def updatePreset(self, context):
if self.preset != "0":
# if preset, set preset
if self.previousSetting != self.preset:
using = self.p[self.preset]
self.source = using[0]
self.vTrunc = using[1]
self.eTrunc = using[2]
self.dual = using[3]
self.snub = using[4]
else:
using = self.p[self.preset]
result0 = self.source == using[0]
result1 = abs(self.vTrunc - using[1]) < 0.004
result2 = abs(self.eTrunc - using[2]) < 0.0015
result4 = using[4] == self.snub or ((using[4] == "Left") and
self.snub in ["Left", "Right"])
if (result0 and result1 and result2 and result4):
if self.p[self.previousSetting][3] != self.dual:
if self.preset[0] == "d":
self.preset = self.preset[1:]
else:
self.preset = "d" + self.preset
else:
self.preset = "0"
updateNode(self, context)
def mode_change(self, context):
# just because click doesn't mean we need to change mode
mode = self.mode
if mode == self.current_mode:
return
if mode == 'VERTEX':
n = 2 if "Vert A" in self.inputs else 1
while len(self.inputs) > n:
self.inputs.remove(self.inputs[-1])
if n == 1:
self.inputs.new('VerticesSocket', "Vert A", "Vert A")
if mode == 'AXIS':
n = 2 if "Vert A" in self.inputs else 1
if n == 2:
while len(self.inputs) > n:
self.inputs.remove(self.inputs[-1])
self.inputs.new('VerticesSocket', "Vert B", "Vert B")
else:
while len(self.inputs) > n:
self.inputs.remove(self.inputs[-1])
self.inputs.new('VerticesSocket', "Vert A", "Vert A")
self.inputs.new('VerticesSocket', "Vert B", "Vert B")
if mode == 'PLANE':
while len(self.inputs) > 1:
self.inputs.remove(self.inputs[-1])
self.inputs.new('MatrixSocket', "Plane", "Plane")
self.current_mode = mode
updateNode(self, context)
def update_mode(self, context):
if self.mode == self.last_mode:
return
self.last_mode = self.mode
self.update_sockets(context)
updateNode(self, context)
def update_angles(self, context):
""" Convert angle values to selected angle units """
if self.last_angle_units == "RAD":
if self.angle_units == "RAD":
au = 1.0 # RAD -> RAD
elif self.angle_units == "DEG":
au = 180.0 / pi # RAD -> DEG
elif self.angle_units == "UNI":
au = 0.5 / pi # RAD -> UNI
elif self.last_angle_units == "DEG":
if self.angle_units == "RAD":
au = pi / 180 # DEG -> RAD
elif self.angle_units == "DEG":
au = 1.0 # DEG -> DEG
elif self.angle_units == "UNI":
au = 1.0 / 360 # DEG -> UNI
elif self.last_angle_units == "UNI":
if self.angle_units == "RAD":
au = 2 * pi # UNI -> RAD
elif self.angle_units == "DEG":
au = 360 # UNI -> DEG
elif self.angle_units == "UNI":
au = 1.0 # UNI -> UNI
self.last_angle_units = self.angle_units
self.updating = True # inhibit update calls
self.twist = au * self.twist # convert to current angle units
self.phase = au * self.phase # convert to current angle units
self.updating = False
updateNode(self, context)
def mode_change(self, context):
if not (self.items_ == self.current_op):
self.label = self.items_
self.update_outputs_and_inputs()
self.current_op = self.items_
updateNode(self, context)
def update_mode(self, context):
self.inputs['Radius'].hide_safe = (self.mode not in ['BySphere', 'ByPlane', 'ByCylinder', 'BBox'])
self.inputs['Center'].hide_safe = (self.mode not in ['BySphere', 'ByPlane', 'ByCylinder', 'Outside', 'BBox'])
self.inputs['Percent'].hide_safe = (self.mode not in ['BySide', 'ByNormal', 'EdgeDir', 'Outside'])
self.inputs['Direction'].hide_safe = (self.mode not in ['BySide', 'ByNormal', 'ByPlane', 'ByCylinder', 'EdgeDir'])
updateNode(self, context)
def mode_change(self, context):
if not (self.selected_hyper == self.current_hyper):
self.label = self.selected_hyper
self.update_outputs_and_inputs()
self.current_hyper = self.selected_hyper
updateNode(self, context)
def update_mode(self, context):
self.inputs['Matrices'].hide_safe = (self.transform_mode != "Matrix")
self.inputs['Height'].hide_safe = (self.transform_mode != "Normal")
self.inputs['Scale'].hide_safe = (self.transform_mode != "Normal")
if self.transform_mode == "Normal":
self.multiple = True
updateNode(self, context)
def update_value(self, context):
if self.int_ < self.minim:
self.int_ = self.minim
return
if self.int_ > self.maxim:
self.int_ = self.maxim
return
updateNode(self, context)
def property_change(node, context, origin):
if origin == 'input_mode_one':
node.inputs[0].prop_name = {'Float': 'x_', 'Int': 'xi_'}.get(getattr(node, origin))
elif origin == 'input_mode_two' and len(node.inputs) == 2:
node.inputs[1].prop_name = {'Float': 'y_', 'Int': 'yi_'}.get(getattr(node, origin))
else:
pass
updateNode(node, context)
def update_mode(self, context):
self.inputs['Verts A'].hide_safe = self.nest_objs
self.inputs['Polys A'].hide_safe = self.nest_objs
self.inputs['Verts B'].hide_safe = self.nest_objs
self.inputs['Polys B'].hide_safe = self.nest_objs
self.inputs['Verts Nested'].hide_safe = not self.nest_objs
self.inputs['Polys Nested'].hide_safe = not self.nest_objs
updateNode(self, context)
def update_mode(self, context):
self.outputs['NewVertices'].hide_safe = not self.show_new
self.outputs['NewEdges'].hide_safe = not self.show_new
self.outputs['NewFaces'].hide_safe = not self.show_new
self.outputs['OldVertices'].hide_safe = not self.show_old
self.outputs['OldEdges'].hide_safe = not self.show_old
self.outputs['OldFaces'].hide_safe = not self.show_old
updateNode(self, context)
def update_type(self, context):
if self.numType == 'INT':
self.inputs['v1'].prop_name = "value_int1"
self.inputs['v2'].prop_name = "value_int2"
else: # float type
self.inputs['v1'].prop_name = "value_float1"
self.inputs['v2'].prop_name = "value_float2"
updateNode(self, context)
def update_mode(self, context):
if self.mode == 'EXT_INT':
self.inputs['R'].prop_name = "torus_eR"
self.inputs['r'].prop_name = "torus_iR"
else:
self.inputs['R'].prop_name = "torus_R"
self.inputs['r'].prop_name = "torus_r"
updateNode(self, context)
def update_mode(self, context):
# switch radii input sockets (R,r) <=> (eR,iR)
if self.mode == 'EXT_INT':
self.inputs['R'].prop_name = "ring_eR"
self.inputs['r'].prop_name = "ring_iR"
else:
self.inputs['R'].prop_name = "ring_R"
self.inputs['r'].prop_name = "ring_r"
updateNode(self, context)
def set_child_quota(self, context):
updateNode(self, context)
# post update check
if self.auto_release:
parent = self.name_node_generated_parent
if parent:
for obj in bpy.data.objects[parent].children:
if not obj.name == self.name_child:
obj.parent = None
def on_update_dims(self, context):
if self.dimensions < 4:
self.formula4 = ""
if self.dimensions < 3:
self.formula3 = ""
if self.dimensions < 2:
self.formula2 = ""
self.adjust_sockets()
updateNode(self, context)
def reload(self):
if self.textmode == "CSV":
self.reload_csv()
elif self.textmode == "SV":
self.reload_sv()
elif self.textmode == "JSON":
self.reload_json()
# if we turn on reload on update we need a safety check for this
# too work.
updateNode(self, None)
def reload(self):
# reload should ONLY be called from operator on ui change
if self.textmode == 'CSV':
self.reload_csv()
elif self.textmode == 'SV':
self.reload_sv()
elif self.textmode == 'JSON':
self.reload_json()
# if we turn on reload on update we need a safety check for this to work.
updateNode(self, None)
def mode_change(self, context):
# just because click doesn't mean we need to change mode
mode = self.mode
if mode == self.current_mode:
return
self.inputs[-1].prop_name = {'LAZYRANGE': 'stop_'}.get(mode, 'count_')
self.current_mode = mode
updateNode(self, context)
def update_mode(self, context):
cls = globals()[self.mode]
while len(self.outputs) > 0:
self.outputs.remove(self.outputs[0])
for ocls, oname in cls.outputs:
self.outputs.new(ocls, oname)
if hasattr(cls, "default_submode"):
self.submode = cls.default_submode
else:
self.submode = None
updateNode(self, context)
def update_size(self, context, sizeID):
if self.syncing:
return
if self.linkSizes:
self.syncing = True
if sizeID == "X": # updating X => sync Y
self.sizey = self.sizex / self.sizeRatio
else: # updating Y => sync X
self.sizex = self.sizey * self.sizeRatio
self.syncing = False
updateNode(self, context)
def update_mode(self, context):
# hide all input sockets
for k, names in input_sockets.items():
for name in names:
self.inputs[name].hide_safe = True
# show mode specific input sockets
for name in input_sockets[self.mode]:
self.inputs[name].hide_safe = False
updateNode(self, context)
def handle_accumulative(self, context):
'''start cache'''
data = self.node_cache.get(0)
if not self.accumulative:
for i in range(len(data)):
self.accumulativity_set_data([], i)
self.accumulative_parse = False
if not data:
self.node_cache[0] = {}
updateNode(self, context)
def wrapped_update(self, context):
if self.selected_mode == 'USER':
if len(self.inputs) == 1:
self.inputs.new('StringsSocket', "Width").prop_name = 'width_custom_tex'
self.inputs.new('StringsSocket', "Height").prop_name = 'height_custom_tex'
else:
if len(self.inputs) == 3:
self.inputs.remove(self.inputs[-1])
self.inputs.remove(self.inputs[-1])
updateNode(self, context)
def adjust_inputs(self, context):
m = self.type_selected_mode
si = self.inputs
if m == 'Int' and si[2].prop_name[-1] == 'f':
si[2].prop_name = 'low_i'
si[3].prop_name = 'high_i'
elif m == 'Float' and si[2].prop_name[-1] == 'i':
si[2].prop_name = 'low_f'
si[3].prop_name = 'high_f'
updateNode(self, context)
def mode_change(self, context):
# just because click doesn't mean we need to change mode
mode = self.mode
if mode == self.current_mode:
return
if mode == 'FRANGE':
self.inputs[1].prop_name = 'stop_'
self.inputs[2].prop_name = 'step_'
elif mode == 'FRANGE_COUNT':
self.inputs[1].prop_name = 'stop_'
self.inputs[2].prop_name = 'count_'
else:
self.inputs[1].prop_name = 'step_'
self.inputs[2].prop_name = 'count_'
self.current_mode = mode
updateNode(self, context)
def change_inputs(self, context):
self.id_data.freeze(hard=True)
# inputs
nrInputs = 1
if self.items_ in self.constant:
nrInputs = 0
elif self.items_ in self.fx:
nrInputs = 1
elif self.items_ in self.fxy:
nrInputs = 2
# ugly hack to verify int property, should be improved.
if self.items_ =='ROUND-N':
if 'Y' in self.inputs:
self.inputs['Y'].prop_name = 'i_y'
self.set_inputs(nrInputs)
self.id_data.unfreeze(hard=True)
updateNode(self, context)
def mode_change(self, context):
if self.mode == 'XYZ':
while len(self.inputs) > 2:
self.inputs.remove(self.inputs[-1])
if self.mode == 'DIST':
while len(self.inputs) > 2:
self.inputs.remove(self.inputs[-1])
self.inputs.new('VerticesSocket', 'Base Point', 'Base Point')
if self.mode == 'AXIS':
while len(self.inputs) > 2:
self.inputs.remove(self.inputs[-1])
self.inputs.new('MatrixSocket', 'Mat')
if self.mode == 'USER':
while len(self.inputs) > 2:
self.inputs.remove(self.inputs[-1])
self.inputs.new('StringsSocket', 'Index Data', 'Index Data')
updateNode(self, [])
def wrapped_update(self, context):
add = self.mk_input_sockets
remove = self.rm_input_sockets
current_mode = socket_count_to_mode.get(len(self.inputs))
new_mode = fractal_type_to_mode.get(self.fractal_type)
actionables = {
'AB': (add, ('offset',)),
'BA': (remove, ('offset',)),
'BC': (add, ('gain',)),
'CB': (remove, ('gain',)),
'AC': (add, ('offset', 'gain')),
'CA': (remove, ('offset', 'gain'))
}.get(current_mode + new_mode)
if actionables:
socket_func, names = actionables
socket_func(*names)
updateNode(self, context)
def loop_forward_timer(self, context):
debug("* Timer: loop_forward_timer")
for timer in self.timers:
timer.loop_forward()
self.sync_time_slider(1)
updateNode(self, context)
def props_changed_and_update(self, context):
if self.node_id in evolver_mem:
self.info_label = "Props changed since execution"
updateNode(self, context)
def update_sockets(self, context):
if not self.inputs["Old Min"].is_linked:
self.inputs["Old Min"].hide_safe = self.auto_limits
if not self.inputs["Old Max"].is_linked:
self.inputs["Old Max"].hide_safe = self.auto_limits
updateNode(self, context)
def execute(self, context):
node = bpy.data.node_groups[self.treename].nodes[self.nodename]
idx = self.item_index
node.control_points[idx].sharp = not node.control_points[idx].sharp
updateNode(node, context)
return {'FINISHED'}
def update_ellipsoid(self, context):
if self.updating:
return
self.presets = "_"
updateNode(self, context)
def mode_change(self, context):
self.inputs[1].prop_name = self.mode
updateNode(self, context)
def toggle_state(self, context):
for switch in self.switches:
switch.toggle_state()
updateNode(self, context)
def pause_timer(self, context):
debug("* Timer: pause_timer")
for timer in self.timers:
timer.pause()
updateNode(self, context)
def reset_timer(self, context):
debug("* Timer: reset_timer")
for timer in self.timers:
timer.reset()
self.sync_time_slider(0)
updateNode(self, context)
def expire_timer(self, context):
debug("* Timer: expire_timer")
for timer in self.timers:
timer.expire()
self.sync_time_slider(1)
updateNode(self, context)
def update_socket(self, context):
updateNode(self, context)
def update_wrapper(self, context):
try:
updateNode(context.node, context)
except:
...
def execute(self, context):
node = bpy.data.node_groups[self.treename].nodes[self.nodename]
idx = self.item_index
node.remove_column(idx)
updateNode(node, context)
return {'FINISHED'}
def update_mode(self, context):
self.inputs['number'].hide_safe = self.mode == "find_range"
self.inputs['radius'].hide_safe = self.mode == "find_n"
updateNode(self, context)
def update_sockets_and_node(self, context):
self.update_sockets()
updateNode(self, context)
def stop_timer(self, context):
debug("* Timer: stop_timer")
for timer in self.timers:
timer.stop()
self.sync_time_slider(0)
updateNode(self, context)
def update_operation(self, context):
self.label = "Matrix " + self.operation.title()
self.update_sockets()
updateNode(self, context)
def start_timer(self, context):
debug("* Timer: start_timer")
for timer in self.timers:
timer.start()
updateNode(self, context)
def psuedo_update(self, context):
for idx, socket in enumerate(self.selected_mode):
self.outputs[idx].name = socket
updateNode(self, context)
def update_mode(self, context):
self.update_sockets()
updateNode(self, context)
def mode_change(self, context):
self.inputs['MaxAngle'].hide_safe = self.split_mode != 'NONPLANAR'
updateNode(self, context)
def mode_change(self, context):
if not (self.selected_axis == self.current_axis):
self.label = self.selected_axis
self.current_axis = self.selected_axis
updateNode(self, context)
def update_labels_and_update(self, context):
self.update_properties()
updateNode(self, context)
def set_sockets(self, context):
self.update_sockets()
updateNode(self, context)
def update_spiral(self, context):
if self.updating:
return
self.presets = " "
updateNode(self, context)
def update_ellipse(self, context):
if self.updating:
return
updateNode(self, context)
def change_prop(self, context):
for i, name in enumerate(self.order):
self.inputs[i].prop_name = name
updateNode(self, context)
def change_mode(self, context):
if self.unwrap:
self.level_unwrap = max(1, self.level)
else:
self.level = self.level_unwrap
updateNode(self, context)
def modifiers_handle(self, context):
set_sv_depsgraph_need(self.modifiers)
updateNode(self, context)
def execute(self, context):
node = bpy.data.node_groups[self.treename].nodes[self.nodename]
node.add_column()
updateNode(node, context)
return {'FINISHED'}
