Merge branch 'Digitigrade-legs-tool' of https://github.com/989onan/Avatar-Toolkit into Digitigrade-legs-tool

.gitignore

@@ -1,2 +1,3 @@
 
 *.pyc
+.vscode/settings.json

__init__.py

@@ -6,34 +6,38 @@ if "bpy" not in locals():
     from .core import register
     from .core.register import __bl_ordered_classes
     from .core import properties
+    from .core import addon_preferences
 else:
     import importlib
     importlib.reload(ui)
     importlib.reload(core)
     importlib.reload(functions)
     importlib.reload(properties)
+    importlib.reload(addon_preferences)
 
 def register():
     print("Registering Avatar Toolkit")
     # Register the addon properties
     properties.register()
+
+    # Load the translations
+    functions.translations.load_translations()
+
     # Order the classes before registration
     core.register.order_classes()
-    register_properties()
+    # Register the properties
-    # Register the UI classes
-    
-    # Iterate over the classes to register and register them
     core.register.register_properties()
-    for cls in core.register.__bl_ordered_classes:
+    # Register the UI classes
-        print("registering " + str(cls))
+    for cls in __bl_ordered_classes:
-        bpy.utils.register_class(cls)
+        print("registering" + str(cls))
+        bpy.utils.register_class(cls)   
 
 def unregister():
     print("Unregistering Avatar Toolkit")
     # Unregister the UI classes
 
     # Iterate over the classes to unregister in reverse order and unregister them
-    for cls in reversed(core.register.__bl_ordered_classes):
+    for cls in reversed(list(__bl_ordered_classes)):
         bpy.utils.unregister_class(cls)
         print("unregistering " + str(cls))
     core.register.unregister_properties()

core/addon_preferences.py

@@ -0,0 +1,43 @@
+import bpy
+import os
+import json
+from bpy.types import AddonPreferences
+from typing import Any, Dict
+
+# Get the directory of the current file
+PREFERENCES_DIR = os.path.dirname(os.path.abspath(__file__))
+PREFERENCES_FILE = os.path.join(PREFERENCES_DIR, "preferences.json")
+
+def save_preference(key: str, value: Any) -> None:
+    """Save a single preference to the JSON file."""
+    prefs = load_preferences()
+    prefs[key] = value
+    with open(PREFERENCES_FILE, 'w') as f:
+        json.dump(prefs, f, indent=4)
+
+def load_preferences() -> Dict[str, Any]:
+    """Load all preferences from the JSON file."""
+    if os.path.exists(PREFERENCES_FILE):
+        with open(PREFERENCES_FILE, 'r') as f:
+            return json.load(f)
+    return {}
+
+def get_preference(key: str, default: Any = None) -> Any:
+    """Get a single preference from the JSON file."""
+    prefs = load_preferences()
+    return prefs.get(key, default)
+
+class AvatarToolkitPreferences(AddonPreferences):
+    bl_idname = __package__.rsplit('.', 1)[0]
+
+    def draw(self, context):
+        layout = self.layout
+        layout.label(text="Preferences are managed internally.")
+        # You can add more UI elements here if needed
+
+def get_addon_preferences(context):
+    return context.preferences.addons[AvatarToolkitPreferences.bl_idname].preferences
+
+# Initialize preferences if the file doesn't exist
+if not os.path.exists(PREFERENCES_FILE):
+    save_preference("language", 0)  # Set default language to 0 (auto)

core/export_resonite.py

@@ -5,13 +5,14 @@ from .common import get_armature
 from bpy.types import Object, ShapeKey, Mesh, Context, Operator
 from functools import lru_cache
 from ..core.register import register_wrap
+from ..functions.translations import t
 
 
 @register_wrap
 class ExportResonite(Operator):
     bl_idname = 'avatar_toolkit.export_resonite'
-    bl_label = "Export to Resonite"
+    bl_label = t("Export.resonite.label")
-    bl_description = "Export a GLB with all animations and materials. For animation data see: "
+    bl_description = t("Export.resonite.desc")
     bl_options = {'REGISTER', 'UNDO'}
     filepath: bpy.props.StringProperty()
 

core/properties.py

@@ -1,94 +1,20 @@
 import bpy
-from ..functions.translations import t, get_languages_list, update_ui
-from ..core.register import register_property
-from typing import Tuple
-from bpy.types import Scene, PropertyGroup, Object, Material, TextureNode, Context, SceneObjects
-from bpy.props import BoolProperty, EnumProperty, FloatProperty, IntProperty, CollectionProperty, StringProperty, FloatVectorProperty, PointerProperty
-from bpy.utils import register_class
-from ..functions.translations import t, get_languages_list, update_language
-from ..core.addon_preferences import get_preference
 
