Upload 8 files

ComfyUI_Comfyroll_CustomNodes/Comfyroll_Nodes.py

@@ -0,0 +1,1160 @@
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+# Comfyroll Custom Nodes by RockOfFire and Akatsuzi         https://github.com/RockOfFire/ComfyUI_Comfyroll_CustomNodes                             #
+# for ComfyUI                                               https://github.com/comfyanonymous/ComfyUI                                               #
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+import torch
+import numpy as np
+from PIL import Image, ImageEnhance
+from PIL.PngImagePlugin import PngInfo
+import os
+import sys
+import io
+import matplotlib.pyplot as plt
+
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), "comfy"))
+
+import comfy.sd
+import comfy.utils
+import comfy.model_management
+
+import folder_paths
+import json
+from nodes import MAX_RESOLUTION
+import typing as tg
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+def tensor2pil(image):
+    return Image.fromarray(np.clip(255. * image.cpu().numpy().squeeze(), 0, 255).astype(np.uint8))
+
+def pil2tensor(image):
+    return torch.from_numpy(np.array(image).astype(np.float32) / 255.0).unsqueeze(0)
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_InputImages:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": ("INT", {"default": 1, "min": 1, "max": 2}),
+                "image1": ("IMAGE",),
+                "image2": ("IMAGE",)
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputImages"
+
+    CATEGORY = "Comfyroll/Logic"
+
+    def InputImages(self, Input, image1, image2):
+        if Input == 1:
+            return (image1, )
+        else:
+            return (image2, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_InputImages_4way:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": ("INT", {"default": 1, "min": 1, "max": 4}),
+                "image1": ("IMAGE",),
+            },
+            "optional": {
+                "image2": ("IMAGE",),
+                "image3": ("IMAGE",),
+                "image4": ("IMAGE",),
+            }
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputImages_4"
+
+    CATEGORY = "Comfyroll/Logic"
+
+    def InputImages_4(self, Input, image1, image2=None, image3=None, image4=None):
+        if Input == 1:
+            return (image1, )
+        elif Input == 2:
+            return (image2, )
+        elif Input == 3:
+            return (image3, )
+        else:
+            return (image4, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_InputLatents:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": ("INT", {"default": 1, "min": 1, "max": 2}),
+                "latent1": ("LATENT",),
+                "latent2": ("LATENT",)
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputLatents"
+
+    CATEGORY = "Comfyroll/Logic"
+
+    def InputLatents(self, Input, latent1, latent2):
+        if Input == 1:
+            return (latent1, )
+        else:
+            return (latent2, )
+            
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_InputConditioning:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": ("INT", {"default": 1, "min": 1, "max": 2}),
+                "conditioning1": ("CONDITIONING",),
+                "conditioning2": ("CONDITIONING",)
+            }
+        }
+
+    RETURN_TYPES = ("CONDITIONING",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputConditioning"
+
+    CATEGORY = "Comfyroll/Logic"
+
+    def InputConditioning(self, Input, conditioning1, conditioning2):
+        if Input == 1:
+            return (conditioning1, )
+        else:
+            return (conditioning2, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_InputClip:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": ("INT", {"default": 1, "min": 1, "max": 2}),
+                "clip1": ("CLIP",),
+                "clip2": ("CLIP",)
+            }
+        }
+
+    RETURN_TYPES = ("CLIP",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputClip"
+
+    CATEGORY = "Comfyroll/Logic"
+
+    def InputClip(self, Input, clip1, clip2):
+        if Input == 1:
+            return (clip1, )
+        else:
+            return (clip2, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_InputModel:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": ("INT", {"default": 1, "min": 1, "max": 2}),
+                "model1": ("MODEL",),
+                "model2": ("MODEL",)
+            }
+        }
+
+    RETURN_TYPES = ("MODEL",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputModel"
+
+    CATEGORY = "Comfyroll/Logic"
+
+    def InputModel(self, Input, model1, model2):
+        if Input == 1:
+            return (model1, )
+        else:
+            return (model2, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#        
+
+class ComfyRoll_InputControlNet:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": ("INT", {"default": 1, "min": 1, "max": 2}),
+                "control_net1": ("CONTROL_NET",),
+                "control_net2": ("CONTROL_NET",)
+            }
+        }
+        
+    RETURN_TYPES = ("CONTROL_NET",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputControlNet"
+
+    CATEGORY = "Comfyroll/Logic"
+
+    def InputControlNet(self, Input, control_net1, control_net2):
+        if Input == 1:
+            return (control_net1, )
+        else:
+            return (control_net2, )
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_InputLatentsText:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": (["txt2img", "img2img"],),
+                "txt2img": ("LATENT",),
+                "img2img": ("LATENT",)
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputLatentsText"
+
+    CATEGORY = "Comfyroll/Process"
+
+    def InputLatentsText(self, Input, txt2img, img2img):
+        if Input == "txt2img":
+            return (txt2img, )
+        else:
+            return (img2img, )            
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_HiResFixSwitch:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": (["latent_upscale", "image_upscale"],),
+                "latent_upscale": ("LATENT",),
+                "image_upscale": ("LATENT",)
+            }
+        }
+
+    RETURN_TYPES = ("LATENT",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputHiResText"
+
+    CATEGORY = "Comfyroll/Process"
+
+    def InputHiResText(self, Input, latent_upscale, image_upscale):
+        if Input == "latent_upscale":
+            return (latent_upscale, )
+        else:
+            return (image_upscale, )  
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#                       
+            
+class ComfyRoll_LoraLoader:
+    def __init__(self):
+        self.loaded_lora = None
+
+    @classmethod
+    def INPUT_TYPES(s):
+        file_list = folder_paths.get_filename_list("loras")
+        file_list.insert(0, "None")
+        return {"required": { "model": ("MODEL",),
+                              "clip": ("CLIP", ),
+                              "switch": ([
+                                "On",
+                                "Off"],),
+                              "lora_name": (file_list, ),
+                              "strength_model": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                              "strength_clip": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                              }}
+    RETURN_TYPES = ("MODEL", "CLIP")
+    FUNCTION = "load_lora"
+
+    CATEGORY = "Comfyroll/IO"
+
+    def load_lora(self, model, clip, switch, lora_name, strength_model, strength_clip):
+        if strength_model == 0 and strength_clip == 0:
+            return (model, clip)
+
+        if switch == "Off" or  lora_name == "None":
+            return (model, clip)
+
+        lora_path = folder_paths.get_full_path("loras", lora_name)
+        lora = None
+        if self.loaded_lora is not None:
+            if self.loaded_lora[0] == lora_path:
+                lora = self.loaded_lora[1]
+            else:
+                del self.loaded_lora
+
+        if lora is None:
+            lora = comfy.utils.load_torch_file(lora_path, safe_load=True)
+            self.loaded_lora = (lora_path, lora)
+
+        model_lora, clip_lora = comfy.sd.load_lora_for_models(model, clip, lora, strength_model, strength_clip)
+        return (model_lora, clip_lora)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#           
+
+class ComfyRoll_ApplyControlNet:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"conditioning": ("CONDITIONING", ),
+                             "control_net": ("CONTROL_NET", ),
+                             "image": ("IMAGE", ),
+                             "switch": ([
+                                "On",
+                                "Off"],),
+                             "strength": ("FLOAT", {"default": 1.0, "min": 0.0, "max": 10.0, "step": 0.01})
+                             }}
+    RETURN_TYPES = ("CONDITIONING",)
+    FUNCTION = "apply_controlnet"
+
+    CATEGORY = "Comfyroll/Conditioning"
+
+    def apply_controlnet(self, conditioning, control_net, image, switch, strength):
+        if strength == 0 or switch == "Off":
+            return (conditioning, )
+
+        c = []
+        control_hint = image.movedim(-1,1)
+        for t in conditioning:
+            n = [t[0], t[1].copy()]
+            c_net = control_net.copy().set_cond_hint(control_hint, strength)
+            if 'control' in t[1]:
+                c_net.set_previous_controlnet(t[1]['control'])
+            n[1]['control'] = c_net
+            c.append(n)
+        return (c, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_ImageSize_Float:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "width": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                "height": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                "upscale_factor": ("FLOAT", {"default": 1, "min": 1, "max": 2000})
+            }
+        }
+    RETURN_TYPES = ("INT", "INT", "FLOAT")
+    #RETURN_NAMES = ("Width", "Height")
+    FUNCTION = "ImageSize_Float"
+
+    CATEGORY = "Comfyroll/Image"
+
+    def ImageSize_Float(self, width, height, upscale_factor):
+        return(width, height, upscale_factor)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_ImageOutput:
+    def __init__(self):
+        self.output_dir = folder_paths.get_output_directory()
+        self.type = "output"
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": 
+                    {"images": ("IMAGE", ),
+                    "output_type": (["Preview", "Save"],),
+                     "filename_prefix": ("STRING", {"default": "ComfyUI"})},
+                "hidden": {"prompt": "PROMPT", "extra_pnginfo": "EXTRA_PNGINFO"},
+                }
+
+    RETURN_TYPES = ()
+    FUNCTION = "save_images"
+
+    OUTPUT_NODE = True
+
+    CATEGORY = "Comfyroll/Legacy"
+
+    def save_images(self, images, filename_prefix="ComfyUI", output_type = "Preview", prompt=None, extra_pnginfo=None):
+        def map_filename(filename):
+            prefix_len = len(os.path.basename(filename_prefix))
+            prefix = filename[:prefix_len + 1]
+            try:
+                digits = int(filename[prefix_len + 1:].split('_')[0])
+            except:
+                digits = 0
+            return (digits, prefix)
+
+        def compute_vars(input):
+            input = input.replace("%width%", str(images[0].shape[1]))
+            input = input.replace("%height%", str(images[0].shape[0]))
+            return input
+
+        if output_type == "Save":
+            self.output_dir = folder_paths.get_output_directory()
+            self.type = "output"
+        elif output_type == "Preview":
+            self.output_dir = folder_paths.get_temp_directory()
+            self.type = "temp"
+
+        filename_prefix = compute_vars(filename_prefix)
+
+        subfolder = os.path.dirname(os.path.normpath(filename_prefix))
+        filename = os.path.basename(os.path.normpath(filename_prefix))
+
+        full_output_folder = os.path.join(self.output_dir, subfolder)
+
+        if os.path.commonpath((self.output_dir, os.path.abspath(full_output_folder))) != self.output_dir:
+            print("Saving image outside the output folder is not allowed.")
+            return {}
+
+        try:
+            counter = max(filter(lambda a: a[1][:-1] == filename and a[1][-1] == "_", map(map_filename, os.listdir(full_output_folder))))[0] + 1
+        except ValueError:
+            counter = 1
+        except FileNotFoundError:
+            os.makedirs(full_output_folder, exist_ok=True)
+            counter = 1
+
+        results = list()
+        for image in images:
+            i = 255. * image.cpu().numpy()
+            img = Image.fromarray(np.clip(i, 0, 255).astype(np.uint8))
+            metadata = PngInfo()
+            if prompt is not None:
+                metadata.add_text("prompt", json.dumps(prompt))
+            if extra_pnginfo is not None:
+                for x in extra_pnginfo:
+                    metadata.add_text(x, json.dumps(extra_pnginfo[x]))
+
+            file = f"{filename}_{counter:05}_.png"
+            img.save(os.path.join(full_output_folder, file), pnginfo=metadata, compress_level=4)
+            results.append({
+                "filename": file,
+                "subfolder": subfolder,
+                "type": self.type
+            })
+            counter += 1
+
+        return { "ui": { "images": results } }
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class CR_Int_Multiple_Of:
+    def __init__(self):
+        pass
+        
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "integer": ("INT", {"default": 1, "min": -18446744073709551615, "max": 18446744073709551615}),
+                "multiple": ("FLOAT", {"default": 8, "min": 1, "max": 18446744073709551615}),
+            }
+        }
+    
+    RETURN_TYPES =("INT",)
+    FUNCTION = "int_multiple_of"
+    
+    CATEGORY = "Comfyroll/Math"
+    
+    def int_multiple_of(self, integer, multiple=8):
+        if multiple == 0:
+            return (int(integer), )
+        integer = integer * multiple
+        return (int(integer), )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_AspectRatio:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "width": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                "height": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                "aspect_ratio": (["custom", "1:1 square 512x512", "1:1 square 1024x1024", "2:3 portrait 512x768", "3:4 portrait 512x682", "3:2 landscape 768x512", "4:3 landscape 682x512", "16:9 cinema 910x512", "2:1 cinema 1024x512"],),
+                "swap_dimensions": (["Off", "On"],),
+                "upscale_factor1": ("FLOAT", {"default": 1, "min": 1, "max": 2000}),
+                "upscale_factor2": ("FLOAT", {"default": 1, "min": 1, "max": 2000}),
+                "batch_size": ("INT", {"default": 1, "min": 1, "max": 64})
+            }
+        }
+    RETURN_TYPES = ("INT", "INT", "FLOAT", "FLOAT", "INT")
+    #RETURN_NAMES = ("Width", "Height")
+    FUNCTION = "Aspect_Ratio"
+
+    CATEGORY = "Comfyroll/Image"
+
+    def Aspect_Ratio(self, width, height, aspect_ratio, swap_dimensions, upscale_factor1, upscale_factor2, batch_size):
+        if swap_dimensions == "Off":
+            if aspect_ratio == "2:3 portrait 512x768":
+                width, height = 512, 768
+            elif aspect_ratio == "3:2 landscape 768x512":
+                width, height = 768, 512
+            elif aspect_ratio == "1:1 square 512x512":
+                width, height = 512, 512
+            elif aspect_ratio == "1:1 square 1024x1024":
+                width, height = 1024, 1024
+            elif aspect_ratio == "16:9 cinema 910x512":
+                width, height = 910, 512
+            elif aspect_ratio == "3:4 portrait 512x682":
+                width, height = 512, 682
+            elif aspect_ratio == "4:3 landscape 682x512":
+                width, height = 682, 512
+            elif aspect_ratio == "2:1 cinema 1024x512":
+                width, height = 1024, 512
+            return(width, height, upscale_factor1, upscale_factor2, batch_size)
+        elif swap_dimensions == "On":
+            if aspect_ratio == "2:3 portrait 512x768":
+                width, height = 512, 768
+            elif aspect_ratio == "3:2 landscape 768x512":
+                width, height = 768, 512
+            elif aspect_ratio == "1:1 square 512x512":
+                width, height = 512, 512              
+            elif aspect_ratio == "1:1 square 1024x1024":
+                width, height = 1024, 1024
+            elif aspect_ratio == "16:9 cinema 910x512":
+                width,height = 910, 512
+            elif aspect_ratio == "3:4 portrait 512x682":
+                width, height = 512, 682
+            elif aspect_ratio == "4:3 landscape 682x512":
+                width, height = 682, 512
+            elif aspect_ratio == "2:1 cinema 1024x512":
+                width, height = 1024, 512
+            return(height, width, upscale_factor1, upscale_factor2, batch_size)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_AspectRatio_SDXL:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "width": ("INT", {"default": 1024, "min": 64, "max": 2048}),
+                "height": ("INT", {"default": 1024, "min": 64, "max": 2048}),
+                "aspect_ratio": (["custom", "square 1024x1024", "portrait 896x1152", "portrait 832x1216", "portrait 768x1344", "portrait 640 x 1536", "landscape 1152x896", "landscape 1216x832", "landscape 1344x768", "landscape 1536x640"],),
+                "swap_dimensions": (["Off", "On"],),
+                "upscale_factor1": ("FLOAT", {"default": 1, "min": 1, "max": 2000}),
+                "upscale_factor2": ("FLOAT", {"default": 1, "min": 1, "max": 2000}),
+                "batch_size": ("INT", {"default": 1, "min": 1, "max": 64})
+            }
+        }
+    RETURN_TYPES = ("INT", "INT", "FLOAT", "FLOAT", "INT")
+    #RETURN_NAMES = ("Width", "Height")
+    FUNCTION = "Aspect_Ratio"
+
+    CATEGORY = "Comfyroll/SDXL"
+
+    def Aspect_Ratio(self, width, height, aspect_ratio, swap_dimensions, upscale_factor1, upscale_factor2, batch_size):
+        if aspect_ratio == "square 1024x1024":
+            width, height = 1024, 1024
+        elif aspect_ratio == "portrait 896x1152":
+            width, height = 896, 1152
+        elif aspect_ratio == "portrait 832x1216":
+            width, height = 822, 1216
+        elif aspect_ratio == "portrait 768x1344":
+            width, height = 768, 1344
+        elif aspect_ratio == "portrait 640 x 1536":
+            width, height = 640, 1536
+        elif aspect_ratio == "landscape 1152x896":
+            width, height = 1152, 896
+        elif aspect_ratio == "landscape 1152x896":
+            width, height = 682, 512
+        elif aspect_ratio == "landscape 1216x832":
+            width, height = 1216, 832
+        elif aspect_ratio == "landscape 1344x768":
+            width, height = 1152, 896
+        elif aspect_ratio == "landscape 1536x640":
+            width, height = 1536, 640
+            
+        if swap_dimensions == "On":
+            return(height, width, upscale_factor1, upscale_factor2, batch_size,)
+        else:
+            return(width, height, upscale_factor1, upscale_factor2, batch_size,)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_SeedToInt:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "seed": ("SEED", ),
+            }
+        }
+
+    RETURN_TYPES = ("INT",)
+    FUNCTION = "seed_to_int"
+
+    CATEGORY = "Comfyroll/Number"
+
+    def seed_to_int(self, seed):
+        return (seed.get('seed'),)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class Comfyroll_Color_Tint:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "image": ("IMAGE",),
+                "strength": ("FLOAT", {
+                    "default": 1.0,
+                    "min": 0.1,
+                    "max": 1.0,
+                    "step": 0.1
+                }),
+                "mode": (["white", "black", "sepia", "red", "green", "blue", "cyan", "magenta", "yellow", "purple", "orange", "warm", "cool",  "lime", "navy", "vintage", "rose", "teal", "maroon", "peach", "lavender", "olive"],),
+            },
+        }
+
+    RETURN_TYPES = ("IMAGE",)
+    FUNCTION = "color_tint"
+
+    CATEGORY = "Comfyroll/Image"
+
+    def color_tint(self, image: torch.Tensor, strength: float, mode: str = "sepia"):
+        if strength == 0:
+            return (image,)
+
+        sepia_weights = torch.tensor([0.2989, 0.5870, 0.1140]).view(1, 1, 1, 3).to(image.device)
+      
+        mode_filters = {
+            "white": torch.tensor([1.0, 1.0, 1.0]),
+            "black": torch.tensor([0, 0, 0]),
+            "sepia": torch.tensor([1.0, 0.8, 0.6]),
+            "red": torch.tensor([1.0, 0.6, 0.6]),
+            "green": torch.tensor([0.6, 1.0, 0.6]),
+            "blue": torch.tensor([0.6, 0.8, 1.0]),
+            "cyan": torch.tensor([0.6, 1.0, 1.0]),
+            "magenta": torch.tensor([1.0, 0.6, 1.0]),
+            "yellow": torch.tensor([1.0, 1.0, 0.6]),
+            "purple": torch.tensor([0.8, 0.6, 1.0]),
+            "orange": torch.tensor([1.0, 0.7, 0.3]),
+            "warm": torch.tensor([1.0, 0.9, 0.7]),
+            "cool": torch.tensor([0.7, 0.9, 1.0]),
+            "lime": torch.tensor([0.7, 1.0, 0.3]),
+            "navy": torch.tensor([0.3, 0.4, 0.7]),
+            "vintage": torch.tensor([0.9, 0.85, 0.7]),
+            "rose": torch.tensor([1.0, 0.8, 0.9]),
+            "teal": torch.tensor([0.3, 0.8, 0.8]),
+            "maroon": torch.tensor([0.7, 0.3, 0.5]),
+            "peach": torch.tensor([1.0, 0.8, 0.6]),
+            "lavender": torch.tensor([0.8, 0.6, 1.0]),
+            "olive": torch.tensor([0.6, 0.7, 0.4]),
+        }
+
+        scale_filter = mode_filters[mode].view(1, 1, 1, 3).to(image.device)
+
+        grayscale = torch.sum(image * sepia_weights, dim=-1, keepdim=True)
+        tinted = grayscale * scale_filter
+
+        result = tinted * strength + image * (1 - strength)
+        return (result,)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class ComfyRoll_prompt_mixer:
+    def __init__(self):
+        pass
+
+    @classmethod        
+    def INPUT_TYPES(s):
+        return {
+            "required":{
+            },
+            "optional":{
+                "prompt_positive": ("STRING", {"multiline": True, "default": "BASE_POSITIVE"}),
+                "prompt_negative": ("STRING", {"multiline": True, "default": "BASE_NEGATIVE"}),
+                "style_positive": ("STRING", {"multiline": True, "default": "REFINER_POSTIVE"}),
+                "style_negative": ("STRING", {"multiline": True, "default": "REFINER_NEGATIVE"}),
+                "preset": (["preset 1", "preset 2", "preset 3", "preset 4", "preset 5"],),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "STRING", "STRING", "STRING", "STRING", "STRING", )
+    RETURN_NAMES = ("pos_g", "pos_l", "pos_r", "neg_g", "neg_l", "neg_r", )
+    FUNCTION = "mixer"
+
+    CATEGORY = "Comfyroll/SDXL"
+
+    def mixer(self, prompt_positive, prompt_negative, style_positive, style_negative, preset):
+        if preset == "preset 1":
+            pos_g = prompt_positive
+            pos_l = prompt_positive
+            pos_r = prompt_positive
+            neg_g = prompt_negative
+            neg_l = prompt_negative
+            neg_r = prompt_negative
+        elif preset == "preset 2":
+            pos_g = prompt_positive
+            pos_l = style_positive
+            pos_r = prompt_positive
+            neg_g = prompt_negative
+            neg_l = style_negative
+            neg_r = prompt_negative
+        elif preset == "preset 3":
+            pos_g = style_positive
+            pos_l = prompt_positive
+            pos_r = style_positive
+            neg_g = style_negative
+            neg_l = prompt_negative
+            neg_r = style_negative
+        elif preset == "preset 4":
+            pos_g = prompt_positive + style_positive
+            pos_l = prompt_positive + style_positive
+            pos_r = prompt_positive + style_positive
+            neg_g = prompt_negative + style_negative
+            neg_l = prompt_negative + style_negative
+            neg_r = prompt_negative + style_negative
+        elif preset == "preset 5":
+            pos_g = prompt_positive
+            pos_l = prompt_positive
+            pos_r = style_positive
+            neg_g = prompt_negative
+            neg_l = prompt_negative
+            neg_r = style_negative
+        return (pos_g, pos_l, pos_r, neg_g, neg_l, neg_r, )
+
+
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+
+class Comfyroll_SDXLStyleText:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "positive_style": ("STRING", {"default": "POS_STYLE", "multiline": True}),
+                    "negative_style": ("STRING", {"default": "NEG_STYLE", "multiline": True}),
+                    },
+                }
+
+    RETURN_TYPES = ("STRING", "STRING", )
+    RETURN_NAMES = ("positive_prompt_text_l", "negative_prompt_text_l" )
+    FUNCTION = "get_value"
+
+    CATEGORY = "Comfyroll/SDXL"
+
+    def get_value(self, positive_style, negative_style):
+        return (positive_style, negative_style,)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class Comfyroll_SDXLBasePromptEncoder:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "base_clip": ("CLIP", ),
+                    "pos_g": ("STRING", {"multiline": True, "default": "POS_G"}),
+                    "pos_l": ("STRING", {"multiline": True, "default": "POS_L"}),
+                    "neg_g": ("STRING", {"multiline": True, "default": "NEG_G"}),
+                    "neg_l": ("STRING", {"multiline": True, "default": "NEG_L"}),
+                    "preset": (["preset A", "preset B", "preset C"],), 
+                    "base_width": ("INT", {"default": 4096.0, "min": 0, "max": MAX_RESOLUTION, "step": 64}),
+                    "base_height": ("INT", {"default": 4096.0, "min": 0, "max": MAX_RESOLUTION, "step": 64}),
+                    "crop_w": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 64}),
+                    "crop_h": ("INT", {"default": 0, "min": 0, "max": MAX_RESOLUTION, "step": 64}),
+                    "target_width": ("INT", {"default": 4096.0, "min": 0, "max": MAX_RESOLUTION, "step": 64}),
+                    "target_height": ("INT", {"default": 4096.0, "min": 0, "max": MAX_RESOLUTION, "step": 64}),
+                    },
+                }
+
+    RETURN_TYPES = ("CONDITIONING", "CONDITIONING", )
+    RETURN_NAMES = ("base_positive", "base_negative", )
+    FUNCTION = "encode"
+
+    CATEGORY = "Comfyroll/SDXL"
+
+    def encode(self, base_clip, pos_g, pos_l, neg_g, neg_l, base_width, base_height, crop_w, crop_h, target_width, target_height, preset,):
+        empty = base_clip.tokenize("")
+
+        # positive prompt
+        tokens1 = base_clip.tokenize(pos_g)
+        tokens1["l"] = base_clip.tokenize(pos_l)["l"]
+
+        if len(tokens1["l"]) != len(tokens1["g"]):
+            while len(tokens1["l"]) < len(tokens1["g"]):
+                tokens1["l"] += empty["l"]
+            while len(tokens1["l"]) > len(tokens1["g"]):
+                tokens1["g"] += empty["g"]
+
+        cond1, pooled1 = base_clip.encode_from_tokens(tokens1, return_pooled=True)
+        res1 = [[cond1, {"pooled_output": pooled1, "width": base_width, "height": base_height, "crop_w": crop_w, "crop_h": crop_h, "target_width": target_width, "target_height": target_height}]]
+
+        # negative prompt
+        tokens2 = base_clip.tokenize(neg_g)
+        tokens2["l"] = base_clip.tokenize(neg_l)["l"]
+
+        if len(tokens2["l"]) != len(tokens2["g"]):
+            while len(tokens2["l"]) < len(tokens2["g"]):
+                tokens2["l"] += empty["l"]
+            while len(tokens2["l"]) > len(tokens2["g"]):
+                tokens2["g"] += empty["g"]
+
+        cond2, pooled2 = base_clip.encode_from_tokens(tokens2, return_pooled=True)
+        res2 = [[cond2, {"pooled_output": pooled2, "width": base_width, "height": base_height, "crop_w": crop_w, "crop_h": crop_h, "target_width": target_width, "target_height": target_height}]]
+
+        # positive style
+        tokens2 = base_clip.tokenize(pos_l)
+        tokens2["l"] = base_clip.tokenize(neg_l)["l"]
+
+        if len(tokens2["l"]) != len(tokens2["g"]):
+            while len(tokens2["l"]) < len(tokens2["g"]):
+                tokens2["l"] += empty["l"]
+            while len(tokens2["l"]) > len(tokens2["g"]):
+                tokens2["g"] += empty["g"]
+
+        cond2, pooled2 = base_clip.encode_from_tokens(tokens2, return_pooled=True)
+        res3 = [[cond2, {"pooled_output": pooled2, "width": base_width, "height": base_height, "crop_w": crop_w, "crop_h": crop_h, "target_width": target_width, "target_height": target_height}]]
+
+        # negative style
+        tokens2 = base_clip.tokenize(neg_l)
+        tokens2["l"] = base_clip.tokenize(neg_l)["l"]
+
+        if len(tokens2["l"]) != len(tokens2["g"]):
+            while len(tokens2["l"]) < len(tokens2["g"]):
+                tokens2["l"] += empty["l"]
+            while len(tokens2["l"]) > len(tokens2["g"]):
+                tokens2["g"] += empty["g"]
+
+        cond2, pooled2 = base_clip.encode_from_tokens(tokens2, return_pooled=True)
+        res4 = [[cond2, {"pooled_output": pooled2, "width": base_width, "height": base_height, "crop_w": crop_w, "crop_h": crop_h, "target_width": target_width, "target_height": target_height}]]
+
+        if preset == "preset A":
+            base_positive = res1
+            base_negative = res2
+        elif preset == "preset B":
+            base_positive = res3
+            base_negative = res4
+        elif preset == "preset C":
+            base_positive = res1 + res3
+            base_negative = res2 + res4
+            
+        return (base_positive, base_negative, )
+
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+
+class Comfyroll_Halftone_Grid:
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {
+                    "width": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                    "height": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                    "dot_style": (["Accent","afmhot","autumn","binary","Blues","bone","BrBG","brg",
+                            "BuGn","BuPu","bwr","cividis","CMRmap","cool","coolwarm","copper","cubehelix","Dark2","flag",
+                            "gist_earth","gist_gray","gist_heat","gist_rainbow","gist_stern","gist_yarg","GnBu","gnuplot","gnuplot2","gray","Greens",
+                            "Greys","hot","hsv","inferno","jet","magma","nipy_spectral","ocean","Oranges","OrRd",
+                            "Paired","Pastel1","Pastel2","pink","PiYG","plasma","PRGn","prism","PuBu","PuBuGn",
+                            "PuOr","PuRd","Purples","rainbow","RdBu","RdGy","RdPu","RdYlBu","RdYlGn","Reds","seismic",
+                            "Set1","Set2","Set3","Spectral","spring","summer","tab10","tab20","tab20b","tab20c","terrain",
+                            "turbo","twilight","twilight_shifted","viridis","winter","Wistia","YlGn","YlGnBu","YlOrBr","YlOrRd"],),
+                    "reverse_dot_style": (["No", "Yes"],),
+                    "dot_frequency": ("INT", {"default": 50, "min": 1, "max":200, "step": 1}),
+                    "background_color": (["custom", "white", "black", "red", "green", "blue", "cyan", "magenta", "yellow", "purple", "orange", "lime", "navy", "teal", "maroon", "lavender", "olive"],),
+                    "background_R": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                    "background_G": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                    "background_B": ("INT", {"default": 255, "min": 0, "max": 255, "step": 1}),
+                    "x_pos": ("FLOAT", {"default": 0.5, "min": 0, "max": 1, "step": .01}),
+                    "y_pos": ("FLOAT", {"default": 0.5, "min": 0, "max": 1, "step": .01}),                    
+                    },
+                }
+
+    RETURN_TYPES = ("IMAGE", )
+    FUNCTION = "halftone"
+
+    CATEGORY = "Comfyroll/Image"
+
+    def halftone(self, width, height, dot_style, reverse_dot_style, dot_frequency, background_color, background_R, background_G, background_B, x_pos, y_pos):
+        if background_color == "custom":
+            bgc = (background_R/255, background_G/255, background_B/255)
+        else:
+            bgc = background_color
+            
+        reverse = ""
+        
+        if reverse_dot_style == "Yes":
+            reverse = "_r"
+        
+        #img = Image.new(mode = 'RGB', size = (300, 200), color = (red, green, blue))
+        fig, ax = plt.subplots(figsize=(width/100,height/100))
+        #fig, ax = plt.subplots(figsize=(width/20,height/20))
+        
+    
+        dotsx = np.linspace(0, 1, dot_frequency)
+        dotsy = np.linspace(0, 1, dot_frequency)
+    
+        X, Y = np.meshgrid(dotsx, dotsy)
+    
+        dist = np.sqrt((X - x_pos)**2 + (Y - y_pos)**2)
+    
+        fig.patch.set_facecolor(bgc)
+        ax.scatter(X, Y, c=dist, cmap=dot_style+reverse)
+            
+        plt.axis('off')
+        plt.tight_layout(pad=0, w_pad=0, h_pad=0)
+        plt.autoscale(tight=True)
+        plt.show()
+        
+        img_buf = io.BytesIO()
+        plt.savefig(img_buf, format='png')
+        img = Image.open(img_buf)
+        
+        return(pil2tensor(img),)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+
+
+class Comfyroll_LatentBatchSize:
+
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                "latent": ("LATENT", ),
+                "batch_size": ("INT", {
+                    "default": 2,
+                    "min": 1,
+                    "max": 16,
+                    "step": 1,
+                }),
+            },
+        }
+
+    RETURN_TYPES = ("LATENT", )
+
+    FUNCTION = "batchsize"
+
+    OUTPUT_NODE = False
+
+    CATEGORY = "Comfyroll/Latent"
+
+    def batchsize(self, latent: tg.Sequence[tg.Mapping[tg.Text, torch.Tensor]], batch_size: int):
+        samples = latent['samples']
+        shape = samples.shape
+
+        sample_list = [samples] + [
+            torch.clone(samples) for _ in range(batch_size - 1)
+        ]
+
+        return ({
+            'samples': torch.cat(sample_list),
+        }, )
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class Comfyroll_ApplyLoRA_Stack:
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"model": ("MODEL",),
+                            "clip": ("CLIP", ),
+                            "lora_stack": ("LORA_STACK", ),
+                            }
+        }
+
+    RETURN_TYPES = ("MODEL", "CLIP",)
+    RETURN_NAMES = ("MODEL", "CLIP", )
+    FUNCTION = "apply_lora_stack"
+    CATEGORY = "Comfyroll/IO"
+
+    def apply_lora_stack(self, model, clip, lora_stack=None,):
+
+        # Initialise the list
+        lora_params = list()
+ 
+        # Extend lora_params with lora-stack items 
+        if lora_stack:
+            lora_params.extend(lora_stack)
+        else:
+            return (model, clip,)
+
+        #print(lora_params)
+
+        # Initialise the model and clip
+        model_lora = model
+        clip_lora = clip
+
+        # Loop through the list
+        for tup in lora_params:
+            lora_name, strength_model, strength_clip = tup
+            print(lora_name, strength_model, strength_clip)
+            
+            lora_path = folder_paths.get_full_path("loras", lora_name)
+            lora = comfy.utils.load_torch_file(lora_path, safe_load=True)
+            
+            model_lora, clip_lora = comfy.sd.load_lora_for_models(model_lora, clip_lora, lora, strength_model, strength_clip)  
+
+        return (model_lora, clip_lora,)
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+# Based on Efficiency Nodes
+class Comfyroll_LoRA_Stack:
+
+    loras = ["None"] + folder_paths.get_filename_list("loras")
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+                    "switch_1": ([
+                        "Off",
+                        "On"],),
+                    "lora_name_1": (cls.loras,),
+                    "model_weight_1": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                    "clip_weight_1": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                    "switch_2": ([
+                        "Off",
+                        "On"],),
+                    "lora_name_2": (cls.loras,),
+                    "model_weight_2": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                    "clip_weight_2": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                    "switch_3": ([
+                        "Off",
+                        "On"],),
+                    "lora_name_3": (cls.loras,),
+                    "model_weight_3": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                    "clip_weight_3": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01}),
+                },
+                "optional": {"lora_stack": ("LORA_STACK",)
+                },
+        }
+
+    RETURN_TYPES = ("LORA_STACK",)
+    RETURN_NAMES = ("LORA_STACK",)
+    FUNCTION = "lora_stacker"
+    CATEGORY = "Comfyroll/IO"
+
+    def lora_stacker(self, lora_name_1, model_weight_1, clip_weight_1, switch_1, lora_name_2, model_weight_2, clip_weight_2, switch_2, lora_name_3, model_weight_3, clip_weight_3, switch_3, lora_stack=None):
+
+        # Initialise the list
+        lora_list=list()
+        
+        if lora_stack is not None:
+            lora_list.extend([l for l in lora_stack if l[0] != "None"])
+        
+        if lora_name_1 != "None" and  switch_1 == "On":
+            lora_list.extend([(lora_name_1, model_weight_1, clip_weight_1)]),
+
+        if lora_name_2 != "None" and  switch_2 == "On":
+            lora_list.extend([(lora_name_2, model_weight_2, clip_weight_2)]),
+
+        if lora_name_3 != "None" and  switch_3 == "On":
+            lora_list.extend([(lora_name_3, model_weight_3, clip_weight_3)]),
+           
+        return (lora_list,)
+
+
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+
+'''
+NODE_CLASS_MAPPINGS = {
+    "CR Image Input Switch": ComfyRoll_InputImages,
+    "CR Image Input Switch (4 way)": ComfyRoll_InputImages_4way,
+    "CR Latent Input Switch": ComfyRoll_InputLatents,
+    "CR Process Switch": ComfyRoll_InputLatentsText,
+    "CR Conditioning Input Switch": ComfyRoll_InputConditioning,
+    "CR Clip Input Switch": ComfyRoll_InputClip,
+    "CR Model Input Switch": ComfyRoll_InputModel,
+    "CR ControlNet Input Switch": ComfyRoll_InputControlNet,
+    "CR Load LoRA": ComfyRoll_LoraLoader,
+    "CR Apply ControlNet": ComfyRoll_ApplyControlNet,
+    "CR Image Size": ComfyRoll_ImageSize_Float,
+    "CR Image Output": ComfyRoll_ImageOutput,
+    "CR Integer Multiple": CR_Int_Multiple_Of,
+    "CR Aspect Ratio": ComfyRoll_AspectRatio,
+    "CR Aspect Ratio SDXL": ComfyRoll_AspectRatio_SDXL,
+    "CR Seed to Int": ComfyRoll_SeedToInt,
+    "CR Color Tint": Comfyroll_Color_Tint,
+    "CR SDXL Prompt Mixer": ComfyRoll_prompt_mixer,
+    "CR SDXL Style Text": Comfyroll_SDXLStyleText,
+    "CR SDXL Base Prompt Encoder": Comfyroll_SDXLBasePromptEncoder, 
+    "CR Hires Fix Process Switch": ComfyRoll_HiResFixSwitch,
+    "CR Halftones" :Comfyroll_Halftone_Grid,
+    "CR LoRA Stack":Comfyroll_LoRA_Stack,
+    "CR Apply LoRA Stack":Comfyroll_ApplyLoRA_Stack,
+    "CR Latent Batch Size":Comfyroll_LatentBatchSize
+}
+'''
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+# Credits                                                                                                                                           #
+# WASasquatch                             https://github.com/WASasquatch/was-node-suite-comfyui                                                     #
+# hnmr293				                  https://github.com/hnmr293/ComfyUI-nodes-hnmr      		                                                #
+# SeargeDP                                https://github.com/SeargeDP/SeargeSDXL                                                                    #
+# LucianoCirino                           https://github.com/LucianoCirino/efficiency-nodes-comfyui                                                 #
+# SLAPaper                                https://github.com/SLAPaper/ComfyUI-Image-Selector                                                        #
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+

