SortHierarchy.py

bl_info = {
    "name": "Object Sorting in Collections",
    "description": "Automatically sorts objects into collections based on various criteria.",
    "author": "Joucaz",
    "version": (1, 0, 0),
    "blender": (3, 90, 0),
    "location": "View3D > Object -> Sort Objects",
    "category": "Object",
}

import bpy

# Classes et Fonctions
class OBJECT_OT_sort_objects(bpy.types.Operator):
    """Trie les objets dans des collections basées sur les critères choisis"""
    bl_idname = "object.sort_objects"
    bl_label = "Trier Objets"
    bl_options = {'REGISTER', 'UNDO'}

    sort_by: bpy.props.EnumProperty(
        name="Trier par",
        description="Choisissez le critère de tri",
        items=[
            ('TYPE', "Type d'Objet", "Trier les objets par type d'objet"),
            ('MATERIAL', "Matériau", "Trier les objets par matériau"),
            ('DISTANCE', "Distance à la Caméra", "Trier les objets par distance à la caméra active"),
        ],
        default='TYPE',
    )
    
    collection_name: bpy.props.EnumProperty(
        name="Collection",
        description="Choisissez une collection à trier",
        items=lambda self, context: [
            (" ", " ", "Sélectionnez une collection")  # Option "Aucun" au début
        ] + [
            ("scene_collection", "Scene Collection", "La collection principale de la scène")
        ] + [
            (col.name, col.name, "") for col in bpy.data.collections if col.name != bpy.context.scene.collection.name
        ],
    )

    def execute(self, context):
        if self.collection_name != ' ':
            if self.sort_by == 'MATERIAL':
                sort_objects_by_material(self.collection_name)
            elif self.sort_by == 'TYPE':
                sort_objects_by_type(self.collection_name)
            elif self.sort_by == 'DISTANCE':
                sort_objects_by_distance(self.collection_name)
            
            sort_collections_alphabetically()
        
        return {'FINISHED'}

# Fonctions de tri
def sort_objects_by_material(collection_name):
    
    if collection_name == "scene_collection":
        target_collection = bpy.context.scene.objects
    else:
        target_collection = bpy.data.collections.get(collection_name).objects
    
    material_collections = {}

    for obj in target_collection:
        if obj.type == 'MESH' and obj.active_material:
            
            mat = obj.active_material
            if mat not in material_collections:
                material_collections[mat] = bpy.data.collections.new(mat.name)
                bpy.context.scene.collection.children.link(material_collections[mat])
            
            target_collection = material_collections[mat]
            
            for col in obj.users_collection:
                col.objects.unlink(obj)

            target_collection.objects.link(obj)

def sort_objects_by_type(collection_name):
    
    if collection_name == "scene_collection":
        target_collection = bpy.context.scene.objects
    else:
        target_collection = bpy.data.collections.get(collection_name).objects
    
#    if not target_collection:
#        print(f"La collection '{collection_name}' n'existe pas.")
#        return
    
    type_collections = {}

    for obj in target_collection:
        obj_type = obj.type
        if obj_type not in type_collections:
            type_collections[obj_type] = bpy.data.collections.new(obj_type)
            bpy.context.scene.collection.children.link(type_collections[obj_type])

        target_collection = type_collections[obj_type]

        for col in obj.users_collection:
            col.objects.unlink(obj)
            
        target_collection.objects.link(obj)

def sort_objects_by_distance(collection_name):
    camera = bpy.context.scene.camera
    if not camera:
        print("Pas de caméra active dans la scène.")
        return

    distance_collections = {
        "Avant-plan": bpy.data.collections.new("Avant-plan"),
        "Milieu": bpy.data.collections.new("Milieu"),
        "Arrière-plan": bpy.data.collections.new("Arrière-plan"),
    }

    for col in distance_collections.values():
        bpy.context.scene.collection.children.link(col)
        
    if collection_name == "scene_collection":
        target_collection = bpy.context.scene.objects
    else:
        target_collection = bpy.data.collections.get(collection_name).objects

    for obj in target_collection:
        if obj.type == 'MESH':
            distance = (camera.location - obj.location).length

            if distance < 10:
                collection_name = "Avant-plan"
            elif distance < 30:
                collection_name = "Milieu"
            else:
                collection_name = "Arrière-plan"
                
                
            target_collection = distance_collections[collection_name]

            for col in obj.users_collection:
                col.objects.unlink(obj)
                
            target_collection.objects.link(obj)

def sort_collections_alphabetically():
    collections = bpy.context.scene.collection.children
    sorted_collections = sorted(collections, key=lambda col: col.name)

    for col in collections:
        bpy.context.scene.collection.children.unlink(col)
    for col in sorted_collections:
        bpy.context.scene.collection.children.link(col)

# Enregistrement et Dé-enregistrement
def menu_func(self, context):        
    self.layout.operator(OBJECT_OT_sort_objects.bl_idname)

def register():
    bpy.utils.register_class(OBJECT_OT_sort_objects)
    bpy.types.VIEW3D_MT_object.append(menu_func)

def unregister():
    bpy.types.VIEW3D_MT_object.remove(menu_func)
    bpy.utils.unregister_class(OBJECT_OT_sort_objects)

if __name__ == "__main__":
    try:
        unregister()
    except:
        pass
    register()