471 lines
13 KiB
Python
471 lines
13 KiB
Python
# SimpleLogics - ComfyUI node library for logic, math, and type conversion
|
|
|
|
|
|
# --- Type Conversion ---
|
|
|
|
class IntToFloat:
|
|
DESCRIPTION = "Converts an integer to a float."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"value": ("INT", {"default": 0})}}
|
|
RETURN_TYPES = ("FLOAT",)
|
|
FUNCTION = "convert"
|
|
CATEGORY = "SimpleLogics/Convert"
|
|
|
|
def convert(self, value):
|
|
return (float(value),)
|
|
|
|
|
|
class FloatToInt:
|
|
DESCRIPTION = "Converts a float to an integer by truncating the decimal part."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"value": ("FLOAT", {"default": 0.0})}}
|
|
RETURN_TYPES = ("INT",)
|
|
FUNCTION = "convert"
|
|
CATEGORY = "SimpleLogics/Convert"
|
|
|
|
def convert(self, value):
|
|
return (int(value),)
|
|
|
|
|
|
class IntToString:
|
|
DESCRIPTION = "Converts an integer to its string representation."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"value": ("INT", {"default": 0})}}
|
|
RETURN_TYPES = ("STRING",)
|
|
FUNCTION = "convert"
|
|
CATEGORY = "SimpleLogics/Convert"
|
|
|
|
def convert(self, value):
|
|
return (str(value),)
|
|
|
|
|
|
class FloatToString:
|
|
DESCRIPTION = "Converts a float to its string representation."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"value": ("FLOAT", {"default": 0.0})}}
|
|
RETURN_TYPES = ("STRING",)
|
|
FUNCTION = "convert"
|
|
CATEGORY = "SimpleLogics/Convert"
|
|
|
|
def convert(self, value):
|
|
return (str(value),)
|
|
|
|
|
|
class StringToInt:
|
|
DESCRIPTION = "Parses a string into an integer. Accepts decimal strings like '3.9' (truncated to 3)."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"value": ("STRING", {"default": "0"})}}
|
|
RETURN_TYPES = ("INT",)
|
|
FUNCTION = "convert"
|
|
CATEGORY = "SimpleLogics/Convert"
|
|
|
|
def convert(self, value):
|
|
return (int(float(value)),)
|
|
|
|
|
|
class StringToFloat:
|
|
DESCRIPTION = "Parses a string into a float."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"value": ("STRING", {"default": "0.0"})}}
|
|
RETURN_TYPES = ("FLOAT",)
|
|
FUNCTION = "convert"
|
|
CATEGORY = "SimpleLogics/Convert"
|
|
|
|
def convert(self, value):
|
|
return (float(value),)
|
|
|
|
|
|
class BoolToInt:
|
|
DESCRIPTION = "Converts a boolean to an integer: True → 1, False → 0."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"value": ("BOOLEAN", {"default": False})}}
|
|
RETURN_TYPES = ("INT",)
|
|
FUNCTION = "convert"
|
|
CATEGORY = "SimpleLogics/Convert"
|
|
|
|
def convert(self, value):
|
|
return (1 if value else 0,)
|
|
|
|
|
|
class IntToBool:
|
|
DESCRIPTION = "Converts an integer to a boolean: 0 → False, any other value → True."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"value": ("INT", {"default": 0})}}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "convert"
|
|
CATEGORY = "SimpleLogics/Convert"
|
|
|
|
def convert(self, value):
|
|
return (value != 0,)
|
|
|
|
|
|
# --- Logic Operators ---
|
|
|
|
class LogicAND:
|
|
DESCRIPTION = "Returns True only if both inputs are True."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("BOOLEAN", {"default": False}), "b": ("BOOLEAN", {"default": False})}}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Logic"
|
|
|
|
def op(self, a, b):
|
|
return (a and b,)
|
|
|
|
|
|
class LogicOR:
|
|
DESCRIPTION = "Returns True if at least one input is True."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("BOOLEAN", {"default": False}), "b": ("BOOLEAN", {"default": False})}}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Logic"
|
|
|
|
def op(self, a, b):
|
|
return (a or b,)
|
|
|
|
|
|
class LogicNOT:
|
|
DESCRIPTION = "Returns the opposite boolean value of the input."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("BOOLEAN", {"default": False})}}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Logic"
|
|
|
|
def op(self, a):
|
|
return (not a,)
|
|
|
|
|
|
class LogicXOR:
|
|
DESCRIPTION = "Returns True if exactly one of the two inputs is True."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("BOOLEAN", {"default": False}), "b": ("BOOLEAN", {"default": False})}}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Logic"
|
|
|
|
def op(self, a, b):
|
|
return (a ^ b,)
|
|
|
|
|
|
class LogicNAND:
|
|
DESCRIPTION = "Returns False only if both inputs are True (NOT AND)."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("BOOLEAN", {"default": False}), "b": ("BOOLEAN", {"default": False})}}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Logic"
|
|
|
|
def op(self, a, b):
|
|
return (not (a and b),)
|
|
|
|
|
|
class LogicNOR:
|
|
DESCRIPTION = "Returns True only if both inputs are False (NOT OR)."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("BOOLEAN", {"default": False}), "b": ("BOOLEAN", {"default": False})}}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Logic"
|
|
|
|
def op(self, a, b):
|
|
return (not (a or b),)
|
|
|
|
|
|
# --- Comparison ---
|
|
|
|
class CompareInt:
|
|
DESCRIPTION = "Compares two integers using the selected operator and returns a boolean result."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"a": ("INT", {"default": 0}),
|
|
"b": ("INT", {"default": 0}),
|
|
"op": (["==", "!=", ">", "<", ">=", "<="],),
|
|
}
|
|
}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "compare"
|
|
CATEGORY = "SimpleLogics/Compare"
|
|
|
|
def compare(self, a, b, op):
|
|
result = {"==": a == b, "!=": a != b, ">": a > b, "<": a < b, ">=": a >= b, "<=": a <= b}[op]
|
|
return (result,)
|
|
|
|
|
|
class CompareFloat:
|
|
DESCRIPTION = "Compares two floats using the selected operator and returns a boolean result."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"a": ("FLOAT", {"default": 0.0}),
|
|
"b": ("FLOAT", {"default": 0.0}),
|
|
"op": (["==", "!=", ">", "<", ">=", "<="],),
|
|
}
|
|
}
|
|
RETURN_TYPES = ("BOOLEAN",)
|
|
FUNCTION = "compare"
|
|
CATEGORY = "SimpleLogics/Compare"
|
|
|
|
def compare(self, a, b, op):
|
|
result = {"==": a == b, "!=": a != b, ">": a > b, "<": a < b, ">=": a >= b, "<=": a <= b}[op]
|
|
return (result,)
|
|
|
|
|
|
# --- Math ---
|
|
|
|
class MathMaxInt:
|
|
DESCRIPTION = "Returns the larger of two integers."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("INT", {"default": 0}), "b": ("INT", {"default": 0})}}
|
|
RETURN_TYPES = ("INT",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Math"
|
|
|
|
def op(self, a, b):
|
|
return (max(a, b),)
|
|
|
|
|
|
class MathMinInt:
|
|
DESCRIPTION = "Returns the smaller of two integers."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("INT", {"default": 0}), "b": ("INT", {"default": 0})}}
|
|
RETURN_TYPES = ("INT",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Math"
|
|
|
|
def op(self, a, b):
|
|
return (min(a, b),)
|
|
|
|
|
|
class MathMaxFloat:
|
|
DESCRIPTION = "Returns the larger of two floats."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("FLOAT", {"default": 0.0}), "b": ("FLOAT", {"default": 0.0})}}
|
|
RETURN_TYPES = ("FLOAT",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Math"
|
|
|
|
def op(self, a, b):
|
|
return (max(a, b),)
|
|
|
|
|
|
class MathMinFloat:
|
|
DESCRIPTION = "Returns the smaller of two floats."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {"required": {"a": ("FLOAT", {"default": 0.0}), "b": ("FLOAT", {"default": 0.0})}}
|
|
RETURN_TYPES = ("FLOAT",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Math"
|
|
|
|
def op(self, a, b):
|
|
return (min(a, b),)
|
|
|
|
|
|
class MathClampInt:
|
|
DESCRIPTION = "Clamps an integer between a minimum and maximum value."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"value": ("INT", {"default": 0}),
|
|
"min_val": ("INT", {"default": 0}),
|
|
"max_val": ("INT", {"default": 100}),
|
|
}
|
|
}
|
|
RETURN_TYPES = ("INT",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Math"
|
|
|
|
def op(self, value, min_val, max_val):
|
|
return (max(min_val, min(max_val, value)),)
|
|
|
|
|
|
class MathClampFloat:
|
|
DESCRIPTION = "Clamps a float between a minimum and maximum value."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"value": ("FLOAT", {"default": 0.0}),
|
|
"min_val": ("FLOAT", {"default": 0.0}),
|
|
"max_val": ("FLOAT", {"default": 1.0}),
|
|
}
|
|
}
|
|
RETURN_TYPES = ("FLOAT",)
|
|
FUNCTION = "op"
|
|
CATEGORY = "SimpleLogics/Math"
|
|
|
|
def op(self, value, min_val, max_val):
|
|
return (max(min_val, min(max_val, value)),)
|
|
|
|
|
|
# --- Switch Nodes ---
|
|
|
|
class SwitchInt:
|
|
DESCRIPTION = "Returns if_true when condition is True, otherwise returns if_false. Works with integers."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"condition": ("BOOLEAN", {"default": False}),
|
|
"if_true": ("INT", {"default": 0}),
|
|
"if_false": ("INT", {"default": 0}),
|
|
}
|
|
}
|
|
RETURN_TYPES = ("INT",)
|
|
FUNCTION = "switch"
|
|
CATEGORY = "SimpleLogics/Switch"
|
|
|
|
def switch(self, condition, if_true, if_false):
|
|
return (if_true if condition else if_false,)
|
|
|
|
|
|
class SwitchFloat:
|
|
DESCRIPTION = "Returns if_true when condition is True, otherwise returns if_false. Works with floats."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"condition": ("BOOLEAN", {"default": False}),
|
|
"if_true": ("FLOAT", {"default": 0.0}),
|
|
"if_false": ("FLOAT", {"default": 0.0}),
|
|
}
|
|
}
|
|
RETURN_TYPES = ("FLOAT",)
|
|
FUNCTION = "switch"
|
|
CATEGORY = "SimpleLogics/Switch"
|
|
|
|
def switch(self, condition, if_true, if_false):
|
|
return (if_true if condition else if_false,)
|
|
|
|
|
|
class SwitchString:
|
|
DESCRIPTION = "Returns if_true when condition is True, otherwise returns if_false. Works with strings."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"condition": ("BOOLEAN", {"default": False}),
|
|
"if_true": ("STRING", {"default": ""}),
|
|
"if_false": ("STRING", {"default": ""}),
|
|
}
|
|
}
|
|
RETURN_TYPES = ("STRING",)
|
|
FUNCTION = "switch"
|
|
CATEGORY = "SimpleLogics/Switch"
|
|
|
|
def switch(self, condition, if_true, if_false):
|
|
return (if_true if condition else if_false,)
|
|
|
|
|
|
class SwitchAny:
|
|
DESCRIPTION = "Returns if_true when condition is True, otherwise returns if_false. Works with any type."
|
|
@classmethod
|
|
def INPUT_TYPES(cls):
|
|
return {
|
|
"required": {
|
|
"condition": ("BOOLEAN", {"default": False}),
|
|
"if_true": ("*",),
|
|
"if_false": ("*",),
|
|
}
|
|
}
|
|
RETURN_TYPES = ("*",)
|
|
FUNCTION = "switch"
|
|
CATEGORY = "SimpleLogics/Switch"
|
|
|
|
def switch(self, condition, if_true, if_false):
|
|
return (if_true if condition else if_false,)
|
|
|
|
|
|
# --- Mappings ---
|
|
|
|
NODE_CLASS_MAPPINGS = {
|
|
# Convert
|
|
"SL_IntToFloat": IntToFloat,
|
|
"SL_FloatToInt": FloatToInt,
|
|
"SL_IntToString": IntToString,
|
|
"SL_FloatToString": FloatToString,
|
|
"SL_StringToInt": StringToInt,
|
|
"SL_StringToFloat": StringToFloat,
|
|
"SL_BoolToInt": BoolToInt,
|
|
"SL_IntToBool": IntToBool,
|
|
# Logic
|
|
"SL_AND": LogicAND,
|
|
"SL_OR": LogicOR,
|
|
"SL_NOT": LogicNOT,
|
|
"SL_XOR": LogicXOR,
|
|
"SL_NAND": LogicNAND,
|
|
"SL_NOR": LogicNOR,
|
|
# Compare
|
|
"SL_CompareInt": CompareInt,
|
|
"SL_CompareFloat": CompareFloat,
|
|
# Math
|
|
"SL_MaxInt": MathMaxInt,
|
|
"SL_MinInt": MathMinInt,
|
|
"SL_MaxFloat": MathMaxFloat,
|
|
"SL_MinFloat": MathMinFloat,
|
|
"SL_ClampInt": MathClampInt,
|
|
"SL_ClampFloat": MathClampFloat,
|
|
# Switch
|
|
"SL_SwitchInt": SwitchInt,
|
|
"SL_SwitchFloat": SwitchFloat,
|
|
"SL_SwitchString": SwitchString,
|
|
"SL_SwitchAny": SwitchAny,
|
|
}
|
|
|
|
NODE_DISPLAY_NAME_MAPPINGS = {
|
|
# Convert
|
|
"SL_IntToFloat": "Int → Float",
|
|
"SL_FloatToInt": "Float → Int",
|
|
"SL_IntToString": "Int → String",
|
|
"SL_FloatToString": "Float → String",
|
|
"SL_StringToInt": "String → Int",
|
|
"SL_StringToFloat": "String → Float",
|
|
"SL_BoolToInt": "Bool → Int",
|
|
"SL_IntToBool": "Int → Bool",
|
|
# Logic
|
|
"SL_AND": "AND",
|
|
"SL_OR": "OR",
|
|
"SL_NOT": "NOT",
|
|
"SL_XOR": "XOR",
|
|
"SL_NAND": "NAND",
|
|
"SL_NOR": "NOR",
|
|
# Compare
|
|
"SL_CompareInt": "Compare Int",
|
|
"SL_CompareFloat": "Compare Float",
|
|
# Math
|
|
"SL_MaxInt": "Max Int",
|
|
"SL_MinInt": "Min Int",
|
|
"SL_MaxFloat": "Max Float",
|
|
"SL_MinFloat": "Min Float",
|
|
"SL_ClampInt": "Clamp Int",
|
|
"SL_ClampFloat": "Clamp Float",
|
|
# Switch
|
|
"SL_SwitchInt": "Switch Int",
|
|
"SL_SwitchFloat": "Switch Float",
|
|
"SL_SwitchString": "Switch String",
|
|
"SL_SwitchAny": "Switch Any",
|
|
}
|