ComfyUI_Comfyroll_CustomNodes/Comfyroll_Pipe_Nodes.py

@@ -0,0 +1,271 @@
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+# Comfyroll Pipe Nodes by Akatsuzi                          https://github.com/RockOfFire/ComfyUI_Comfyroll_CustomNodes                             #
+# for ComfyUI                                               https://github.com/comfyanonymous/ComfyUI                                               #
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+import os
+import sys
+import json
+import torch
+import comfy.sd
+import comfy.utils
+import numpy as np
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class module_pipe_loader:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                #"model": ("MODEL",),
+            },
+            "optional": {
+                "model": ("MODEL",),
+                "pos": ("CONDITIONING",),
+                "neg": ("CONDITIONING",),
+                "latent": ("LATENT",),
+                "vae": ("VAE",),
+                "clip": ("CLIP",),
+                "controlnet": ("CONTROL_NET",),
+                "image": ("IMAGE",),
+                "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff})            
+            },
+        }
+
+    RETURN_TYPES = ("PIPE_LINE", )
+    RETURN_NAMES = ("pipe", )
+    FUNCTION = "flush"
+
+    CATEGORY = "Comfyroll/Module"
+
+    def flush(self, model=0, pos=0, neg=0, latent=0, vae=0, clip=0, controlnet=0, image=0, seed=0):
+        pipe_line = (model, pos, neg, latent, vae, clip, controlnet, image, seed)
+        return (pipe_line, )
+        
+#---------------------------------------------------------------------------------------------------------------------------------------------------#       
+        
+class module_input:
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {"pipe": ("PIPE_LINE",)},
+            }
+
+    RETURN_TYPES = ("PIPE_LINE", "MODEL", "CONDITIONING", "CONDITIONING", "LATENT", "VAE", "CLIP", "CONTROL_NET", "IMAGE", "INT")
+    RETURN_NAMES = ("pipe", "model", "pos", "neg", "latent", "vae", "clip", "controlnet", "image", "seed")
+    FUNCTION = "flush"
+
+    CATEGORY = "Comfyroll/Module"
+    
+    def flush(self, pipe):
+        model, pos, neg, latent, vae, clip, controlnet, image, seed = pipe
+        return pipe, model, pos, neg, latent, vae, clip, controlnet, image, seed
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+ 
+class module_output:
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"pipe": ("PIPE_LINE",)},
+                "optional": {
+                    "model": ("MODEL",),
+                    "pos": ("CONDITIONING",),
+                    "neg": ("CONDITIONING",),
+                    "latent": ("LATENT",),
+                    "vae": ("VAE",),
+                    "clip": ("CLIP",),
+                    "controlnet": ("CONTROL_NET",),
+                    "image": ("IMAGE",),
+                    "seed": ("INT", {"default": 0, "min": 0, "max": 0xffffffffffffffff})
+                },
+            }
+
+    RETURN_TYPES = ("PIPE_LINE", )
+    RETURN_NAMES = ("pipe", )
+    FUNCTION = "flush"
+
+    CATEGORY = "Comfyroll/Module"
+
+    def flush(self, pipe, model=None, pos=None, neg=None, latent=None, vae=None, clip=None, controlnet=None, image=None, seed=None):
+        new_model, new_pos, new_neg, new_latent, new_vae, new_clip, new_controlnet, new_image, new_seed = pipe
+
+        if model is not None:
+            new_model = model
+        
+        if pos is not None:
+            new_pos = pos
+
+        if neg is not None:
+            new_neg = neg
+
+        if latent is not None:
+            new_latent = latent
+
+        if vae is not None:
+            new_vae = vae
+
+        if clip is not None:
+            new_clip = clip
+            
+        if controlnet is not None:
+            new_controlnet = controlnet
+            
+        if image is not None:
+            new_image = image
+            
+        if seed is not None:
+            new_seed = seed
+       
+        pipe = new_model, new_pos, new_neg, new_latent, new_vae, new_clip, new_controlnet, new_image, new_seed
+        return (pipe, )
+        
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+        
+class image_pipe_in:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {
+                #"model": ("MODEL",),
+            },
+            "optional": {
+                "image": ("IMAGE",),
+                "width": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                "height": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                "upscale_factor": ("FLOAT", {"default": 1, "min": 1, "max": 2000})
+            },
+        }
+
+    RETURN_TYPES = ("PIPE_LINE", )
+    RETURN_NAMES = ("pipe", )
+    FUNCTION = "flush"
+
+    CATEGORY = "Comfyroll/Module"
+
+    def flush(self, image=0, width=0, height=0, upscale_factor=0):
+        pipe_line = (image, width, height, upscale_factor)
+        return (pipe_line, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class image_pipe_edit:
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def INPUT_TYPES(s):
+        return {"required": {"pipe": ("PIPE_LINE",)},
+                "optional": {
+                    "image": ("IMAGE",),
+                    "width": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                    "height": ("INT", {"default": 512, "min": 64, "max": 2048}),
+                    "upscale_factor": ("FLOAT", {"default": 1, "min": 1, "max": 2000})
+                },
+            }
+
+    RETURN_TYPES = ("PIPE_LINE", )
+    RETURN_NAMES = ("pipe", )
+    FUNCTION = "flush"
+
+    CATEGORY = "Comfyroll/Module"
+
+    def flush(self, pipe, image=None, width=None, height=None, upscale_factor=None):
+        new_image, new_width, new_height, new_upscale_factor = pipe
+
+        if image is not None:
+            new_image = image
+            
+        if width is not None:
+            new_width = width
+            
+        if height is not None:
+            new_height = height
+
+        if upscale_factor is not None:
+            new_upscale_factor = upscale_factor
+            
+        pipe = new_image, new_width, new_height, new_upscale_factor
+        return (pipe, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class image_pipe_out:
+    def __init__(self):
+        pass
+    
+    @classmethod
+    def INPUT_TYPES(s):
+        return {
+            "required": {"pipe": ("PIPE_LINE",)},
+            }
+
+    RETURN_TYPES = ("PIPE_LINE", "IMAGE", "INT", "INT", "FLOAT",)
+    RETURN_NAMES = ("pipe", "image", "width", "height", "upscale_factor")
+    FUNCTION = "flush"
+
+    CATEGORY = "Comfyroll/Module"
+    
+    def flush(self, pipe):
+        #if switch == "Off":
+            #return (pipe, )
+        #else:  
+            image, width, height, upscale_factor = pipe
+            return pipe, image, width, height, upscale_factor
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+
+class input_switch_pipe:
+    def __init__(self):
+        pass
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "Input": ("INT", {"default": 1, "min": 1, "max": 2}),
+                "pipe1": ("PIPE_LINE",),
+                "pipe2": ("PIPE_LINE",)
+            }
+        }
+
+    RETURN_TYPES = ("PIPE_LINE",)
+    OUTPUT_NODE = True
+    FUNCTION = "InputSwitchPipe"
+
+    CATEGORY = "Comfyroll/Module"
+
+    def InputSwitchPipe(self, Input, pipe1, pipe2):
+        if Input == 1:
+            return (pipe1, )
+        else:
+            return (pipe2, )
+
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+'''
+NODE_CLASS_MAPPINGS_2 = {
+    "CR Module Pipe Loader": module_pipe_loader,
+    "CR Module Input": module_input,
+    "CR Module Output": module_output,
+    "CR Image Pipe In": image_pipe_in,
+    "CR Image Pipe Edit": image_pipe_edit,
+    "CR Image Pipe Out": image_pipe_out,
+    "CR Pipe Switch": input_switch_pipe,
+}
+'''
+#---------------------------------------------------------------------------------------------------------------------------------------------------#
+# Credits   
+# TinyTerra                               https://github.com/TinyTerra/ComfyUI_tinyterraNodes                                                       #
+#---------------------------------------------------------------------------------------------------------------------------------------------------#

