310 lines
11 KiB
Python
310 lines
11 KiB
Python
bl_info = {
|
|
'name': 'SWBF .msh Import-Export',
|
|
'author': 'Will Snyder, SleepKiller',
|
|
"version": (1, 0, 0),
|
|
'blender': (2, 80, 0),
|
|
'location': 'File > Import-Export',
|
|
'description': 'Export as SWBF .msh file',
|
|
'warning': '',
|
|
'wiki_url': "https://github.com/SleepKiller/SWBF-msh-Blender-Export/blob/master/docs/reference_manual.md",
|
|
'tracker_url': "https://github.com/SleepKiller/SWBF-msh-Blender-Export/issues",
|
|
'support': 'COMMUNITY',
|
|
'category': 'Import-Export'
|
|
}
|
|
|
|
# Taken from glTF-Blender-IO, because I do not understand Python that well
|
|
# (this is the first thing of substance I've created in it) and just wanted
|
|
# script reloading to work.
|
|
#
|
|
# https://github.com/KhronosGroup/glTF-Blender-IO
|
|
#
|
|
# Copyright 2018-2019 The glTF-Blender-IO authors.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
def reload_package(module_dict_main):
|
|
import importlib
|
|
from pathlib import Path
|
|
|
|
def reload_package_recursive(current_dir, module_dict):
|
|
for path in current_dir.iterdir():
|
|
if "__init__" in str(path) or path.stem not in module_dict:
|
|
continue
|
|
|
|
if path.is_file() and path.suffix == ".py":
|
|
importlib.reload(module_dict[path.stem])
|
|
elif path.is_dir():
|
|
reload_package_recursive(path, module_dict[path.stem].__dict__)
|
|
|
|
reload_package_recursive(Path(__file__).parent, module_dict_main)
|
|
|
|
|
|
if "bpy" in locals():
|
|
reload_package(locals())
|
|
# End of stuff taken from glTF
|
|
|
|
import bpy
|
|
from bpy_extras.io_utils import ExportHelper, ImportHelper
|
|
from bpy.props import BoolProperty, EnumProperty, CollectionProperty
|
|
from bpy.types import Operator, Menu
|
|
from .msh_scene_utilities import create_scene, set_scene_animation
|
|
from .msh_scene_save import save_scene
|
|
from .msh_scene_read import read_scene
|
|
from .msh_material_properties import *
|
|
from .msh_skeleton_properties import *
|
|
from .msh_collision_prim_properties import *
|
|
from .msh_to_blend import *
|
|
from .zaa_to_blend import *
|
|
|
|
|
|
class ExportMSH(Operator, ExportHelper):
|
|
""" Export the current scene as a SWBF .msh file. """
|
|
|
|
bl_idname = "swbf_msh.export"
|
|
bl_label = "Export SWBF .msh File"
|
|
filename_ext = ".msh"
|
|
|
|
filter_glob: StringProperty(
|
|
default="*.msh",
|
|
options={'HIDDEN'},
|
|
maxlen=255, # Max internal buffer length, longer would be clamped.
|
|
)
|
|
|
|
generate_triangle_strips: BoolProperty(
|
|
name="Generate Triangle Strips",
|
|
description="Triangle strip generation can be slow for meshes with thousands of faces "
|
|
"and is off by default to enable fast mesh iteration.\n\n"
|
|
"In order to improve runtime performance and reduce munged model size you are "
|
|
"**strongly** advised to turn it on for your 'final' export!",
|
|
default=False
|
|
)
|
|
|
|
export_target: EnumProperty(name="Export Target",
|
|
description="What to export.",
|
|
items=(
|
|
('SCENE', "Scene", "Export the current active scene."),
|
|
('SELECTED', "Selected", "Export the currently selected objects and their parents."),
|
|
('SELECTED_WITH_CHILDREN', "Selected with Children", "Export the currently selected objects with their children and parents.")
|
|
),
|
|
default='SCENE')
|
|
|
|
apply_modifiers: BoolProperty(
|
|
name="Apply Modifiers",
|
|
description="Whether to apply Modifiers during export or not.",
|
|
default=True
|
|
)
|
|
|
|
|
|
animation_export: EnumProperty(name="Export Animation(s)",
|
|
description="If/how animation data should be exported.",
|
|
items=(
|
|
('NONE', "None", "Do not include animation data in the export."),
|
|
('ACTIVE', "Active", "Export animation extracted from the scene's Armature's active Action."),
|
|
('BATCH', "Batch", "Export a separate animation file for each Action in the scene.")
|
|
),
|
|
default='NONE')
|
|
|
|
|
|
def execute(self, context):
|
|
|
|
scene, armature_obj = create_scene(
|
|
generate_triangle_strips=self.generate_triangle_strips,
|
|
apply_modifiers=self.apply_modifiers,
|
|
export_target=self.export_target,
|
|
skel_only=self.animation_export != 'NONE') # Exclude geometry data (except root stuff) if we're doing anims
|
|
|
|
if self.animation_export != 'NONE' and not armature_obj:
|
|
raise Exception("Could not find an armature object from which to export animations!")
|
|
|
|
|
|
def write_scene_to_file(filepath : str, scene_to_write : Scene):
|
|
with open(filepath, 'wb') as output_file:
|
|
save_scene(output_file=output_file, scene=scene_to_write)
|
|
|
|
if self.animation_export == 'ACTIVE':
|
|
set_scene_animation(scene, armature_obj)
|
|
write_scene_to_file(self.filepath, scene)
|
|
|
|
elif self.animation_export == 'BATCH':
|
|
export_dir = self.filepath if os.path.isdir(self.filepath) else os.path.dirname(self.filepath)
|
|
|
|
for action in bpy.data.actions:
|
|
anim_save_path = os.path.join(export_dir, action.name + ".msh")
|
|
armature_obj.animation_data.action = action
|
|
set_scene_animation(scene, armature_obj)
|
|
write_scene_to_file(anim_save_path, scene)
|
|
else:
|
|
write_scene_to_file(self.filepath, scene)
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
# Only needed if you want to add into a dynamic menu
|
|
def menu_func_export(self, context):
|
|
self.layout.operator(ExportMSH.bl_idname, text="SWBF msh (.msh)")
|
|
|
|
|
|
|
|
class ImportMSH(Operator, ImportHelper):
|
|
""" Import an SWBF .msh file. """
|
|
|
|
bl_idname = "swbf_msh.import"
|
|
bl_label = "Import SWBF .msh File(s)"
|
|
filename_ext = ".msh"
|
|
|
|
files: CollectionProperty(
|
|
name="File Path",
|
|
type=bpy.types.OperatorFileListElement,
|
|
)
|
|
|
|
filter_glob: StringProperty(
|
|
default="*.msh;*.zaa;*.zaabin",
|
|
options={'HIDDEN'},
|
|
maxlen=255, # Max internal buffer length, longer would be clamped.
|
|
)
|
|
|
|
animation_only: BoolProperty(
|
|
name="Import Animation(s)",
|
|
description="Import on or more animations from the selected files and append each as a new Action to currently selected Armature.",
|
|
default=False
|
|
)
|
|
|
|
|
|
def execute(self, context):
|
|
dirname = os.path.dirname(self.filepath)
|
|
for file in self.files:
|
|
filepath = os.path.join(dirname, file.name)
|
|
if filepath.endswith(".zaabin") or filepath.endswith(".zaa"):
|
|
extract_and_apply_munged_anim(filepath)
|
|
else:
|
|
with open(filepath, 'rb') as input_file:
|
|
scene = read_scene(input_file, self.animation_only)
|
|
|
|
if not self.animation_only:
|
|
extract_scene(filepath, scene)
|
|
else:
|
|
extract_and_apply_anim(filepath, scene)
|
|
|
|
return {'FINISHED'}
|
|
|
|
def menu_func_import(self, context):
|
|
self.layout.operator(ImportMSH.bl_idname, text="SWBF msh (.msh)")
|
|
|
|
|
|
|
|
|
|
class FillSWBFMaterialProperties(bpy.types.Operator):
|
|
bl_idname = "swbf_msh.fill_mat_props"
|
|
bl_label = "Fill SWBF Material Properties"
|
|
bl_description = ("Fill in SWBF properties of all materials used by selected objects.\n"
|
|
"Only considers materials that use nodes.\n"
|
|
"Please see 'Materials > Materials Operators' in the docs for more details.")
|
|
|
|
def execute(self, context):
|
|
|
|
slots = sum([list(ob.material_slots) for ob in bpy.context.selected_objects if ob.type == 'MESH'],[])
|
|
mats = [slot.material for slot in slots if (slot.material and slot.material.node_tree)]
|
|
|
|
for mat in mats:
|
|
try:
|
|
for BSDF_node in [n for n in mat.node_tree.nodes if n.type == 'BSDF_PRINCIPLED']:
|
|
base_col = BSDF_node.inputs['Base Color']
|
|
|
|
for link in base_col.links :
|
|
link_node = link.from_node
|
|
|
|
if link_node.type != 'TEX_IMAGE':
|
|
continue
|
|
|
|
tex_name = link_node.image.name
|
|
|
|
i = tex_name.find(".tga")
|
|
|
|
# Get rid of trailing number in case one is present
|
|
if i > 0:
|
|
tex_name = tex_name[0:i+4]
|
|
|
|
mat.swbf_msh_mat.rendertype = 'NORMAL_BF2'
|
|
mat.swbf_msh_mat.diffuse_map = tex_name
|
|
break
|
|
except:
|
|
# Many chances for null ref exceptions. None if user reads doc section...
|
|
pass
|
|
|
|
return {'FINISHED'}
|
|
|
|
|
|
class VIEW3D_MT_SWBF(bpy.types.Menu):
|
|
bl_label = "SWBF"
|
|
|
|
def draw(self, _context):
|
|
layout = self.layout
|
|
layout.operator("swbf_msh.fill_mat_props", text="Fill SWBF Material Properties")
|
|
|
|
|
|
def draw_matfill_menu(self, context):
|
|
layout = self.layout
|
|
layout.separator()
|
|
layout.menu("VIEW3D_MT_SWBF")
|
|
|
|
|
|
|
|
|
|
def register():
|
|
bpy.utils.register_class(CollisionPrimitiveProperties)
|
|
|
|
bpy.utils.register_class(MaterialProperties)
|
|
bpy.utils.register_class(MaterialPropertiesPanel)
|
|
|
|
bpy.utils.register_class(SkeletonProperties)
|
|
bpy.utils.register_class(SkeletonPropertiesPanel)
|
|
|
|
bpy.utils.register_class(ExportMSH)
|
|
bpy.utils.register_class(ImportMSH)
|
|
|
|
bpy.types.TOPBAR_MT_file_export.append(menu_func_export)
|
|
bpy.types.TOPBAR_MT_file_import.append(menu_func_import)
|
|
|
|
bpy.types.Object.swbf_msh_coll_prim = bpy.props.PointerProperty(type=CollisionPrimitiveProperties)
|
|
bpy.types.Material.swbf_msh_mat = bpy.props.PointerProperty(type=MaterialProperties)
|
|
bpy.types.Armature.swbf_msh_skel = bpy.props.CollectionProperty(type=SkeletonProperties)
|
|
|
|
bpy.utils.register_class(FillSWBFMaterialProperties)
|
|
bpy.utils.register_class(VIEW3D_MT_SWBF)
|
|
bpy.types.VIEW3D_MT_object_context_menu.append(draw_matfill_menu)
|
|
|
|
|
|
|
|
def unregister():
|
|
bpy.utils.unregister_class(CollisionPrimitiveProperties)
|
|
|
|
bpy.utils.unregister_class(MaterialProperties)
|
|
bpy.utils.unregister_class(MaterialPropertiesPanel)
|
|
|
|
bpy.utils.unregister_class(SkeletonProperties)
|
|
bpy.utils.unregister_class(SkeletonPropertiesPanel)
|
|
|
|
bpy.utils.unregister_class(ExportMSH)
|
|
bpy.utils.unregister_class(ImportMSH)
|
|
|
|
bpy.types.TOPBAR_MT_file_export.remove(menu_func_export)
|
|
bpy.types.TOPBAR_MT_file_import.remove(menu_func_import)
|
|
|
|
bpy.utils.unregister_class(FillSWBFMaterialProperties)
|
|
|
|
bpy.utils.unregister_class(VIEW3D_MT_SWBF)
|
|
bpy.types.VIEW3D_MT_object_context_menu.remove(draw_matfill_menu)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
register()
|