def createHeightFieldVisVerb():
volvizVerb = hou.sopNodeTypeCategory().nodeVerb("volumevisualization")
lin = hou.rampBasis.Linear
rampmaskcolor = hou.Ramp((lin,lin), (0,1),((1.0,1.0,1.0), (1.0,0.0,0.0)))
rampheightfield = hou.Ramp((lin,lin), (0,1),((1.0,1.0,1.0), (1.0,1.0,1.0)))
volvizVerb.setParms({
"vismode":0,
"densityfield":"height",
"densityramp":rampheightfield,
"cdfield":"mask",
"cdramp":rampmaskcolor
})
return volvizVerb
def SetupRampRgb(shaderNode, aishader):
blin = hou.rampBasis.Linear
bcon = hou.rampBasis.Constant
bcat = hou.rampBasis.CatmullRom
bbez = hou.rampBasis.Bezier
bbsl = hou.rampBasis.BSpline
colorArrayPtr = AiNodeGetArray(aishader.node, "color")
positionArrayPtr = AiNodeGetArray(aishader.node, "position")
if colorArrayPtr is None or positionArrayPtr is None:
return
colorArray = NullToNone(colorArrayPtr, POINTER(AtArray)).contents
positionArray = NullToNone(positionArrayPtr, POINTER(AtArray)).contents
colors = []
positions = []
for i in range(0, AiArrayGetNumElements(positionArray)):
rgb = AiArrayGetRGB(colorArray, i)
position = AiArrayGetFlt(positionArray, i)
colors.append((rgb.r, rgb.g, rgb.b))
positions.append(position)
basis = (blin,) * len(positions)
rampdata = hou.Ramp(basis, positions, colors)
parm = shaderNode.parm('ramp')
parm.set(rampdata)
def execute():
selected = hou.selectedNodes()
if len(selected) == 2:
origNode = hou.selectedNodes()[0]
destNode = hou.selectedNodes()[1]
origRamps = []
destRamps = []
origRamps = checkRamps(origNode)
destRamps = checkRamps(destNode)
origRamp = origRamps[selectRamp(origRamps)[0]]
destRamp = destRamps[selectRamp(destRamps)[0]]
ramp = origRamp.evalAsRamp()
basis = ramp.basis()
keys = ramp.keys()
values = ramp.values()
#print destRamp
if ramp.isColor() is destRamp.evalAsRamp().isColor():
destRamp.set(hou.Ramp(basis, keys, values))
else:
hou.ui.displayMessage("different type")
else:
print hou.ui.displayMessage("select 2 nodes")
def load_parameter_and_apply(self, path):
f = open(path)
jsontxt = f.read()
f.close()
items = json.loads(jsontxt)
for (k, v) in items.items():
#geo.addAttrib(hou.attribType.Global, k, v)
itemtype = v["t"]
if itemtype == "ramp_float":
self.ramp_interpolate_arr(v["v"])
param = hou.node("../").parm(k)
rampobj = hou.Ramp(v["v"], v["x"], v["y"])
if param != None:
param.set(rampobj)
elif itemtype == "float_interval":
param = hou.node("../").parm(k + "min")
if param != None:
param.set(v["v"])
param = hou.node("../").parm(k + "max")
if param != None:
param.set(v["v1"])
else:
param = hou.node("../").parm(k)
if param != None:
param.set(v["v"])
def set_ramp(self):
"""
applies the new ramp to the selected parameter.
"""
# hou.Ramp((basis, basis),(0, 1),(2.5, 4.5))
ramp = hou.Ramp((self.ramp_basis, self.ramp_basis), self.ramp_keys,
self.ramp_values)
self.ramp_parm.set(ramp)
def parm_update(node,
type,
name,
default="",
min="",
max="",
hidden="",
join="",
ramplib=""):
ptg = node.parmTemplateGroup()
parmedit = ptg.find(name)
if type == "integer":
try:
parmedit.setDefaultValue([int(default)])
parmedit.setMinValue(int(min))
parmedit.setMaxValue(int(max))
except:
pass
if type == "toggle":
try:
parmedit.setDefaultValue(int(default))
except:
pass
if type == "float":
try:
parmedit.setDefaultValue([float(default)])
parmedit.setMinValue(float(min))
parmedit.setMaxValue(float(max))
except:
pass
if type == "string":
try:
parmedit.setDefaultValue([default])
except:
pass
if hidden: parmedit.hide(True)
if join: parmedit.setJoinWithNext(True)
if ramplib:
ramp_preset, ramp_basis, ramp_keys, ramp_values = wf_network_ui_ramp_lib.ramp_lib(
)
try:
i = ramp_preset.index(ramplib)
newRamp = hou.Ramp(ramp_basis[i], ramp_keys[i], ramp_values[i])
node.setParms({name: newRamp})
except:
# comment is "color" or "glob" or anything else
pass
ptg.replace(name, parmedit)
node.setParmTemplateGroup(ptg)
def setup_parametric_ramp(node, ramp_parm, parametric_ramp_type):
# type: (hou.Node, hou.Parm, str) -> None
if parametric_ramp_type not in parametric_ramps:
return
ramp_name = ramp_parm.name()
clean_parametric_spare_parms(node, ramp_parm)
parametric_ramp = parametric_ramps[parametric_ramp_type]
spare_parms = parametric_ramp.spare_parms
name_prefix = name_prefix_format.format(ramp_name)
callback = "node = kwargs['node']\n"
callback += "ramp_name = '{}'\n".format(ramp_name)
callback += """
ramp = node.parm(ramp_name)
if not (ramp is None or ramp.evalAsInt() < {}):
""".format(parametric_ramp.num_keys)
for parm in spare_parms: # type: ParametricSpareParm
callback += "\t{} = node.parm('{}').eval()\n".format(parm.name, name_prefix + parm.name)
callback += parametric_ramp.callback
ptg = node.parmTemplateGroup() # type: hou.ParmTemplateGroup
insert_parm = get_multiparm_top_parent(ramp_parm)
insert_parm_template = ptg.find(insert_parm.name())
ramp = hou.Ramp(
(hou.rampBasis.Bezier,) * parametric_ramp.num_keys,
np.linspace(0.0, 1.0, parametric_ramp.num_keys),
np.linspace(0.0, 1.0, parametric_ramp.num_keys)
)
ramp_parm.set(ramp)
for parm in spare_parms: # type: ParametricSpareParm
parm_template = hou.FloatParmTemplate(
name_prefix + parm.name,
label_format.format(ramp_parm.description(), parm.label),
1,
(parm.default_value,),
min=0.0, max=1.0,
script_callback=callback,
script_callback_language=hou.scriptLanguage.Python
)
ptg.insertAfter(insert_parm_template, parm_template)
node.setParmTemplateGroup(ptg)
node.parm(name_prefix + spare_parms[0].name).pressButton()
def copyFloatRampToColorRamp(r, cd):
ramp = r.evalAsRamp()
basis = ramp.basis()
keys = ramp.keys()
values = ramp.values()
cdValues = []
for val in values:
cdValues += [[val, val, val]]
cdRamp = hou.Ramp(basis, keys, cdValues)
cd.set(cdRamp)
def set_ramp_basis(kwargs, ramp_basis):
"""Set all knots on a ramp to the specified type.
(Called from PARMmenu.xml)
"""
try:
p = kwargs['parms'][0]
v = p.eval()
num_keys = len(v.basis())
new_basis = (ramp_basis, ) * num_keys
new_ramp = hou.Ramp(new_basis, v.keys(), v.values())
p.set(new_ramp)
except:
hou.ui.setStatusMessage("couldn't set ramp interpolation type on %s" % p.path(),
severity=hou.severityType.Error)
def invert_parm(n, parmname):
parm = hou.parm('{}/{}'.format(n.path(), parmname))
ramp = parm.evalAsRamp()
ramp_isColor = ramp.isColor()
ramp_keys = ramp.keys()
ramp_vals = ramp.values()
ramp_basis = ramp.basis()
ramp_keysl = list(reversed(list(ramp_keys)))
invert_keys = []
for ramp_key in ramp_keysl:
invert_keys.append(1 - float(ramp_key))
invert_vals = list(reversed(list(ramp_vals)))
invert_basis = list(reversed(list(ramp_basis)))
ramp_parms = hou.Ramp(tuple(invert_basis), tuple(invert_keys),
tuple(invert_vals))
parm.set(ramp_parms)
def set_ramp(node, event_type, **kwargs):
"""Set the ramp when a certain parameter changes.
:param node: This node
:type node: :class:`hou.Node`
:param event_type: Houdini Node Event
:type event_type: :class:`hou.nodeEventType`
:param kwargs: Any extra keyword arugments passed by the event
:type kwargs: dict
"""
if not event_type == hou.nodeEventType.ParmTupleChanged:
return
parm_changed = kwargs.get("parm_tuple")
if not parm_changed:
return
if parm_changed.name() not in callback_parm_names(node):
return
ramp_parm = node.parm("ramp")
stops = node.evalParm("stops")
interpolation = hou.rampBasis.Linear
try:
colors = node.node(
"RGB_COLORS"
).geometry().floatListAttribValue("colors")
except AttributeError:
return
except hou.OperationFailed:
return
colors = [colors[i:i + 3] for i in range(0, len(colors), 3)]
keys = [x * (1.0 / (stops - 1)) for x in range(stops)]
basis = (interpolation, interpolation)
ramp = hou.Ramp(basis, keys, colors)
ramp_parm.set(ramp)
def prepare_curve(self, curve):
#todo we can remove the constants to add 1 and subtract 1
"""
for a given curve will add extra nodes to use stretch and squash an attribute
@param curve: the curve that will add the nodes
@return:
"""
for i in curve.children():
if i.isRenderFlagSet() is True:
null_out = i
resample = curve.createNode("resample")
resample.parm("last").set(1)
resample.parm("length").set(0)
resample.parm("dosegs").set(1)
resample.parm("segs").set(15)
resample.parm("dolength").set(0)
# try:
# utils.promote_parm_to_ui(resample.parm("segs"), curve, insert_after_parm="wire_rad")
# except:
# utils.promote_parm_to_ui(resample.parm("segs"), curve, insert_before_parm="stdswitcher5")
resample.setInput(0, null_out)
time_shift = curve.createNode("timeshift", "timeshift_rest")
time_shift.parm("frame").setExpression("$FSTART")
time_shift.setInput(0, resample)
vopsop = curve.createNode("vopsop", "vopsop_streatch_and_squash")
vopsop.setInput(0, resample)
vopsop.setInput(1, time_shift)
globals = vopsop.node("global1")
itf = vopsop.createNode("inttofloat")
itf.setInput(0, globals, 8)
div = vopsop.createNode("divide")
div.setInput(0, itf, 0)
div.setInput(1, globals, 11)
#-----------------------------
ramp_stre = vopsop.createNode("rampparm", "ramp_stretch")
ramp_stre.parm("parmname").set("stretch_ramp")
ramp_stre.parm("parmlabel").set("Stretch Ramp")
ramp_stre.parm("rampshowcontrolsdefault").set(0)
ramp_stre.parm("ramptype").set(1)
ramp_stre.parm("rampbasisdefault").set("catmull-rom")
basis = hou.rampBasis.CatmullRom
ramp_default = hou.Ramp((basis, basis, basis), (0, 0.5, 1), (0, 1, 0))
vopsop.parm("stretch_ramp").set(ramp_default)
ramp_stre.setInput(0, div, 0)
stre_mult_parm = vopsop.createNode("parameter")
stre_mult_parm.parm("parmname").set("stretch_ramp_mult")
stre_mult_parm.parm("parmlabel").set("Stretch Ramp Mult")
stre_mult_parm.parm("floatdef").set(1)
stre_mult_parm.parmTuple("rangeflt").set([0, 10])
stre_mult_parm.parm("joinnext").set(1)
stre_mult = vopsop.createNode("multiply")
stre_mult.setInput(0, ramp_stre)
stre_mult.setInput(1, stre_mult_parm)
stre_clamp_parm = vopsop.createNode("parameter")
stre_clamp_parm.parm("parmname").set("stretch_cap")
stre_clamp_parm.parm("parmlabel").set("Stretch Cap")
stre_clamp_parm.parm("floatdef").set(20)
stre_clamp_parm.parmTuple("rangeflt").set([0, 20])
stre_clamp = vopsop.createNode("clamp", "clamp_cap_ramp")
stre_clamp.setInput(0, stre_mult, 0)
stre_clamp.setInput(2, stre_clamp_parm, 0)
#-------------------------------------
ramp_squa = vopsop.createNode("rampparm", "ramp_squash")
ramp_squa.parm("parmname").set("squash_ramp")
ramp_squa.parm("parmlabel").set("Squash Ramp")
ramp_squa.parm("rampshowcontrolsdefault").set(0)
ramp_squa.parm("ramptype").set(1)
ramp_squa.parm("ramptype").set(1)
ramp_squa.parm("rampbasisdefault").set("catmull-rom")
vopsop.parm("squash_ramp").set(ramp_default)
ramp_squa.setInput(0, div, 0)
squa_mult_parm = vopsop.createNode("parameter")
squa_mult_parm.parm("parmname").set("squash_ramp_mult")
squa_mult_parm.parm("parmlabel").set("Squash Ramp Mult")
squa_mult_parm.parm("floatdef").set(1)
squa_mult_parm.parm("floatdef").set(1)
squa_mult_parm.parmTuple("rangeflt").set([0, 10])
squa_mult_parm.parm("joinnext").set(1)
squa_mult = vopsop.createNode("multiply")
squa_mult.setInput(0, ramp_squa)
squa_mult.setInput(1, squa_mult_parm)
squa_clamp_parm = vopsop.createNode("parameter")
squa_clamp_parm.parm("parmname").set("squash_cap")
squa_clamp_parm.parm("parmlabel").set("Squash Cap")
squa_clamp_parm.parm("floatdef").set(2)
squa_clamp_parm.parmTuple("rangeflt").set([0, 20])
squa_clamp = vopsop.createNode("clamp", "clamp_cap_ramp")
squa_clamp.setInput(0, squa_mult, 0)
squa_clamp.setInput(2, squa_clamp_parm, 0)
#---------------------------------------
ori_len_parm = vopsop.createNode("parameter")
ori_len_parm.parm("parmname").set("original_curve_len")
ori_len_parm.parm("parmlabel").set("Original Curve Length")
ori_len_parm.parm("floatdef").set(0)
ori_len_parm.parm("joinnext").set(1)
vopsop.parm("original_curve_len").setExpression(
'arclen(opinputpath(".",1),0,0,1)')
current_len_parm = vopsop.createNode("parameter")
current_len_parm.parm("parmname").set("current_curve_len")
current_len_parm.parm("parmlabel").set("Current Curve Length")
current_len_parm.parm("floatdef").set(0)
vopsop.parm("current_curve_len").setExpression(
'arclen(opinputpath(".",0),0,0,1)')
divi_len = vopsop.createNode("divide")
divi_len.setInput(0, ori_len_parm, 0)
divi_len.setInput(1, current_len_parm, 0)
cons = vopsop.createNode("addconst")
cons.parm("addconst").set(-1)
cons.setInput(0, divi_len, 0)
compare = vopsop.createNode("compare")
compare.setInput(0, ori_len_parm)
compare.setInput(1, current_len_parm)
compare.parm("cmp").set("gt")
two_ways = vopsop.createNode("twoway")
two_ways.parm("condtype").set(0)
two_ways.setInput(0, compare, 0)
two_ways.setInput(1, squa_clamp, 0)
two_ways.setInput(2, stre_clamp, 0)
mult_cons_two = vopsop.createNode("multiply")
mult_cons_two.setInput(0, cons, 0)
mult_cons_two.setInput(1, two_ways, 0)
cons_one = vopsop.createNode("addconst")
cons_one.parm("addconst").set(1)
cons_one.setInput(0, mult_cons_two, 0)
bind_export = vopsop.createNode("bind")
bind_export.parm("parmname").set("bscale")
bind_export.parm("useasparmdefiner").set(1)
bind_export.parm("exportparm").set(2)
bind_export.setInput(0, cons_one)
vopsop.layoutChildren()
#after we get the original length of the curve delete the connection so we dont depend on the timeshift.
vopsop.parm("original_curve_len").deleteAllKeyframes()
#-----------------------------------------
pw = curve.createNode("pointwrangle",
"pointwrangle_make_local_variable")
pw.parm("snippet").set(
"f@bscale = @bscale; addvariablename('bscale', 'BSCALE');")
pw.setInput(0, vopsop)
carve_node = curve.createNode("carve")
carve_node.setInput(0, pw)
carve_node.parm("firstu").set(0)
carve_node.parm("secondu").set(1)
carve_node.parm("domainu2").set(1)
carve_node.bypass(1)
null_out = curve.createNode("null", "OUT")
null_out.setInput(0, carve_node)
null_out.setDisplayFlag(1)
null_out.setRenderFlag(1)
curve.layoutChildren()
return curve
def write_color_ramp(self):
if len(self.colors) < 2:
return
color_points = []
vlast_color = hou.Vector3(hou.qt.fromQColor(self.colors[0])[0].rgb())
last_color_index = 0
color_points.append((vlast_color, 0))
# remove same keys in a row
for index, color in enumerate(self.colors[1:]):
color_index = index + 1
vcolor = hou.Vector3(hou.qt.fromQColor(color)[0].rgb())
dist = vcolor.distanceTo(vlast_color)
if dist > TOLERANCE:
# if color_index - last_color_index > 1 and dist > SHARP_PRECISION:
# color_points.append((hou.Vector3(vlast_color), color_index - 1))
color_points.append((hou.Vector3(vcolor), color_index))
vlast_color = vcolor
last_color_index = color_index
if color_points[-1][1] < (len(self.colors) - 1):
color_points.append(
(hou.Vector3(hou.qt.fromQColor(self.colors[-1])[0].rgb()),
len(self.colors) - 1))
# Create a polyline representing ramp and remove inline points with Facet SOP
points = [color_point[0] for color_point in color_points]
pos = [color_point[1] for color_point in color_points]
ramp_geo = hou.Geometry()
pos_attrib = ramp_geo.addAttrib(hou.attribType.Point,
"ramp_pos",
0.0,
create_local_variable=False)
ramp_points = ramp_geo.createPoints(points)
fnum_points = float(len(self.colors) - 1)
for ptnum, point in enumerate(ramp_points): # type: (int, hou.Point)
point.setAttribValue(pos_attrib, float(pos[ptnum]) / fnum_points)
ramp_poly = ramp_geo.createPolygons((ramp_points, ),
False)[0] # type: hou.Face
facet_verb = hou.sopNodeTypeCategory().nodeVerb(
"facet") # type: hou.SopVerb
facet_verb.setParms({"inline": 1, "inlinedist": 0.02})
facet_verb.execute(ramp_geo, [ramp_geo])
ramp_poly = ramp_geo.prim(0)
ramp_points = ramp_poly.points()
linear = hou.rampBasis.Linear
basis = []
keys = []
values = []
pos_attrib = ramp_geo.findPointAttrib("ramp_pos")
for point in ramp_points: # type: hou.Point
basis.append(linear)
keys.append(point.attribValue(pos_attrib))
values.append(tuple(point.position()))
if not self.disable_gamma_correction:
values = [np.power(v, 2.2) for v in values]
ramp = hou.Ramp(basis, keys, values)
self.parm.set(ramp)
self.parm.pressButton()
def write_ramp_sketch(self):
if len(self.positions) < 2:
return
positions = np.array([(float(p.x()), float(-p.y()))
for p in self.positions])
min_point = positions.min(axis=0)
max_point = positions.max(axis=0)
ramp_range = max_point - min_point
if not np.any((ramp_range == 0.0)):
norm_positions = (positions - min_point) / ramp_range
geo_points = []
geo_points.append(
hou.Vector3(norm_positions[0][0], norm_positions[0][1], 0.0))
left = 0.0
for pt in norm_positions[1:-1]:
if pt[0] >= left:
left = pt[0]
geo_points.append(hou.Vector3(pt[0], pt[1], 0.0))
geo_points.append(
hou.Vector3(norm_positions[-1][0], norm_positions[-1][1], 0.0))
ramp_geo = hou.Geometry() # type: hou.Geometry
ramp_points = ramp_geo.createPoints(geo_points)
ramp_geo.createPolygons((ramp_points, ), False)
resample_verb = hou.sopNodeTypeCategory().nodeVerb(
"resample") # type: hou.SopVerb
resample_verb.setParms({"length": 0.04})
resample_verb.execute(ramp_geo, [ramp_geo])
facet_verb = hou.sopNodeTypeCategory().nodeVerb(
"facet") # type: hou.SopVerb
facet_verb.setParms({"inline": 1, "inlinedist": 0.003})
facet_verb.execute(ramp_geo, [ramp_geo])
ramp_poly = ramp_geo.prim(0)
ramp_points = ramp_poly.points()
ramp_basis = hou.rampBasis.BSpline if self.disable_gamma_correction else hou.rampBasis.Linear
basis = []
keys = []
values = []
for point in ramp_points: # type: hou.Point
basis.append(ramp_basis)
pos = point.position()
keys.append(pos.x())
values.append(pos.y())
ramp = hou.Ramp(basis, keys, values)
self.parm.set(ramp)
self.parm.pressButton()
def test_ramp(self):
ramp = hou.Ramp([hou.rampBasis.Linear] * 3, (0.0, 0.5, 1.0), (0.25, 1.0, 0.5))
self.spectrum.parm("ramp").set(ramp)
self.spectrum.parm("type").set("ramp")
self.compare_scene()
def onMouseEvent(self, kwargs):
""" Demonstrates how to access the active gadget info from the
gadget context.
"""
hcontext = self.state_context
hparms = kwargs["state_parms"]
ui_event = kwargs["ui_event"]
reason = ui_event.reason()
device = ui_event.device()
origin, direction = ui_event.ray()
#_geo_intersect = self.node.node('CURVE_GEO').geometry()
gadget_name = self.state_context.gadget()
# Pick line to display gadgets
if self.geometry:
gi = su.GeometryIntersector(self.geometry,
scene_viewer=self.scene_viewer,
tolerance=0.05)
gi.intersect(origin, direction)
hit = gi.prim_num
position = gi.position
norm = gi.normal
uvw = gi.uvw
#hit, position, norm, uvw = su.sopGeometryIntersection(self.geometry, origin, direction)
if reason == hou.uiEventReason.Start:
self.scene_viewer.beginStateUndo("Edit Ramp")
if hit != -1 and gadget_name == "line_gadget":
#self.log(reason)
if reason == hou.uiEventReason.Start or reason == hou.uiEventReason.Picked:
self.prim = self.geometry.prim(hit)
self.createLineGadget()
self.createPoints()
self.createCircles()
if self.id != -1:
self.createCircle(self.id)
self.createVisPoint(self.id)
self.show(True)
# Show ramp key values at cursor
if gadget_name == "point_gadget":
c1 = self.state_context.component1()
#if c1 == self.id:
self.cursor.setParams(kwargs)
u_label = self.node.parm('{}{}pos'.format(
self.ramp_name, c1 + 1)).eval()
self.cursor.setLabel('Position: {}'.format(round(u_label, 3)))
self.cursor.show(True)
elif self.id > -1:
if gadget_name == "point_gadget":
c1 = self.state_context.component1()
if c1 == self.id:
self.cursor.setParams(kwargs)
u_label = self.node.parm('{}{}pos'.format(
self.ramp_name, self.id + 1)).eval()
self.cursor.setLabel('Position: {}'.format(
round(u_label, 3)))
self.cursor.show(True)
elif gadget_name == "circle_gadget":
self.cursor.setParams(kwargs)
val_label = self.node.parm('{}{}value'.format(
self.ramp_name, self.id + 1)).eval()
ramp_min = self.node.parm('ramp_min').eval()
ramp_max = self.node.parm('ramp_max').eval()
val_label_remap = (
(val_label - 0) /
(1 - 0)) * (ramp_max - ramp_min) + ramp_min
self.cursor.setLabel('Value: {} Remapped: {}'.format(
round(val_label, 3), round(val_label_remap, 3)))
self.cursor.show(True)
else:
self.cursor.show(False)
else:
self.cursor.show(False)
# Create circle handle at selected point
if gadget_name == "point_gadget":
if not device.isCtrlKey():
if reason == hou.uiEventReason.Start or reason == hou.uiEventReason.Picked:
self.id = self.state_context.component1()
if self.id != self.prev_id:
self.createCircle(self.id)
self.createVisPoint(self.id)
self.circle_gadget.show(True)
self.point_vis.show(True)
self.circle_gadget_vis = True
self.prev_id = self.id
#elif self.id == self.prev_id:
#self.circle_gadget.show(False)
#self.point_vis.show(False)
#self.circle_gadget_vis = False
#self.prev_id = -1
#if self.geometry:
#hit, position, norm, uvw = su.sopGeometryIntersection(self.geometry, origin, direction)
if hit != -1:
# Add points to ramp
if device.isShiftKey():
if reason == hou.uiEventReason.Start or reason == hou.uiEventReason.Picked:
#self.scene_viewer.beginStateUndo("Add Point")
u = uvw[0]
val = self.prim.attribValueAt("attrib", u)
ramp_val = self.ramp_parm.eval()
bases = list(ramp_val.basis())
keys = list(ramp_val.keys()) + [u]
values = list(ramp_val.values()) + [val]
ramp_new = hou.Ramp(bases, keys, values)
self.ramp_parm.set(ramp_new)
ramp_val = self.ramp_parm.eval()
keys = list(ramp_val.keys())
keys.sort()
index = keys.index(u)
self.id = index
self.createPoints()
self.createCircles()
#self.id = self.state_context.component1()
self.createCircle(self.id)
self.createVisPoint(self.id)
self.circle_gadget.show(True)
self.point_vis.show(True)
self.circle_gadget_vis = True
self.prev_id = self.id
#if reason == hou.uiEventReason.Changed:
#self.scene_viewer.endStateUndo()
# Remove points from ramp
if gadget_name == "point_gadget":
if device.isCtrlKey():
if reason == hou.uiEventReason.Start or reason == hou.uiEventReason.Picked:
#self.scene_viewer.beginStateUndo("Delete Point")
self.id = self.state_context.component1()
u = self.node.parm('{}{}pos'.format(
self.ramp_name, self.id + 1)).eval()
ramp_val = self.ramp_parm.eval()
keys = list(ramp_val.keys())
index = keys.index(u)
bases = list(ramp_val.basis())
bases.pop(index)
keys.pop(index)
values = list(ramp_val.values())
values.pop(index)
ramp_new = hou.Ramp(bases, keys, values)
self.ramp_parm.set(ramp_new)
self.createPoints()
self.createCircles()
if self.id == self.prev_id and len(keys) >= 2:
if self.id == len(keys):
self.id = self.id - 1
self.createCircle(self.id)
self.createVisPoint(self.id)
self.circle_gadget.show(True)
self.point_vis.show(True)
self.circle_gadget_vis = True
self.prev_id = self.id
elif len(keys) >= 2:
self.id = self.id - 1
else:
self.id = 0
# Move points along line
if gadget_name == "point_gadget":
#if self.geometry:
#hit, position, norm, uvw = su.sopGeometryIntersection(self.geometry, origin, direction)
if hit != -1:
if reason == hou.uiEventReason.Start:
#self.scene_viewer.beginStateUndo("Move Point")
self.id = self.state_context.component1()
#if reason == hou.uiEventReason.Changed:
#self.scene_viewer.endStateUndo()
if reason == hou.uiEventReason.Active:
u = uvw[0]
#u = _geo_intersect.iterPrims()[hit].floatAttribValue("gradient")
self.node.parm('{}{}pos'.format(
self.ramp_name, self.id + 1)).set(u)
self.createPoints()
self.createCircles()
self.createCircle(self.id)
self.createVisPoint(self.id)
self.circle_gadget.show(True)
self.point_vis.show(True)
self.circle_gadget_vis = True
self.prev_id = self.id
# Scale circle handle
if gadget_name == "circle_gadget":
if reason == hou.uiEventReason.Start:
#self.scene_viewer.beginStateUndo("Change Value")
hit, position, norm, uvw = su.sopGeometryIntersection(
self.circle_handle, origin, direction)
u = self.node.parm('{}{}pos'.format(
self.ramp_name, self.id + 1)).eval()
self.center = self.prim.positionAt(u)
self.handle_dragger.startDrag(ui_event, self.center)
elif reason == hou.uiEventReason.Active:
if self.handle_dragger.valid() == True:
drag_values = self.handle_dragger.drag(ui_event)
pos = drag_values["position"]
pos_screen = self.viewport.mapToScreen(pos)
dist = math.sqrt((pos[0] - self.center[0])**2 +
(pos[1] - self.center[1])**2 +
(pos[2] - self.center[2])**2)
scale = self.node.parm('{}{}value'.format(
self.ramp_name, self.id + 1)).eval()
#dist = dist - scale
u = self.node.parm('{}{}pos'.format(
self.ramp_name, self.id + 1)).eval()
#val_prev = self.node.parm('{}{}value'.format(self.ramp_name, self.id+1)).eval()
if self.node.parm('scale_clamp').eval() == 1:
dist = self.clamp(dist, 0, 1)
self.node.parm('{}{}value'.format(
self.ramp_name, self.id + 1)).set(dist)
self.createCircle(self.id)
self.createCircles()
self.show(True)
if reason == hou.uiEventReason.Changed:
self.scene_viewer.endStateUndo()