ComfyUI_Comfyroll_CustomNodes/README.md

@@ -0,0 +1,89 @@
+# Comfyroll Custom Nodes
+
+These nodes were originally made for use in the Comfyroll Template Workflows.
+
+[ComfyUI Template Workflows](https://civitai.com/models/59806/comfyroll-template-workflows)
+
+[Comfyroll Pro Templates](https://civitai.com/models/85619/comfyroll-pro-template)
+
+The nodes can be used in any ComfyUI workflow.
+
+# Installation
+
+If you have a previous version of the Comfyroll nodes from the Comfyroll Worflow Templates download, please delete this before installing these nodes.
+
+1. cd custom_nodes
+2. git clone https://github.com/RockOfFire/ComfyUI_Comfyroll_CustomNodes.git
+3. Restart ComfyUI
+
+You can also install the nodes using the following methods:
+* install using [ComfyUI Manager](https://github.com/ltdrdata/ComfyUI-Manager)
+* download from [CivitAI](https://civitai.com/models/87609/comfyroll-custom-nodes-for-comfyui)
+
+# List of Custom Nodes
+
+__Logic__
+* CR Image Input Switch
+* CR Image Input Switch (4 way)
+* CR Latent Input Switch
+* CR Conditioning Input Switch
+* CR Clip Input Switch
+* CR Model Input Switch
+* CR ControlNet Input Switch
+
+__Process__
+* CR Img2Img Process Switch
+* CR Hires Fix Process Switch
+
+__IO__
+* CR Load LoRA
+  
+__Maths__
+* CR Integer Multiple
+
+__Number__
+* CR Seed to Int
+
+__Image__
+* CR Image Size
+* CR Aspect Ratio
+* CR Color Tint
+
+__Conditioning__
+* CR Apply ControlNet
+
+__SDXL__
+* CR Aspect Ratio SDXL
+* CR SDXL Prompt Mixer
+* CR SDXL Style Text
+* CR SDXL Base Prompt Encoder
+
+__Module__
+* CR Module Pipe Loader
+* CR Module Input
+* CR Module Output
+* CR Image Pipe In
+* CR Image Pipe Edit
+* CR Image Pipe Out
+* CR Pipe Switch
+
+
+![Custom Nodes](/images/custom_nodes_image1.png)
+
+![Custom Nodes](/images/custom_nodes_image2.jpg)
+
+![Custom Nodes](/images/custom_nodes_image3.JPG)
+
+![Custom Nodes](/images/custom_nodes_image4.JPG)
+
+# Credits
+
+comfyanonymous/[ComfyUI](https://github.com/comfyanonymous/ComfyUI) - A powerful and modular stable diffusion GUI.
+
+WASasquatch/[was-node-suite-comfyui](https://github.com/WASasquatch/was-node-suite-comfyui) - A powerful custom node extensions of ComfyUI.
+
+TinyTerra/[ComfyUI_tinyterraNodes](https://github.com/TinyTerra/ComfyUI_tinyterraNodes) - A selection of nodes for Stable Diffusion ComfyUI
+
+hnmr293/[ComfyUI-nodes-hnmr](https://github.com/hnmr293/ComfyUI-nodes-hnmr) - ComfyUI custom nodes - merge, grid (aka xyz-plot) and others
+
+SeargeDP/[SeargeSDXL](https://github.com/SeargeDP) - ComfyUI custom nodes - Prompt nodes and Conditioning nodes

ComfyUI_Comfyroll_CustomNodes/__init__.py

@@ -0,0 +1,48 @@
+from .Comfyroll_Nodes import *
+from .Comfyroll_Pipe_Nodes import *
+#from .Comfyroll_Test_Nodes import *
+
+NODE_CLASS_MAPPINGS = {
+    "CR Module Pipe Loader": module_pipe_loader,
+    "CR Module Input": module_input,
+    "CR Module Output": module_output,
+    "CR Image Pipe In": image_pipe_in,
+    "CR Image Pipe Edit": image_pipe_edit,
+    "CR Image Pipe Out": image_pipe_out,
+    "CR Pipe Switch": input_switch_pipe,
+    "CR Image Input Switch": ComfyRoll_InputImages,
+    "CR Image Input Switch (4 way)": ComfyRoll_InputImages_4way,
+    "CR Latent Input Switch": ComfyRoll_InputLatents,
+    "CR Conditioning Input Switch": ComfyRoll_InputConditioning,
+    "CR Clip Input Switch": ComfyRoll_InputClip,
+    "CR Model Input Switch": ComfyRoll_InputModel,
+    "CR ControlNet Input Switch": ComfyRoll_InputControlNet,
+    "CR Load LoRA": ComfyRoll_LoraLoader,
+    "CR Apply ControlNet": ComfyRoll_ApplyControlNet,
+    "CR Image Size": ComfyRoll_ImageSize_Float,
+    "CR Image Output": ComfyRoll_ImageOutput,
+    "CR Integer Multiple": CR_Int_Multiple_Of,
+    "CR Aspect Ratio": ComfyRoll_AspectRatio,
+    "CR Aspect Ratio SDXL": ComfyRoll_AspectRatio_SDXL,
+    "CR Seed to Int": ComfyRoll_SeedToInt,
+    "CR Color Tint": Comfyroll_Color_Tint,
+    "CR SDXL Prompt Mixer": ComfyRoll_prompt_mixer,
+    "CR SDXL Style Text": Comfyroll_SDXLStyleText,
+    "CR SDXL Base Prompt Encoder": Comfyroll_SDXLBasePromptEncoder, 
+    "CR Img2Img Process Switch": ComfyRoll_InputLatentsText,
+    "CR Hires Fix Process Switch": ComfyRoll_HiResFixSwitch,
+    "CR Halftone Grid" : Comfyroll_Halftone_Grid,
+    "CR Latent Batch Size": Comfyroll_LatentBatchSize,
+    "CR LoRA Stack":Comfyroll_LoRA_Stack,
+    "CR Apply LoRA Stack":Comfyroll_ApplyLoRA_Stack,
+    ### test nodes
+    #"CR Latent Upscale (Iterative)":Comfyroll_LatentUpscaleIterative,
+    #"CR KSampler (Iterative)":Comfyroll_Iterative_KSampler,
+    #"CR Load Image Sequence":Comfyroll_LoadImageSequence,
+    #"CR Switch": Comfyroll_Comfyroll_Switch_Test,
+    #"CR Halftone Image":Comfyroll_ConvertImageToHalftone,
+}
+
+__all__ = ['NODE_CLASS_MAPPINGS']
+
+print("\033[34mComfyroll Custom Nodes: \033[92mLoaded\033[0m")