-
+def register():
-class material_list_bool:
+    default_language = get_preference("language", 0)
-    #For the love that is holy do not ever touch these. If this was java I would make these private
-    #They should only be accessed via context.scene.texture_atlas_Has_Mat_List_Shown
-    #This is so we know if the materials are up to date. messing with these variables directly will make the thing blow up.
     
-    #The only exception to this is the ExpandSection_Materials operator which populates this with new data once the materials have changed and need reloading.
+    bpy.types.Scene.avatar_toolkit_language = bpy.props.EnumProperty(
-    old_list: dict[str,list[Material]] = {}
+        name=t("Settings.language.label", "Language"),
-    bool_material_list_expand: dict[str,bool] = {}
+        description=t("Settings.language.desc", "Select the language for the addon"),
-
-    def set_bool(self, value: bool) -> None:
-        material_list_bool.bool_material_list_expand[bpy.context.scene.name] = value
-        if value == False:
-            material_list_bool.old_list[bpy.context.scene.name] = []
-
-    def get_bool(self) -> bool:
-            newlist: list[Material] = []
-            for obj in bpy.context.scene.objects:
-                if len(obj.material_slots)>0:
-                    for mat_slot in obj.material_slots:
-                        if mat_slot.material:
-                            if mat_slot.material not in newlist:
-                                newlist.append(mat_slot.material)
-            
-            still_the_same: bool = True
-            if bpy.context.scene.name in material_list_bool.old_list:
-                for item in newlist:
-                    if item not in material_list_bool.old_list[bpy.context.scene.name]:
-                        still_the_same = False
-                        break
-                for item in material_list_bool.old_list[bpy.context.scene.name]:
-                    if item not in newlist:
-                        still_the_same = False
-                        break
-            else:
-                still_the_same = False
-            material_list_bool.bool_material_list_expand[bpy.context.scene.name] = still_the_same
-            
-            return material_list_bool.bool_material_list_expand[bpy.context.scene.name]
-
-class SceneMatClass(PropertyGroup):
-    mat: PointerProperty(type=Material)
-
-def register() -> None:
-    register_property((Scene, "language", bpy.props.EnumProperty(
-        name=t("Settings.language.label"),
-        description=t("Settings.language.desc"),
         items=get_languages_list,
-        update=update_ui
+        default=default_language,
-    )))
+        update=update_language
+    )
     
-    register_class(SceneMatClass)
+    bpy.types.Scene.avatar_toolkit_language_changed = bpy.props.BoolProperty(default=False)
-
+def unregister():
-    #happy with how compressed this get_texture_node_list method is - @989onan
+    if hasattr(bpy.types.Scene, "avatar_toolkit_language"):
-    def get_texture_node_list(self: Material, context: Context) -> list[set[3]]:
+        del bpy.types.Scene.avatar_toolkit_language
-        if self.use_nodes:
-            Object.Enum = [((i.image.name if i.image else i.name+"_image"),(i.image.name if i.image else "node with no image..."),(i.image.name if i.image else i.name),index+1) for index,i in enumerate(self.node_tree.nodes) if i.bl_idname == "ShaderNodeTexImage"]
-            if not len(Object.Enum):
-                Object.Enum = [("ERROR", "THIS MATERIAL HAS NO IMAGES!", "ERROR", 0)]
-        else:
-            Object.Enum = [("ERROR", "THIS MATERIAL DOES NOT USE NODES!", "ERROR", 0)]
-        Object.Enum.append(("None", "None", "None", 0))
-        return Object.Enum
-
         
-    
+    if hasattr(bpy.types.Scene, "avatar_toolkit_language_changed"):
-    register_property(Material, "texture_atlas_albedo", EnumProperty(name="Albedo", description="The texture that will be used for the albedo map atlas", default=0, items=get_texture_node_list))
+        del bpy.types.Scene.avatar_toolkit_language_changed
-    register_property(Material, "texture_atlas_normal", EnumProperty(name="Normal", description="The texture that will be used for the normal map atlas", default=0, items=get_texture_node_list))
-    register_property(Material, "texture_atlas_emission", EnumProperty(name="Emission", description="The texture that will be used for the emission map atlas", default=0, items=get_texture_node_list))
-    register_property(Material, "texture_atlas_ambient_occlusion", EnumProperty(name="Ambient Occlusion", description="The texture that will be used for the ambient occlusion map atlas", default=0, items=get_texture_node_list))
-    register_property(Material, "texture_atlas_height", EnumProperty(name="Height", description="The texture that will be used for the height map atlas", default=0, items=get_texture_node_list))
-    register_property(Material, "texture_atlas_roughness", EnumProperty(name="Roughness", description="The texture that will be used for the roughness map atlas", default=0, items=get_texture_node_list))
-    
-    register_property(Scene, "texture_atlas_material_index", IntProperty(default=-1, get=(lambda self : -1), set=(lambda self,context : None)))
-
-    
-
-
-    register_property(Scene, "materials", CollectionProperty(type=SceneMatClass))
-
-    register_property(Scene, "texture_atlas_Has_Mat_List_Shown", BoolProperty(default=False, get=material_list_bool.get_bool, set=material_list_bool.set_bool))
-
-def unregister() -> None:
-    pass

