Add MMD Tools installation feature

Author: UuuNyaa

mmd_tools_append/asset_search/panels.py

@@ -13,7 +13,7 @@
 
 from .. import PACKAGE_PATH
 from ..m17n import _, iface_
-from ..utilities import get_preferences, label_multiline, to_human_friendly_text, to_int32
+from ..utilities import get_preferences, is_mmd_tools_installed, label_multiline, to_human_friendly_text, to_int32
 from .actions import ImportActionExecutor, MessageException
 from .assets import ASSETS, AssetDescription, AssetType
 from .cache import CONTENT_CACHE, Content, Task
@@ -204,7 +204,7 @@ class AssetImport(bpy.types.Operator):
 
     @classmethod
     def poll(cls, context):
-        return bpy.context.mode == "OBJECT"
+        return bpy.context.mode == "OBJECT" and is_mmd_tools_installed()
 
     def execute(self, context):
         print(f"do: {self.bl_idname}")

mmd_tools_append/converters/armatures/panels.py

@@ -4,6 +4,8 @@
 
 import bpy
 
+from ...utilities import is_mmd_tools_installed
+
 from ...m17n import _
 from .autorig import AutoRigArmatureObject
 from .mmd_bind import ControlType
@@ -20,6 +22,9 @@ class MMDRigifyPanel(bpy.types.Panel):
 
     @classmethod
     def poll(cls, context):
+        if not is_mmd_tools_installed():
+            return False
+
         active_object = context.active_object
         if not MMDRigifyArmatureObject.is_rigify_armature_object(active_object):
             return False

mmd_tools_append/converters/physics/cloth.py

@@ -9,14 +9,70 @@
 from ...editors.meshes import MeshEditor
 from ...m17n import _
 from ...tuners import TunerABC, TunerRegistry
-from ...utilities import MessageException, import_mmd_tools
+from ...utilities import MessageException, MMD_TOOLS_IMPORT_HOOKS, import_mmd_tools
 from .rigid_body_to_cloth import (
     PhysicsMode,
     RigidBodyToClothConverter,
 )
 
-mmd_tools = import_mmd_tools()
-if not hasattr(mmd_tools.core.model.Model, "clothGroupObject"):
+
+def on_import_mmd_tools_ensure_cloth_methods(mmd_tools):
+    """
+    Monkey-patch helper that augments mmd_tools.core.model.Model with cloth-related
+    convenience methods if they are not already present.
+
+    Behavior:
+    1. Idempotency: Returns immediately if Model already has the attribute
+        'clothGroupObject', preventing duplicate patching.
+    2. Adds Model.clothGroupObject(self):
+        - Lazily resolves (and caches on the instance as _cloth_grp) a dedicated
+          container object named "cloths" parented to the model's root object.
+        - Searches existing children of rootObject() for an object named "cloths".
+        - If absent, creates a new empty object via mmd_tools.bpyutils.FnContext.new_and_link_object.
+        - Configures the new object to be:
+             * Hidden and unselectable (hide, hide_select = True)
+             * Transform-locked on location, rotation, and scale (all axes True)
+        - Returns the resolved/created container object.
+    3. Adds Model.cloths(self):
+        - Iterates over all objects returned by Model.allObjects(clothGroupObject()).
+        - Yields only MESH type objects that have an existing cloth modifier, as
+          determined by MeshEditor(obj).find_cloth_modifier().
+
+    Side Effects:
+    - Mutates the mmd_tools.core.model.Model class by attaching two methods:
+      'clothGroupObject' and 'cloths'.
+    - May create and link a new helper object named "cloths" into the current
+      Blender context's scene hierarchy.
+
+    Caching Details:
+    - The resolved group object is stored per-model instance in the private
+      attribute _cloth_grp to avoid repeated scene searches or object creation.
+
+    Prerequisites:
+    - A functioning import_mmd_tools() utility returning the mmd_tools module.
+    - Availability of bpy (Blender Python API) and MeshEditor in the execution environment.
+
+    Returns:
+         None
+
+    Raises:
+         None (all operations are performed defensively; absence of expected API
+         components would surface as AttributeError at runtime).
+
+    Usage Pattern:
+         ensure_cloth_methods()
+         model = mmd_tools.core.model.Model(...)
+         grp = model.clothGroupObject()
+         for cloth_obj in model.cloths():
+              ...
+
+    Rationale:
+    - Centralizes the patch so add-on code can safely call ensure_cloth_methods()
+      before relying on the extended API, without risking duplicate definitions.
+    """
+
+    if hasattr(mmd_tools.core.model.Model, "clothGroupObject"):
+        return
 
     def mmd_model_cloth_group_object_method(self):
         # pylint: disable=protected-access
