def initialize(self, node):
global viewerState
if self.initialized:
return
viewerState = self
self.initialized = True
self.node = node
# Init state
self.state('current_point', None)
self.state('current_prim', None)
self.state('draw_backward', False)
self.state('selected_points', [])
node.setCachedUserData('tool', None)
self.state('tool', currentTool(node))
# Init Guide
# Init Line
geo = node.node('./GUIDE_LINE').geometry()
guide = hou.Drawable(self.sceneViewer, geo, 'line')
guide.enable(True)
guide.show(True)
self.guides['line'] = guide
# Init Anchor
verb = hou.sopNodeTypeCategory().nodeVerb('sphere')
geo = hou.Geometry()
verb.setParms({
'scale': 1
})
verb.execute(geo, [])
geo.addAttrib(
hou.attribType.Point, 'Cd', (1.0, 0.0, 0.0))
geo.addAttrib(hou.attribType.Point, 'Alpha', 0.5)
geo.addAttrib(hou.attribType.Global, 'gl_lit', 0)
guide = hou.Drawable(self.sceneViewer, geo, 'anchor')
guide.setDisplayMode(
hou.drawableDisplayMode.CurrentViewportMode)
guide.enable(True)
guide.show(False)
self.guides['anchor'] = guide
# Init Intersection Object
self.gi = su.GeometryIntersector(
node.node('./INTERSECTION').geometry(), scene_viewer=self.sceneViewer)
print(self.gi.snap_priorities)
self.gi.snap_priorities = (
hou.snappingPriority.GeoPoint,
)
self.gi.snap_mode = hou.snappingMode.Multi
def onGenerate(self, kwargs):
""" Assign the geometry to drawabled
"""
self.scene_viewer.setPromptMessage(State.msg)
self.current_node = hou.SceneViewer.pwd(
self.scene_viewer).displayNode()
self.geometry = hou.SopNode.geometry(self.current_node)
self.geo_intersector = su.GeometryIntersector(self.geometry,
self.scene_viewer)
self.setActive(False)
def __init__(self, kwargs):
self.objnode = stateutils.ancestorObject(kwargs['node'])
self.scene_viewer = kwargs['scene_viewer']
self.__resetSettings()
# snapping: points
tolerance = 0.03 # 1.5
test_dist = 1
# point snapping
if 'points_geo' in kwargs:
geo = kwargs['points_geo']
options = {
'snap_mode': hou.snappingMode.Point,
'snap_gravity': 50,
'snap_priorities': (hou.snappingPriority.GeoPoint, )
}
self.gi_points = su.GeometryIntersector(geo,
snap_options=options,
tolerance=tolerance,
test_dist=test_dist)
else:
self.gi_points = None
# edge snapping
if 'edge_geo' in kwargs:
geo = kwargs['edge_geo']
options = {
'snap_mode': hou.snappingMode.Multi,
'snap_gravity': 50,
'snap_priorities': (hou.snappingPriority.GeoEdge, )
}
self.gi_edge = su.GeometryIntersector(geo,
snap_options=options,
tolerance=tolerance,
test_dist=test_dist)
else:
self.gi_edge = None
# reference object
self.reference_geo = kwargs.get('reference_geo')
def intersectGeo(collisionGeo,
origin,
dir,
intersectTolerance,
doSnapping=True):
### Try intersect the collision geo from the mouse position in the viewport
gi = su.GeometryIntersector(collisionGeo, tolerance=intersectTolerance)
gi.intersect(origin, dir, snapping=doSnapping)
# print (gi.prim_num)
# print (gi.geometry)
# print (gi.position)
# print (gi.snapped_point_num)
return gi.prim_num, gi.position, gi.normal, gi.uvw
def onMouseEvent(self, kwargs):
""" Find the position of the point to add by
intersecting the construction plane.
"""
ui_event = kwargs["ui_event"]
device = ui_event.device()
origin, direction = ui_event.ray()
reason = ui_event.reason()
control = device.isCtrlKey()
gi = su.GeometryIntersector(self.collisiongeo,
scene_viewer=self.scene_viewer)
gi.intersect(origin, direction)
# Check if we didn't hit anything
if gi.prim_num >= 0:
hitposition = gi.position
numentries = self.GetNumberOfMultiparmEntries(kwargs)
print "I hit a primtive"
# if reason == hou.uiEventReason.Picked:
# print "Single Click"
# self.multiparm.set(numentries+1)
if self.placedobject == False:
self.node.parmTuple("vPosition_%s" %
numentries).set(hitposition)
# Mouse Down
if reason == hou.uiEventReason.Start:
self.placedpos = hitposition
self.hitnormal = gi.normal
self.placedobject = True
# Mouse Moving
if reason == hou.uiEventReason.Active and control != True:
if self.placedobject == True:
pos = hou.hmath.intersectPlane(self.placedpos,
self.hitnormal, origin,
direction)
scale = hitposition.distanceTo(self.placedpos)
self.node.parm('fScale_%s' % numentries).set(scale)
print hitposition.distanceTo(self.placedpos)
elif reason == hou.uiEventReason.Active and control == True:
if self.placedobject == True:
#scale = hitposition[0] - self.placedpo[0]
#scale =
pos = hou.hmath.intersectPlane(self.placedpos,
self.hitnormal, origin,
direction)
rot = hitposition.distanceTo(self.placedpos) * 2
self.node.parm('rot_%s' % numentries).set(rot)
print hitposition.distanceTo(self.placedpos)
# mouse up
if reason == hou.uiEventReason.Changed:
self.multiparm.set(numentries + 1)
self.placedobject = False
numentries = self.GetNumberOfMultiparmEntries(kwargs)
if numentries > 1:
preNumentries = numentries - 1
previousValues = self.node.parm(
"iID_{}".format(preNumentries)).eval()
self.node.parm("iID_%s" % numentries).set(
max(previousValues, 0))
return True
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()
