Combine and duplicate meshes before exporting them?

Question

I'm writing an add-on that exports objects to FBX file format.

One of its features will be the ability to merge another object for export. So the user selects object A, clicks the "choose merge object" button, then clicks object B. During export, the objects are combined as per Ctrl+J type operation, exported as a single object, then everything is restored to normal (back to 2 objects).

This is my idea:

1. Duplicate both objects - remaining steps deal with copies
2. Set B as selected and A as active
3. Use bpy.ops.object.join()
4. Export A (active_object)
5. Delete A

I have a couple questions regarding this if anyone might know something about it..

X. Is there an alternative to avoid the need to create temporaries and delete them afterward? The objects could be any complexity imaginable, so any way to use the inputs as read-only would be better. Some alternate merger? A+B=C instead of A+=delete(B)?

Edit: I later found out that you can duplicate an object as a link (which doesn't copy mesh data), then use that linked duplicate as an input object for join(). This is very similar to not needing to create temporaries because the mesh data is never duplicated.

Y. In the scenario above using join(), would the temporary copy of B be deleted automatically? Not sure how join() works under the hood. And a little worried about messing around with a deleted object reference in code.

Edit: Yes, all input objects except the active one get deleted by join().

I really appreciate any advice. I'm very new to python and add-on development, so details are also appreciated.

Answer 1

Sounds like a job for our good old friend: Undo. You can make it complicated for sure, but since the operation is in memory anyway, it should make it pretty fast.

import bpy

from bpy.props import (BoolProperty, FloatProperty, StringProperty)
from bpy.types import (Operator)
from bpy_extras.io_utils import ExportHelper

# ExportHelper is a helper class, defines filename and
# invoke() function which calls the file selector.
class EXPORT_OT_customFBX(Operator, ExportHelper):
    """Export the scene to FBX"""
    bl_idname = "export_scene.custom_fbx"
    bl_label = "Export FBX"

    # ExportHelper mixin class uses this
    filename_ext = ".fbx"

    filter_glob: StringProperty(
        default="*.fbx",
        options={'HIDDEN'},
        maxlen=255,  # Max internal buffer length, longer would be clamped.
    )

    # List of operator properties, the attributes will be assigned
    # to the class instance from the operator settings before calling.
    global_scale: FloatProperty(
        name="Scale",
        description="Scale",
        default=1.0,
    )

    use_subsurf: BoolProperty(
        name="Use Subsurf",
        description="Use Subsurf",
        default=False,
    )

    apply_unit_scale: BoolProperty(
        name="Apply Unit Scale",
        description="Use Subsurf",
        default=True,
    )

    def execute(self, context):

        viewport_selection = [o for o in context.selected_objects if o.type == 'MESH']

        if len(viewport_selection) == 2:
            if context.active_object in viewport_selection:
                # Join! 
                # https://blender.stackexchange.com/q/13986
                # https://blender.stackexchange.com/q/50160
                bpy.ops.object.join()
            else:
                print ("Can not call join operator")
        else:
            print ("Nothing to join.")

        # Export
        bpy.ops.export_scene.fbx(
                filepath=self.filepath,
                global_scale=self.global_scale, 
                apply_unit_scale=self.apply_unit_scale, 
                use_subsurf=self.use_subsurf,
                use_metadata=True, 
                axis_forward='-Z', 
                axis_up='Y'
            )

        # Undo!
        bpy.ops.ed.undo()
        return {'FINISHED'} 

# Only needed if you want to add into a dynamic menu
def draw_export_fbx(self, context):
    self.layout.operator(EXPORT_OT_customFBX.bl_idname, text="Custom FBX (.fbx)", icon="MESH_MONKEY")


# Registration
classes = (
    EXPORT_OT_customFBX,
)

def register():
    from bpy.utils import register_class
    for cls in classes:
        register_class(cls)

    bpy.types.TOPBAR_MT_file_export.prepend(draw_export_fbx)


def unregister():
    from bpy.utils import unregister_class
    for cls in reversed(classes):
        unregister_class(cls)

    bpy.types.TOPBAR_MT_file_export.remove(draw_export_fbx)


if __name__ == "__main__":
    register()

    # test call
    bpy.ops.export_scene.custom_fbx('INVOKE_DEFAULT')

Operator is based on Templates > Python > Operator File Export

---

Another quite boring approach is saving the file before exporting to fbx and then reload the blend:

def execute(self, context):

    # Save!
    if bpy.data.is_dirty:
        bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)

    viewport_selection = [o for o in context.selected_objects if o.type == 'MESH']

    if len(viewport_selection) == 2:
        if context.active_object in viewport_selection:
            # Join! # https://blender.stackexchange.com/q/13986
            bpy.ops.object.join()
        else:
            print ("Can not call join operator")
    else:
        print ("Nothing to join.")

    # Export
    bpy.ops.export_scene.fbx(
            filepath=self.filepath,
            global_scale=self.global_scale, 
            apply_unit_scale=self.apply_unit_scale, 
            use_subsurf=self.use_subsurf,
            use_metadata=True, 
            axis_forward='-Z', 
            axis_up='Y'
        )

    # Reload
    bpy.ops.wm.open_mainfile(filepath=bpy.data.filepath)
    return {'FINISHED'} 

Might be nice doing some tests to measure execution time of both... in memory.

Answer 2

I don't see the need to join the objects at all inside Blender. Since you are? writing the fbx export code, just merge the triangle/texture/animation data for the two meshes yourself and write it out to the fbx format as a single object.