microvision/__init__.py

import bpy
from bpy.props import CollectionProperty, EnumProperty, PointerProperty, StringProperty
from bpy.types import PropertyGroup
from . import attribution
import importlib

bl_info = {
    "name": "Microvision",
    "description": "Size comparison, now in 3D!",
    "version": (0, 1, 0),
    "blender": (2, 80, 0),
    "location": "View3D > Toolbar > Microvision",
    "author": "chemicalcrux",
    "category": "Development"
}

class MicrovisionPerson(PropertyGroup):
    id: StringProperty(name="Identifier")

class MicrovisionSource(PropertyGroup):
    url: StringProperty(name="URL")

class MicrovisionTool(PropertyGroup):
    id: StringProperty(name="identifier")

class MicrovisionAttribution(PropertyGroup):
    authors: CollectionProperty(name="Authors", type=MicrovisionPerson)
    owners: CollectionProperty(name="Owners", type=MicrovisionPerson)
    sources: CollectionProperty(name="Owners", type=MicrovisionSource)
    citations: CollectionProperty(name="Owners", type=MicrovisionSource)
    tools: CollectionProperty(name="Owners", type=MicrovisionTool)

class MicrovisionData(PropertyGroup):
    attribution: PointerProperty(type=MicrovisionAttribution)

class MicrovisionProperties(PropertyGroup):
    def groups(self, context:bpy.types.Context):
        results = []

        if "Microvision Assets" in bpy.data.collections:
            assets = bpy.data.collections["Microvision Assets"]
            
            for index, child in enumerate(assets.children):
                results.append(
                    (child.name, child.name, "", "", index)
                )
        
        return results

    def kinds(self, context:bpy.types.Context):
        results = []

        if context.scene.micro.group:
            assets = bpy.data.collections[context.scene.micro.group]
            
            for index, child in enumerate(assets.children):
                results.append(
                    (child.name, child.name, "", "", index)
                )
        
        return results

    def objects(self, context:bpy.types.Context):
        results = []

        
        if context.scene.micro.kind:
            assets = bpy.data.collections[context.scene.micro.kind]
            for index, child in enumerate(assets.children):
                results.append(
                    (child.name, child.name, "", "", index)
                )
            
        return results

    group: EnumProperty(
        name="Group",
        items=groups,
        description="What general kind of thing to browse",
        default=None
    )

    kind: EnumProperty(
        name="Kind",
        items=kinds,
        description="What specific kind of thing to browse",
        default=None
    )

    object: EnumProperty(
        name="Object",
        items=objects,
        description="The object to spawn",
        default=None
    )
    

class LoadAssets(bpy.types.Operator):
    bl_idname = "microvision.load_assets"
    bl_label = "Load Assets"

    def execute(self, context: bpy.types.Context):
        link_data(context)

        return {'FINISHED'} 

class Spawn(bpy.types.Operator):
    bl_idname = "microvision.spawn"
    bl_label = "Spawn"

    def execute(self, context: bpy.types.Context):
        empty = bpy.data.objects.new(context.scene.micro.object, None)

        empty.instance_type = 'COLLECTION'
        empty.instance_collection = bpy.data.collections[context.scene.micro.object]
        empty.show_instancer_for_viewport = False
        empty.show_instancer_for_render = False

        context.view_layer.layer_collection.collection.children["Microvision Objects"].objects.link(empty)

        context.view_layer.objects.active = empty
        bpy.ops.object.select_all(action="DESELECT")
        empty.select_set(state=True)
        

        return {'FINISHED'}

class AddListItem(bpy.types.Operator):
    bl_idname = "microvision.addlist"
    bl_label = "Add Entry"
    
    target: StringProperty()
    action: StringProperty()

    def execute(self, context: bpy.types.Context):
        if self.action == "add":
            context.collection.microvision.attribution.__getattribute__(self.target).add()
        if self.action == "remove":
            context.collection.microvision.attribution.__getattribute__(self.target).remove(len(context.collection.microvision.attribution.__getattribute__(self.target)) - 1)

        return {'FINISHED'}

class MicrovisionAttributionEditPanel(bpy.types.Panel):
    bl_idname = "OBJECT_PT_microvision_attribution_edit_panel"
    bl_label = "Attribution Editor"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "Microvision"
    bl_context = "objectmode"

    @classmethod
    def poll(self, context: bpy.types.Context):
        return context.view_layer.layer_collection.collection.children[0].name == "Assets"

    def add_buttons(self, layout, target):
        row = layout.row()
        op = row.operator('microvision.addlist', text="Add")
        op.target = target
        op.action = "add"
        
        op = row.operator('microvision.addlist', text="Remove")
        op.target = target
        op.action = "remove"

    def draw(self, context: bpy.types.Context):
        layout = self.layout
        scene = context.scene

        attribution_data = context.collection.microvision.attribution

        layout.label(text="Authors")
        for author in attribution_data.authors:
            layout.prop(author, "id")
        
        self.add_buttons(layout, "authors")

        layout.label(text="Owners")
        for owner in attribution_data.owners:
            layout.prop(owner, "id")

        self.add_buttons(layout, "owners")

        layout.label(text="Sources")
        for source in attribution_data.sources:
            layout.prop(source, "url")
        
        self.add_buttons(layout, "sources")

        layout.label(text="Citations")
        for citation in attribution_data.citations:
            layout.prop(citation, "url")
        
        self.add_buttons(layout, "citations")

        layout.label(text="Tools")
        for tool in attribution_data.tools:
            layout.prop(tool, "id")

        self.add_buttons(layout, "tools")