core/register.py

@@ -1,5 +1,6 @@
 import bpy
 import typing
+from typing import List, Type
 
 # List to store the classes to register
 __bl_classes = []
@@ -21,8 +22,11 @@ def register_property(prop):
 
 def register_properties():
     for prop in __bl_props:
-        setattr(prop[0], prop[1], prop[2])
+        if isinstance(prop[2], bpy.props._PropertyDeferred):
-
+            setattr(prop[0], prop[1], prop[2])
+        else:
+            prop() 
+            
 def unregister_properties():
     for prop in reversed(__bl_props):
         delattr(prop[0], prop[1])
@@ -109,4 +113,3 @@ def toposort(deps_dict):
         deps_dict = {value : deps_dict[value] - sorted_values for value in unsorted}
     
     return sorted_list
-

functions/combine_materials.py

@@ -4,6 +4,7 @@ from typing import List, Tuple, Optional
 from bpy.types import Material, Operator, Context, Object
 from ..core.common import clean_material_names
 from ..core.register import register_wrap
+from ..functions.translations import t
 
 def textures_match(tex1: bpy.types.ImageTexture, tex2: bpy.types.ImageTexture) -> bool:
     return tex1.image == tex2.image and tex1.extension == tex2.extension
@@ -58,8 +59,8 @@ def report_consolidated(self: Operator, num_combined: int) -> None:
 @register_wrap
 class CombineMaterials(Operator):
     bl_idname = "avatar_toolkit.combine_materials"
-    bl_label = "Combine Materials"
+    bl_label = t("Optimization.combine_materials.label")
-    bl_description = "Combine similar materials to optimize the model"
+    bl_description = t("Optimization.combine_materials.desc")
     bl_options = {'REGISTER', 'UNDO'}
 
     @classmethod

functions/join_meshes.py

@@ -3,12 +3,13 @@ from typing import List, Optional
 from bpy.types import Operator, Context, Object
 from ..core.register import register_wrap
 from ..core.common import fix_uv_coordinates
+from ..functions.translations import t
 
 @register_wrap
 class JoinAllMeshes(Operator):
     bl_idname = "avatar_toolkit.join_all_meshes"
-    bl_label = "Join All Meshes"
+    bl_label = t("Optimization.join_all_meshes.label")
-    bl_description = "Join all meshes in the scene"
+    bl_description = t("Optimization.join_all_meshes.desc")
     bl_options = {'REGISTER', 'UNDO'}
 
     @classmethod
@@ -45,8 +46,8 @@ class JoinAllMeshes(Operator):
 @register_wrap
 class JoinSelectedMeshes(Operator):
     bl_idname = "avatar_toolkit.join_selected_meshes"
-    bl_label = "Join Selected Meshes"
+    bl_label = t("Optimization.join_selected_meshes.label")
-    bl_description = "Join selected meshes"
+    bl_description = t("Optimization.join_selected_meshes.desc")
     bl_options = {'REGISTER', 'UNDO'}
 
     @classmethod

functions/remove_doubles_safely.py