@@ -50,17 +106,12 @@ def mmd_model_cloths_method(self):
                 continue
             yield obj
 
-    def iterate_joint_objects(
-        root_object: bpy.types.Object,
-    ) -> Iterator[bpy.types.Object]:
-        return mmd_tools.core.model.FnModel.iterate_filtered_child_objects(
-            mmd_tools.core.model.FnModel.is_joint_object,
-            mmd_tools.core.model.FnModel.find_joint_group_object(root_object),
-        )
-
     mmd_tools.core.model.Model.cloths = mmd_model_cloths_method
 
 
+MMD_TOOLS_IMPORT_HOOKS.append(on_import_mmd_tools_ensure_cloth_methods)
+
+
 class ClothTunerABC(TunerABC, MeshEditor):
     pass
 
@@ -268,6 +319,7 @@ def poll(cls, context: bpy.types.Context):
     def filter_only_in_mmd_model(
         key_object: bpy.types.Object,
     ) -> Iterable[bpy.types.Object]:
+        mmd_tools = import_mmd_tools()
         mmd_root = mmd_tools.core.model.FnModel.find_root_object(key_object)
         if mmd_root is None:
             return
@@ -362,7 +414,7 @@ def poll(cls, context: bpy.types.Context):
         selected_mesh_mmd_root = None
         selected_rigid_body_mmd_root = None
 
-        mmd_find_root = mmd_tools.core.model.FnModel.find_root_object
+        mmd_find_root = import_mmd_tools().core.model.FnModel.find_root_object
         for obj in context.selected_objects:
             if obj.type != "MESH":
                 return False
@@ -382,7 +434,7 @@ def invoke(self, context, event):
 
     def execute(self, context: bpy.types.Context):
         try:
-            mmd_find_root = mmd_tools.core.model.FnModel.find_root_object
+            mmd_find_root = import_mmd_tools().core.model.FnModel.find_root_object
 
             target_mmd_root_object = None
             rigid_body_objects: List[bpy.types.Object] = []

mmd_tools_append/panels.py

@@ -33,9 +33,23 @@
 )
 from .generators.physics import AddCenterOfGravityObject
 from .m17n import _
-from .utilities import import_mmd_tools
+from .utilities import import_mmd_tools, is_mmd_tools_installed
 
-mmd_tools = import_mmd_tools()
+
+class InstallMMDTools(bpy.types.Operator):
+    bl_idname = "mmd_tools_append.install_mmd_tools"
+    bl_label = _("Install MMD Tools")
+    bl_options = {"REGISTER"}
+
+    @classmethod
+    def poll(cls, _context):
+        return not is_mmd_tools_installed()
+
+    def execute(self, context):
+        bpy.ops.extensions.userpref_allow_online()
+        bpy.ops.extensions.repo_sync(repo_index=0)
+        bpy.ops.extensions.package_install(repo_index=0, pkg_id="mmd_tools")
+        return {"FINISHED"}
 
 
 class OperatorPanel(bpy.types.Panel):
@@ -49,6 +63,11 @@ class OperatorPanel(bpy.types.Panel):
     def draw(self, _context):
         layout = self.layout
 
+        if not is_mmd_tools_installed():
+            layout.label(text=_("MMD Tools is not installed."), icon="ERROR")
+            layout.operator(InstallMMDTools.bl_idname, icon="IMPORT")
+            return
+
         col = layout.column(align=True)
         col.label(text=_("Render:"), icon="SCENE_DATA")
         grid = col.grid_flow(row_major=True, align=True)
@@ -97,6 +116,10 @@ class MMDAppendPhysicsPanel(bpy.types.Panel):
     bl_region_type = "UI"
     bl_category = "MMD"
 
+    @classmethod
+    def poll(cls, context: bpy.types.Context):
+        return is_mmd_tools_installed()
+
     def draw(self, context: bpy.types.Context):
         layout = self.layout
 
@@ -108,7 +131,7 @@ def draw(self, context: bpy.types.Context):
         row.operator(SelectCollisionMesh.bl_idname, text=_(""), icon="RESTRICT_SELECT_OFF")
         row.operator(RemoveMeshCollision.bl_idname, text=_(""), icon="TRASH")
 
-        mmd_root_object = mmd_tools.core.model.FnModel.find_root_object(context.active_object)
+        mmd_root_object = import_mmd_tools().core.model.FnModel.find_root_object(context.active_object)
         if mmd_root_object is None:
             col = layout.column(align=True)
             col.label(text=_("MMD Model is not selected."), icon="ERROR")