class MicrovisionAttributionPanel(bpy.types.Panel):
    bl_idname = "OBJECT_PT_microvision_attribution_panel"
    bl_label = "Attribution"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "Microvision"
    bl_context = "objectmode"

    @classmethod
    def poll(self, context):
        if context.active_object is not None:
            if context.active_object.instance_collection is not None:
                return True
        else:
            return False

    def draw(self, context: bpy.types.Context):
        layout = self.layout
        scene = context.scene

        attribution_data = context.active_object.instance_collection.microvision.attribution

        layout.label(text="Authors")
        for author in attribution_data.authors:
            id = author.id
            layout.operator('wm.url_open', text=attribution.people[id]["name"]).url=attribution.people[id]["url"]

        layout.label(text="Owners")
        for owner in attribution_data.owners:
            id = owner.id
            layout.operator('wm.url_open', text=attribution.people[id]["name"]).url=attribution.people[id]["url"]

        layout.label(text="Sources")
        for source in attribution_data.sources:
            url = source.url
            layout.operator('wm.url_open', text="Source").url=url

        layout.label(text="Citations")
        for citation in attribution_data.citations:
            url = citation.url
            layout.operator('wm.url_open', text="Citation").url=url

        layout.label(text="Tools")
        for tool in attribution_data.tools:
            id = tool.id
            layout.operator('wm.url_open', text=attribution.tools[id]["name"]).url=attribution.tools[id]["url"]

class MicrovisionPanel(bpy.types.Panel):
    bl_idname = "OBJECT_PT_microvision_panel"
    bl_label = "Spawn"
    bl_space_type = "VIEW_3D"
    bl_region_type = "UI"
    bl_category = "Microvision"
    bl_context = "objectmode"

    @classmethod
    def poll(self, context: bpy.types.Context):
        return context.view_layer.layer_collection.collection.children[0].name != "Assets"


    def draw(self, context: bpy.types.Context):
        layout = self.layout
        scene = context.scene

        if "Microvision Assets" not in bpy.context.view_layer.layer_collection.children:
            layout.operator("microvision.load_assets")
        else:
            layout.prop(context.scene.micro, "group")
            layout.prop(context.scene.micro, "kind")
            layout.prop(context.scene.micro, "object")

            layout.operator("microvision.spawn")

classes = [
    LoadAssets,
    Spawn,
    MicrovisionPerson,
    MicrovisionSource,
    MicrovisionTool,
    MicrovisionAttribution,
    MicrovisionData,
    AddListItem,
    MicrovisionPanel,
    MicrovisionAttributionEditPanel,
    MicrovisionAttributionPanel,
    MicrovisionProperties,
]

def remove_recursive(collection: bpy.types.Collection):
    print(collection)
    for child in collection.children:
        remove_recursive(child)
        collection.children.unlink(child)
        bpy.data.collections.remove(child)

def link_data(context: bpy.types.Context):
    top = bpy.data.collections.new(name="Microvision Assets")
    context.view_layer.layer_collection.collection.children.link(top)
    context.view_layer.layer_collection.collection.children["Microvision Assets"].hide_viewport = True
    for lib in ["Buildings", "Vehicles"]:
        path = f"C:/Users/hausss/AppData/Roaming/Blender Foundation/Blender/2.93/scripts/addons/microvision/libs/{lib}.blend"

        category = bpy.data.collections.new(name=lib)
        top.children.link(category)
        with bpy.data.libraries.load(path, link=True) as (data_from, data_to):
            data_to.collections = ["Assets"]

        print(len(data_to.collections[0].children))

        for coll in data_to.collections[0].children:
            print(coll)
            if coll is not None:
                category.children.link(coll)
    
    objects = bpy.data.collections.new(name="Microvision Objects")
    context.view_layer.layer_collection.collection.children.link(objects)

def register():
    print("Hi") 
    importlib.reload(attribution)
    for cls in classes:
        bpy.utils.register_class(cls)
    bpy.types.Scene.micro = PointerProperty(type=MicrovisionProperties)
    bpy.types.Collection.microvision = PointerProperty(type=MicrovisionData)

def unregister():
    print("Bye")
    for cls in classes:
        bpy.utils.unregister_class(cls)