@@ -0,0 +1,140 @@
+from ast import Dict
+from itertools import count
+import bpy
+import re
+from typing import List, Tuple, Optional, TypedDict
+from bpy.types import Material, Operator, Context, Object
+from ..core.register import register_wrap
+from ..core.common import get_armature
+
+
+class meshEntry(TypedDict):
+    mesh: bpy.types.Object
+    shapekeys: list[str]
+
+@register_wrap
+class RemoveDoublesSafely(Operator):
+    bl_idname = "avatar_toolkit.remove_doubles_safely"
+    bl_label = "Remove Doubles Safely"
+    bl_description = "Remove Doubles on all meshes, making sure to not fuse things like mouths together."
+    bl_options = {'REGISTER', 'UNDO'}
+    objects_to_do: list[meshEntry] = []
+    merge_distance: bpy.props.FloatProperty(default=0.0001)
+
+    @classmethod
+    def poll(cls, context: Context) -> bool:
+        return context.mode == 'OBJECT'
+
+    def execute(self, context: Context) -> set:
+        if not bpy.data.objects:
+            self.report({'INFO'}, "No objects in the scene")
+            return
+
+        bpy.ops.object.mode_set(mode='OBJECT')
+        bpy.ops.object.select_all(action='DESELECT')
+        objects: List[Object] =  get_armature(context).children if get_armature(context) else context.view_layer.objects
+
+        meshes: List[Object] = [obj for obj in objects if obj.type == 'MESH']  
+        
+        for mesh in meshes:
+            if mesh.data.name not in [stored_object["mesh"].data.name for stored_object in self.objects_to_do]:
+                mesh_shapekeys = {"mesh":mesh,"shapekeys":[]}
+                mesh_data: bpy.types.Mesh = mesh.data
+                shape: bpy.types.ShapeKey = None
+                if mesh_data.shape_keys:
+                    for shape in mesh_data.shape_keys.key_blocks:
+                        mesh_shapekeys["shapekeys"].append(shape.name)
+                self.objects_to_do.append(mesh_shapekeys)
+                
+        
+        return {'FINISHED'}
+        
+    def invoke(self, context: Context, event: bpy.types.Event) -> set:
+
+        self.execute(context)
+        context.window_manager.modal_handler_add(self)
+        return {'RUNNING_MODAL'}
+    
+    def modify_mesh(self, context: Context, mesh: meshEntry):
+        mesh["mesh"].select_set(True)
+        context.view_layer.objects.active = mesh["mesh"]
+        context.view_layer.objects.active = mesh["mesh"]
+        mesh_data: bpy.types.Mesh = mesh["mesh"].data
+        bpy.ops.object.mode_set(mode='EDIT')
+        
+        
+        bpy.ops.object.mode_set(mode='OBJECT')
+        for index, point in enumerate(mesh["mesh"].active_shape_key.points):
+            if point.co.xyz != mesh_data.shape_keys.key_blocks[0].points[index].co.xyz:
+                mesh_data.vertices[index].select = True
+                print("shapekey has a moved vertex at index \""+str(index)+"\", excluding from double merging!")
+        bpy.ops.object.mode_set(mode='EDIT')
+        
+        
+
+
+        bpy.ops.object.mode_set(mode='OBJECT')
+        mesh["mesh"].select_set(False)
+
+
+    def modal(self, context: Context, event: bpy.types.Event) -> set:
+        
+        
+        
+
+        if len(self.objects_to_do) > 0:
+            mesh = self.objects_to_do[0]
+            mesh_data: bpy.types.Mesh = mesh["mesh"].data
+            if len(mesh['shapekeys']) > 0:
+                shapekeyname: str = mesh['shapekeys'].pop(0)
+                
+                target_shapekey: int = mesh_data.shape_keys.key_blocks.find(shapekeyname)
+                mesh["mesh"].active_shape_key_index = target_shapekey
+                print("doing shapekey \""+shapekeyname+"\" on mesh \""+mesh['mesh'].name+"\".")
+                self.modify_mesh(context, mesh)
+
+            elif not (mesh_data.shape_keys):
+                print("doing mesh with no shapekeys named \""+mesh['mesh'].name+"\".")
+                mesh["mesh"].select_set(True)
+                context.view_layer.objects.active = mesh["mesh"]
+                bpy.ops.object.mode_set(mode='EDIT')
+                mesh_data.vertices.foreach_set("select",[False]*len(mesh_data.vertices))
+    
+                bpy.ops.mesh.select_all(action="INVERT")
+                bpy.ops.mesh.remove_doubles(threshold=self.merge_distance,use_unselected=False)
+
+                bpy.ops.object.mode_set(mode='OBJECT')
+                mesh["mesh"].select_set(False)
+                self.objects_to_do.pop(0)
+            else:
+                mesh["mesh"].select_set(True)
+                context.view_layer.objects.active = mesh["mesh"]
+                bpy.ops.object.mode_set(mode='EDIT')
+
+                bpy.ops.mesh.select_all(action="INVERT")
+                bpy.ops.mesh.remove_doubles(threshold=self.merge_distance,use_unselected=False)
+                
+                bpy.ops.object.mode_set(mode='OBJECT')
+                mesh["mesh"].select_set(False)
+                
+                self.objects_to_do.pop(0)
+                if len(self.objects_to_do) > 0:
+                    mesh = self.objects_to_do[0]
+                    mesh["mesh"].select_set(True)
+                    context.view_layer.objects.active = mesh["mesh"]
+                    bpy.ops.object.mode_set(mode='EDIT')
+                    mesh_data.vertices.foreach_set("select",[False]*len(mesh_data.vertices))
+                    bpy.ops.object.mode_set(mode='OBJECT')
+                    mesh["mesh"].select_set(False)
+
+        else:
+            return {'FINISHED'}
+        
+        return {'RUNNING_MODAL'}
+                
+                
+                
+
+
+
+

functions/resonite_functions.py

@@ -5,12 +5,13 @@ import re
 from bpy.types import Operator, Context, Object
 from ..core.dictionaries import bone_names
 from ..core.common import get_armature, simplify_bonename
+from ..functions.translations import t
 
 @register_wrap
 class ConvertToResonite(Operator):
     bl_idname = 'avatar_toolkit.convert_to_resonite'