@@ -166,11 +189,13 @@ def draw(self, context: bpy.types.Context):
 
     @staticmethod
     def _toggle_visibility_of_cloths(obj, context):
+        mmd_tools = import_mmd_tools()
+
         mmd_root_object = mmd_tools.core.model.FnModel.find_root_object(obj)
         mmd_model = mmd_tools.core.model.Model(mmd_root_object)
         hide = not mmd_root_object.mmd_tools_append_show_cloths
 
-        with mmd_tools.bpyutils.activate_layer_collection(mmd_root_object):
+        with mmd_tools.bpyutils.FnContext.temp_override_active_layer_collection(context, mmd_root_object):
             cloth_object: bpy.types.Object
             for cloth_object in mmd_model.cloths():
                 cloth_object.hide = hide
@@ -197,7 +222,7 @@ class MMDAppendSegmentationPanel(bpy.types.Panel):
 
     @classmethod
     def poll(cls, context: bpy.types.Context):
-        return context.mode in {"PAINT_VERTEX", "EDIT_MESH"}
+        return is_mmd_tools_installed() and context.mode in {"PAINT_VERTEX", "EDIT_MESH"}
 
     def draw(self, context: bpy.types.Context):
         layout = self.layout

mmd_tools_append/tuners/panels.py

@@ -5,6 +5,7 @@
 
 import bpy
 
+from ..utilities import is_mmd_tools_installed
 from ..editors.nodes import MaterialEditor
 from ..m17n import _, iface_
 from ..tuners.lighting_tuners import LightingUtilities
@@ -122,7 +123,7 @@ class MaterialPanel(bpy.types.Panel):
     @classmethod
     def poll(cls, context):
         obj = context.active_object
-        return obj.active_material and obj.mmd_type == "NONE"
+        return is_mmd_tools_installed() and obj.active_material and obj.mmd_type == "NONE"
 
     def draw(self, context):
         material = context.active_object.active_material

mmd_tools_append/utilities.py

@@ -3,9 +3,11 @@
 # This file is part of MMD Tools Append.
 
 import hashlib
-import importlib
+import importlib.util
+import logging
 import math
 import re
+import sys
 
 import bpy
 
@@ -56,24 +58,52 @@ def import_from_file(module_name: str, module_path: str):
         raise ImportError(f"Cannot load module '{module_name}' from '{module_path}'")
 
     module = importlib.util.module_from_spec(spec)
-    # Optional: cache in sys.modules to avoid reloading
-    import sys
-
     sys.modules[module_name] = module  # ensures single instance if repeatedly called
     spec.loader.exec_module(module)  # type: ignore[attr-defined]
     return module
 
 
+def is_mmd_tools_installed():
+    candidates = (
+        "bl_ext.blender_org.mmd_tools",
+        "bl_ext.vscode_development.mmd_tools",
+    )
+
+    for name in candidates:
+        if name in sys.modules or importlib.util.find_spec(name) is not None:
+            return True
+
+    return False
+
+
+_MMD_TOOLS_CACHE = None
+
+MMD_TOOLS_IMPORT_HOOKS = []
+
+
 def import_mmd_tools():
+    global _MMD_TOOLS_CACHE
+    global MMD_TOOLS_IMPORT_HOOKS
+
+    if _MMD_TOOLS_CACHE is not None:
+        return _MMD_TOOLS_CACHE
+
     try:
-        return importlib.import_module("bl_ext.blender_org.mmd_tools")
+        _MMD_TOOLS_CACHE = importlib.import_module("bl_ext.blender_org.mmd_tools")
     except ImportError as exception:
-        # for debugging
         try:
-            return importlib.import_module("bl_ext.vscode_development.mmd_tools")
+            _MMD_TOOLS_CACHE = importlib.import_module("bl_ext.vscode_development.mmd_tools")
         except ImportError:
             raise RuntimeError(_("MMD Tools is not installed correctly. Please install MMD Tools using the correct steps, as MMD Tools Append depends on MMD Tools.")) from exception
 
+    for hook in MMD_TOOLS_IMPORT_HOOKS:
+        try:
+            hook(_MMD_TOOLS_CACHE)
+        except:
+            logging.exception(f"Warning: An error occurred in import_mmd_tools hook {hook}")
+
+    return _MMD_TOOLS_CACHE
+
 
 def label_multiline(layout, text="", width=0):
     if text.strip() == "":