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()