-    bl_label = "Convert to Resonite" #t('Tools.convert_to_resonite.label')
+    bl_label = t('Tools.convert_to_resonite.label')
-    bl_description = "Converts bone names on a model to names compatable with Resonite" #t('Tools.convert_to_resonite.desc')
+    bl_description = t('Tools.convert_to_resonite.desc')
     bl_options = {'REGISTER', 'UNDO'}
 
     @classmethod

functions/translations.py

@@ -2,63 +2,95 @@ import os
 import json
 import bpy
 from bpy.app.translations import locale
-from ..core.register import register_wrap
 from typing import Dict, List, Tuple
+from ..core.addon_preferences import save_preference, get_preference
 
-main_dir: str = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+# Use __file__ to get the current file's directory
-resources_dir: str = os.path.join(main_dir, "resources")
+current_dir = os.path.dirname(os.path.abspath(__file__))
-translations_dir: str = os.path.join(resources_dir, "translations")
+main_dir = os.path.dirname(current_dir)
+resources_dir = os.path.join(main_dir, "resources")
+translations_dir = os.path.join(resources_dir, "translations")
 
 dictionary: Dict[str, str] = dict()
 languages: List[str] = []
 verbose: bool = True
 
-def load_translations() -> None:
+def load_translations() -> bool:
     global dictionary, languages
 
+    old_dictionary = dictionary.copy()
+
     dictionary = dict()
     languages = ["auto"]
 
-    language: str = bpy.context.preferences.view.language
+    # Populate languages list
-
     for i in os.listdir(translations_dir):
-        languages.append(i.split(".")[0])
+        lang = i.split(".")[0]
+        if lang != "auto":
+            languages.append(lang)
+
+    language_index = get_preference("language", 0)
+    print(f"Loading translations for language index: {language_index}")  # Debug print
+
+    if language_index == 0:  # "auto"
+        language = bpy.context.preferences.view.language
+    else:
+        try:
+            language = languages[language_index]
+        except IndexError:
+            language = bpy.context.preferences.view.language
+
+    print(f"Selected language: {language}")  # Debug print
 
     translation_file: str = os.path.join(translations_dir, language + ".json")
     if os.path.exists(translation_file):
         with open(translation_file, 'r', encoding='utf-8') as file:
             dictionary = json.load(file)["messages"]
+        print(f"Loaded translations: {dictionary}")  # Debug print
     else:
         custom_language: str = language.split("_")[0]
         custom_translation_file: str = os.path.join(translations_dir, custom_language + ".json")
         if os.path.exists(custom_translation_file):
             with open(custom_translation_file, 'r', encoding='utf-8') as file:
                 dictionary = json.load(file)["messages"]
+            print(f"Loaded custom translations: {dictionary}")  # Debug print
         else:
             print(f"Translation file not found for language: {language}")
             default_file: str = os.path.join(translations_dir, "en_US.json")
             if os.path.exists(default_file):
                 with open(default_file, 'r', encoding='utf-8') as file:
                     dictionary = json.load(file)["messages"]
+                print(f"Loaded default translations: {dictionary}")  # Debug print
             else:
                 print("Default translation file 'en_US.json' not found.")
+    return dictionary != old_dictionary
 
 def t(phrase: str, *args, **kwargs) -> str:
     output: str = dictionary.get(phrase)
     if output is None:
         if verbose:
-            print('Warning: Unknown phrase: ' + phrase)
+            print(f'Warning: Unknown phrase: {phrase}')
-        return phrase
+        return default if default is not None else phrase
-    return output.format(*args, **kwargs)
+    print(f"Translating '{phrase}' to '{output}'")  # Debug print
+    return output
+
+def get_language_display_name(lang: str) -> str:
+    if lang == "auto":
+        return t("Language.auto", "Automatic")
+    return t(f"Language.{lang}", lang)
 
 def get_languages_list(self, context) -> List[Tuple[str, str, str]]:
-    choices: List[Tuple[str, str, str]] = []
+    return [(str(i), get_language_display_name(lang), f"Use {lang} language") for i, lang in enumerate(languages)]
-    for language in languages:
-        choices.append((language, language, language))
-    return choices
 
-def update_ui(self, context) -> None:
+def update_language(self, context):
+    print(f"Updating language to: {self.avatar_toolkit_language}")  # Debug print
+    save_preference("language", int(self.avatar_toolkit_language))
     load_translations()
-    bpy.ops.wm.redraw_timer(type='DRAW_WIN_SWAP', iterations=1)
+    # Set a flag to indicate that a language change has occurred
+    context.scene.avatar_toolkit_language_changed = True
+    # Show popup after language change
+    bpy.ops.avatar_toolkit.translation_restart_popup('INVOKE_DEFAULT')
 
+# Initial load of translations
+print("Performing initial load of translations")  # Debug print
 load_translations()

