Nodes/MKRShift_Nodes/Blender Image Output Plan
ComfyUI Node

Blender Image Output Plan

Decide how a generated image gets back into Blender — before you generate it

By criskb·Created 7 months ago·Updated 5 months ago· 0
Blender Image Output Plan
    • image_output_plan_json
    • manifest_line
    • summary_json
    asset_path
    image_rolebase_color
    target_nameMKRShift Result
    apply_modetexture_image
    target_material_name
    target_object_name
    transport_plan_json

    There's a right way and a "where did that file go" way to send generated images back into Blender, and MKRBlenderImageOutputPlan exists to make the right way explicit. It's a planning node: it documents, in JSON, exactly where an image should land and how Blender should treat it - as a texture on a material, an image plane, a camera background, or a compositor image - before you ever generate the pixels. That plan then drives MKRBlenderImageOutput, which does the actual write. Planning before generating means the output side is deterministic instead of a scramble at the end.

    From MKRShift_Nodes by criskb. Install via ComfyUI Manager (search "MKRShift_Nodes") or git clone https://github.com/criskb/MKRShift_Nodes into custom_nodes/, restart.

    How it works

    You declare the destination up front: asset_path (where the file will live), image_role (what the image is - default base_color), target_name (the object or asset it belongs to), and apply_mode, the four-way choice that defines how Blender applies it:

    • texture_image - a texture mapped onto a material (the default)
    • image_plane - a plane in the scene, handy for storyboards and set dressing
    • camera_background - behind the camera, for plates and matte work
    • compositor_image - into the compositor, for post passes

    Optionally you can pin target_material_name and target_object_name so the plan names its destination precisely, and pass a transport_plan_json if your add-on lane uses one. The node emits image_output_plan_json (the plan), manifest_line (a compact CSV-ish summary for logging), and summary_json.

    Why the plan-first pattern is worth it

    This is the pack's design philosophy in one node: keep the "what and where" data separate from the "write the bytes" action. You can run the plan node on its own, eyeball the JSON, and change your mind - apply as texture vs. compositor image - without re-generating anything. It also means the same plan JSON can be inspected, logged, or versioned like any other asset manifest. It's more ceremony than just typing a folder path, but for a production roundtrip the ceremony saves you from discovering at 11pm that your base color overwrote your render.

    The honest caveat: the plan is only as good as the asset_path you give it, and the actual application in Blender still depends on the add-on honoring apply_mode. No community lore exists on this node yet - treat the plan JSON as the contract and test one full roundtrip before you trust a whole batch.

    CategoryMKRShift Nodes/Addons/Blender

    Inputs (7)

    NameTypeDefaultDescription
    asset_pathSTRING
    image_roleSTRINGbase_color
    target_nameSTRINGMKRShift Result
    apply_modeCOMBOtexture_image4 options: texture_image, image_plane, camera_background, compositor_image
    target_material_nameoptSTRING
    target_object_nameoptSTRING
    transport_plan_jsonoptSTRING

    Outputs (3)

    NameTypeDescription
    image_output_plan_jsonSTRING
    manifest_lineSTRING
    summary_jsonSTRING