resources/translations/en_US.json

@@ -1,9 +1,42 @@
 {
-    "messages": {
+  "authors": ["Avatar Toolkit Team"],  
+  "messages": {
+      "Language.auto": "Automatic",
+      "Language.en_US": "English",
+      "Language.ja_JP": "日本語",
+      "Quick_Access.label": "Quick Access",
+      "Quick_Access.import_export.label": "Import/Export",
+      "Quick_Access.options": "Quick Access Options",
+      "Quick_Access.import_menu.label": "Import Menu",
+      "Quick_Access.import": "Import",
+      "Quick_Access.export": "Export",
+      "Quick_Access.import_pmx": "Import PMX",
+      "Quick_Access.import_pmx.desc": "Import MMD PMX Model",
+      "Quick_Access.import_pmd": "Import PMD",
+      "Quick_Access.import_pmd.desc": "Import MMD PMD Model",
+      "Quick_Access.export_menu.label": "Export Menu",
+      "Quick_Access.select_export.label": "Select Export Method",
+      "Quick_Access.select_export_resonite.label": "Resonite",
+      "Export.resonite.label": "Export to Resonite",
+      "Export.resonite.desc": "Export a GLB with all animations and materials. For animation data see:",
+      "Optimization.label": "Optimization",
+      "Optimization.options.label": "Optimization Options",
+      "Optimization.combine_materials.label": "Combine Materials",
+      "Optimization.combine_materials.desc": "Combine similar materials to optimize the model",
+      "Optimization.join_all_meshes.label": "Join All Meshes",
+      "Optimization.join_all_meshes.desc": "Join all meshes into one",
+      "Optimization.join_selected_meshes.label": "Join Selected Mehses",
+      "Optimization.join_selected_meshes.desc": "Join all currntly Selected Mehses into one",
+      "Tools.tools_title.label": "Tools",
+      "Tools.convert_to_resonite.label": "Convert to Resonite",
+      "Tools.convert_to_resonite.desc": "Converts bone names on a model to names compatable with Resonite",
       "Settings.label": "Settings",
       "Settings.language.label": "Language",
-      "Settings.language.desc": "Select the language for the addon's UI"
+      "Settings.language.desc": "Select the language for the addon's UI",
+      "Settings.translation_restart_popup.label": "Translation Update",
+      "Settings.translation_restart_popup.description": "Information about translation updates",
+      "Settings.translation_restart_popup.message1": "Some translations may not apply",
+      "Settings.translation_restart_popup.message2": "until you restart Blender."
     }
   }
-  
   

resources/translations/ja_JP.json

@@ -1,8 +1,41 @@
 {
-    "messages": {
+  "authors": ["Avatar Toolkit Team"],  
-      "Settings.label": "Settings Ja Test",
+  "messages": {
-      "Settings.language.label": "Language Ja Test",
+    "Language.auto": "Automatic",
-      "Settings.language.desc": "Select the language for the addon's UI Ja Test"
+    "Language.en_US": "English",
-    }
+    "Language.ja_JP": "日本語",
+    "Quick_Access.label": "クイックアクセス",
+    "Quick_Access.import_export.label": "インポート/エクスポート",
+    "Quick_Access.options": "クイックアクセスオプション",
+    "Quick_Access.import_menu.label": "インポートメニュー",
+    "Quick_Access.import": "インポート",
+    "Quick_Access.export": "エクスポート",
+    "Quick_Access.import_pmx": "PMXインポート",
+    "Quick_Access.import_pmx.desc": "MMD PMXモデルをインポート",
+    "Quick_Access.import_pmd": "PMDインポート",
+    "Quick_Access.import_pmd.desc": "MMD PMDモデルをインポート",
+    "Quick_Access.export_menu.label": "エクスポートメニュー",
+    "Quick_Access.select_export.label": "エクスポート方法を選択",
+    "Quick_Access.select_export_resonite.label": "Resonite",
+    "Export.resonite.label": "Resoniteにエクスポート",
+    "Export.resonite.desc": "すべてのアニメーションとマテリアルを含むGLBをエクスポートします。アニメーションデータについては以下を参照してください：",
+    "Optimization.label": "最適化",
+    "Optimization.options.label": "最適化オプション",
+    "Optimization.combine_materials.label": "マテリアルを結合",
+    "Optimization.combine_materials.desc": "類似したマテリアルを結合してモデルを最適化します",
+    "Optimization.join_all_meshes.label": "すべてのメッシュを結合",
+    "Optimization.join_all_meshes.desc": "すべてのメッシュを1つに結合します",
+    "Optimization.join_selected_meshes.label": "選択したメッシュを結合",
+    "Optimization.join_selected_meshes.desc": "現在選択されているすべてのメッシュを1つに結合します",
+    "Tools.tools_title.label": "ツール",
+    "Tools.convert_to_resonite.label": "Resoniteに変換",
+    "Tools.convert_to_resonite.desc": "モデルのボーン名をResoniteと互換性のある名前に変換します",
+    "Settings.label": "設定",
+    "Settings.language.label": "言語",
+    "Settings.language.desc": "アドオンのUI言語を選択してください",
+    "Settings.translation_restart_popup.label": "翻訳の更新",
+    "Settings.translation_restart_popup.description": "翻訳の更新に関する情報",
+    "Settings.translation_restart_popup.message1": "一部の翻訳は適用されない場合があります",
+    "Settings.translation_restart_popup.message2": "Blenderを再起動するまで。"
   }
-  
+}

ui/optimization.py

@@ -1,10 +1,11 @@
 import bpy
 from ..core.register import register_wrap
 from .panel import AvatarToolkitPanel
+from ..functions.translations import t
 
 @register_wrap
 class AvatarToolkitOptimizationPanel(bpy.types.Panel):
-    bl_label = "Optimization"
+    bl_label = t("Optimization.label")
     bl_idname = "OBJECT_PT_avatar_toolkit_optimization"
     bl_space_type = 'VIEW_3D'
     bl_region_type = 'UI'
@@ -13,18 +14,20 @@ class AvatarToolkitOptimizationPanel(bpy.types.Panel):
 
     def draw(self, context):
         layout = self.layout
-        layout.label(text="Optimization Options")
+        layout.label(text=t("Optimization.options.label"))
         
         row = layout.row()
         row.scale_y = 1.2 
-        row.operator("avatar_toolkit.combine_materials", text="Combine Materials")
+        row.operator("avatar_toolkit.combine_materials", text=t("Optimization.combine_materials.label"))
+        
 
         layout.separator(factor=0.5)
         
         row = layout.row(align=True)
         row.scale_y = 1.2 
-        row.operator("avatar_toolkit.join_all_meshes", text="Join All Meshes")
+        row.operator("avatar_toolkit.join_all_meshes", text=t("Optimization.join_all_meshes.label"))
-        row.operator("avatar_toolkit.join_selected_meshes", text="Join Selected Meshes")
+        row.operator("avatar_toolkit.join_selected_meshes", text=t("Optimization.join_selected_meshes.label"))
+        row.operator("avatar_toolkit.remove_doubles_safely", text="Remove Doubles Safely")
 
         # Add optimization options here
 

ui/panel.py

@@ -1,5 +1,6 @@
 import bpy
 from ..core.register import register_wrap
+from ..functions.translations import t
 
 @register_wrap
 class AvatarToolkitPanel(bpy.types.Panel):

ui/quick_access.py

@@ -2,6 +2,7 @@ import bpy
 from ..core.register import register_wrap
 from .panel import AvatarToolkitPanel
 from bpy.types import Context
+from ..functions.translations import t
 
 from ..core.import_pmx import import_pmx
 from ..core.import_pmd import import_pmd
@@ -9,7 +10,7 @@ from ..core.importer import import_fbx
 
 @register_wrap
 class AvatarToolkitQuickAccessPanel(bpy.types.Panel):
-    bl_label = "Quick Access"
+    bl_label = t("Quick_Access.label")
     bl_idname = "OBJECT_PT_avatar_toolkit_quick_access"
     bl_space_type = 'VIEW_3D'
     bl_region_type = 'UI'
@@ -18,22 +19,23 @@ class AvatarToolkitQuickAccessPanel(bpy.types.Panel):
 
     def draw(self, context: Context):
         layout = self.layout
-        layout.label(text="Quick Access Options")
+        layout.label(text=t("Quick_Access.options"))
-    
+
         row = layout.row()
-        row.label(text="Import/Export", icon='IMPORT')
+        row.label(text=t("Quick_Access.import_export.label"), icon='IMPORT')
         
         layout.separator(factor=0.5)
 
         row = layout.row(align=True)
         row.scale_y = 1.5  
-        row.operator("avatar_toolkit.import_menu", text="Import")
+        row.operator("avatar_toolkit.import_menu", text=t("Quick_Access.import"))
-        row.operator("avatar_toolkit.export_menu", text="Export")
+        row.operator("avatar_toolkit.export_menu", text=t("Quick_Access.export"))
 
 @register_wrap
 class AVATAR_TOOLKIT_OT_import_menu(bpy.types.Operator):
     bl_idname = "avatar_toolkit.import_menu"
-    bl_label = "Import Menu"
+    bl_label = t("Quick_Access.import_menu.label")
+    bl_description = t("Quick_Access.import_menu.desc")
 
     def execute(self, context: Context):
         return {'FINISHED'}
@@ -45,14 +47,15 @@ class AVATAR_TOOLKIT_OT_import_menu(bpy.types.Operator):
     def draw(self, context: Context):
         layout = self.layout
         layout.label(text="Select Import Method")
-        layout.operator("avatar_toolkit.import_pmx", text="Import PMX")
+        layout.operator("avatar_toolkit.import_pmx", text=t("Quick_Access.import_pmx"))
-        layout.operator("avatar_toolkit.import_pmd", text="Import PMD")
+        layout.operator("avatar_toolkit.import_pmd", text=t("Quick_Access.import_pmd"))
         layout.operator("avatar_toolkit.import_fbx", text="Import FBX") 
 
 @register_wrap
 class AVATAR_TOOLKIT_OT_export_menu(bpy.types.Operator):
     bl_idname = "avatar_toolkit.export_menu"
-    bl_label = "Export Menu"
+    bl_label = t("Quick_Access.export_menu.label")
+    bl_description = t("Quick_Access.import_pmx.desc")
 
     @classmethod
     def poll(cls, context):
@@ -67,14 +70,14 @@ class AVATAR_TOOLKIT_OT_export_menu(bpy.types.Operator):
 
     def draw(self, context: Context):
         layout = self.layout
-        layout.label(text="Select Export Method")
+        layout.label(text=t("Quick_Access.select_export.label"))
-        layout.operator("avatar_toolkit.export_resonite", text="Export Resonite")
+        layout.operator("avatar_toolkit.export_resonite", text=t("Quick_Access.select_export_resonite.label"))
         layout.operator("avatar_toolkit.export_fbx", text="Export FBX")
 
 @register_wrap
 class AVATAR_TOOLKIT_OT_import_pmx(bpy.types.Operator):
     bl_idname = "avatar_toolkit.import_pmx"
-    bl_label = "Import PMX"
+    bl_label = t("Quick_Access.import_pmx")
 
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
 
@@ -89,7 +92,7 @@ class AVATAR_TOOLKIT_OT_import_pmx(bpy.types.Operator):
 @register_wrap
 class AVATAR_TOOLKIT_OT_import_pmd(bpy.types.Operator):
     bl_idname = "avatar_toolkit.import_pmd"
-    bl_label = "Import PMD"
+    bl_label = t("Quick_Access.import_pmd")
 
     filepath: bpy.props.StringProperty(subtype="FILE_PATH")
 

ui/settings.py

@@ -14,6 +14,26 @@ class AvatarToolkitSettingsPanel(bpy.types.Panel):
 
     def draw(self, context):
         layout = self.layout
-        props = context.scene
+        layout.prop(context.scene, "avatar_toolkit_language", text=t("Settings.language.label"))
 
-        layout.prop(props, "language")
+@register_wrap
+class AVATAR_TOOLKIT_OT_translation_restart_popup(bpy.types.Operator):
+    bl_idname = "avatar_toolkit.translation_restart_popup"
+    bl_label = t("Settings.translation_restart_popup.label")
+    bl_description = t("Settings.translation_restart_popup.description")
+    bl_options = {'INTERNAL'}
+
+    def execute(self, context):
+        if context.scene.avatar_toolkit_language_changed:
+            # Reload the addon after the popup is closed
+            bpy.ops.script.reload()
+            context.scene.avatar_toolkit_language_changed = False
+        return {'FINISHED'}
+
+    def invoke(self, context, event):
+        return context.window_manager.invoke_props_dialog(self, width=300)
+
+    def draw(self, context):
+        layout = self.layout
+        layout.label(text=t("Settings.translation_restart_popup.message1"))
+        layout.label(text=t("Settings.translation_restart_popup.message2"))

ui/tools.py

@@ -3,6 +3,7 @@ from ..core.register import register_wrap
 from .panel import AvatarToolkitPanel
 from bpy.types import Context
 from ..functions.digitigrade_legs import CreateDigitigradeLegs
+from ..functions.translations import t
 
 @register_wrap
 class AvatarToolkitToolsPanel(bpy.types.Panel):
@@ -15,10 +16,13 @@ class AvatarToolkitToolsPanel(bpy.types.Panel):
 
     def draw(self, context: Context):
         layout = self.layout
-        layout.label(text="Tools")
+        layout.label(text=t("Tools.tools_title.label"))
         layout.separator(factor=0.5)
 
         row = layout.row(align=True)
         row.scale_y = 1.5  
-        row.operator("avatar_toolkit.convert_to_resonite", text="Translate to Resonite")
+        row.operator("avatar_toolkit.convert_to_resonite", text=t("Tools.convert_to_resonite.label"))
-        row.operator(CreateDigitigradeLegs.bl_idname, text="Create Digitigrade Legs")
+        row = layout.row(align=True)
+        row.operator("avatar_toolkit.remove_doubles_safely", text="Remove Doubles Safely")
+        row = layout.row(align=True)
+        row.operator(CreateDigitigradeLegs.bl_idname, text="Create Digitigrade Legs")