def createViewerStateTemplate():
    """登録するViewerステートテンプレートを作成して返すための必須のエントリーポイント。"""

    state_typename = kwargs["type"].definition().sections()["DefaultState"].contents()
    state_label = "State gadget test"
    state_cat = hou.sopNodeTypeCategory()

    template = hou.ViewerStateTemplate(state_typename, state_label, state_cat)
    template.bindFactory(State)
    template.bindIcon(kwargs["type"].icon())

    template.bindGadget( hou.drawableGeometryType.Line, "line_gadget", label="Line" )
    template.bindGadget( hou.drawableGeometryType.Face, "face_gadget", label="Face" )
    template.bindGadget( hou.drawableGeometryType.Point, "point_gadget", label="Point" )

    menu = hou.ViewerStateMenu(state_typename + "_menu", state_label)        
    menu.addActionItem("cycle", "Cycle Gadgets", hotkey=su.hotkey(state_typename, "cycle", "y"))
    template.bindMenu(menu)

    return template

class State(object):
    def __init__(self, state_name, scene_viewer):
        ...

    def onEnter(self, kwargs):
        """ノード入力ジオメトリをガジェットに割り当てます。
        """
        node = kwargs["node"]
        self.geometry = node.geometry()

        self.line_gadget = self.state_gadgets["line_gadget"]
        self.line_gadget.setGeometry(self.geometry)
        self.line_gadget.setParams({"draw_color":[.3,0,0,1], "locate_color":[1,0,0,1], "pick_color":[1,1,0,1], "line_width":2.0})
        self.line_gadget.show(True)

        self.face_gadget = self.state_gadgets["face_gadget"]
        self.face_gadget.setGeometry(self.geometry)
        self.face_gadget.setParams({"draw_color":[0,.3,0,1], "locate_color":[1,0,0,1],"pick_color":[1,1,0,1]})
        self.face_gadget.show(True)

        self.point_gadget = self.state_gadgets["point_gadget"]
        self.point_gadget.setGeometry(self.geometry)
        self.point_gadget.setParams({"draw_color":[0,0,.3,1], "locate_color":[0,0,1,1], "pick_color":[1,1,0,1], "radius":15.0})
        self.point_gadget.show(True)

    def onMouseEvent(self, kwargs):
        """カーソルのテキスト位置とDrawableジオメトリを計算します。
        """
        # set the cursor label
        self.cursor.setParams(kwargs)

        ui_event = kwargs["ui_event"]

        gadget_name = self.state_context.gadget()
        if gadget_name in ["line_gadget", "face_gadget", "point_gadget"]:
            gadget = self.state_gadgets[gadget_name]

            label = self.state_context.gadgetLabel()
            c1 = self.state_context.component1()
            c2 = self.state_context.component2()

            self.cursor.setLabel("{} : {} {}".format(label, c1, c2 if c2 > -1 else ""))
            self.cursor.show(True)

        else:
            self.cursor.show(False)

        return True        

    def onDraw( self, kwargs ):
        """このコールバックはDrawableのレンダリングに使用されます。
        """
        handle = kwargs["draw_handle"]

        c1 = self.state_context.component1()

        gadget_name = self.state_context.gadget()
        if gadget_name == "face_gadget":
            self.face_gadget.setParams({"indices":[c1]})
        else:
            self.face_gadget.setParams({"indices":[]})

        self.face_gadget.draw(handle) 
        self.line_gadget.draw(handle) 
        self.point_gadget.draw(handle) 

        self.cursor.draw(handle)

def onMouseEvent(self, kwargs):

    # カーソルのラベルを設定します。
    self.cursor.setParams(kwargs)

    ui_event = kwargs["ui_event"]

    gadget_name = self.state_context.gadget()
    if gadget_name in ["line_gadget", "face_gadget", "point_gadget"]:
        gadget = self.state_gadgets[gadget_name]
        label = self.state_context.gadgetLabel()
        c1 = self.state_context.component1()
        c2 = self.state_context.component2()

        # カーソルをアクティブなガジェットの情報で更新します。
        self.cursor.setLabel("{} : {} {}".format(label, c1, c2 if c2 > -1 else ""))
        self.cursor.show(True)

        if gadget_name == "face_gadget":

            reason = ui_event.reason()          
            if reason == hou.uiEventReason.Start:

                # ロケートしたポリゴン法線に沿ってジオメトリを移動できるようにDraggerをセットアップします。
                self.scene_viewer.beginStateUndo("Drag")

                # ラインの開始位置と方向を取得します。
                line_orig = hou.Vector3()
                normal = hou.Vector3()
                uvw = hou.Vector3()
                (rpos, rdir) = ui_event.ray()
                self.geometry.intersect(rpos, rdir, line_orig, normal, uvw)

                line_dir = self.geometry.prim(c1).normal()                    
                self.dragger.startDragAlongLine(ui_event, line_orig, line_dir)                    

                # ガイドラインを配置します。
                self.guide_line_points[0].setPosition(line_orig)
                self.guide_line_points[1].setPosition(line_orig + line_dir*0.3)

                # ... あとは矢印
                rot_mat = hou.Vector3(0, 1, 0).matrixToRotateTo(line_dir)
                self.rotate = hou.hmath.buildRotate(rot_mat.extractRotates())

                xform = self.rotate
                xform *= hou.hmath.buildTranslate(self.guide_line_points[1].position())
                self.guide_arrow.setTransform(xform)

                self.guide_line.show(True)
                self.guide_arrow.show(True)

            elif reason in [hou.uiEventReason.Active, hou.uiEventReason.Changed]:
                # 最新のDragger値を取得します。
                drag_values = self.dragger.drag(ui_event)
                delta = drag_values["delta_position"]

                # 移動パラメータを更新します。
                self.tx.set(self.tx.eval() + delta[0])
                self.ty.set(self.ty.eval() + delta[1])
                self.tz.set(self.tz.eval() + delta[2])

                # ガイドジオメトリを更新します。
                self.guide_line_points[0].setPosition(self.guide_line_points[0].position() + delta)
                self.guide_line_points[1].setPosition(self.guide_line_points[1].position() + delta)
                xform = self.rotate
                xform *= hou.hmath.buildTranslate(self.guide_line_points[1].position())
                self.guide_arrow.setTransform(xform)

                if reason == hou.uiEventReason.Changed:
                    # ドラッグを完了します。
                    self.dragger.endDrag()
                    self.guide_line.show(False)
                    self.guide_arrow.show(False)

            if reason != hou.uiEventReason.Located:
                # ガイドジオメトリのデータIDを更新します。
                self.guide_line_geo.findPointAttrib("P").incrementDataId()
                self.guide_line_geo.incrementModificationCounter()
                self.guide_arrow_geo.incrementModificationCounter()

            if reason == hou.uiEventReason.Changed:
                self.scene_viewer.endStateUndo()

    else:
        self.cursor.show(False)

    return True

# ローカルの位置とローカルの回転があったと仮定します。
local_position = ...  # type: hou.Vector3()
local_rotate = ...  # type: hou.Vector3()

# ジオメトリオブジェクトのトランスフォームを補正します。
parent = ancestorObject(kwargs["node"])
if parent:
    parent_xform = node.parent().worldTransform()
    world_pos = local_pos * parent_xform
    world_rotate = local_rotate * parent_xform.extractRotates()
    # これは、以下のように記述することもできます。
    # world_rotate = local_rotate.multiplyAsDir(parent_xform)
else:
    world_pos = local_pos
    world_rotate = local_rotate

from stateutils import ancestorObject
from stateutils import sopGeometryIntersection
from stateutils import cplaneIntersection

class CursorState(object):
    def __init__(self, state_name, scene_viewer):
        self.state_name = state_name
        self.scene_viewer = scene_viewer

        self._cursor = hou.SimpleDrawable(
            scene_viewer,
            hou.drawablePrimitive.Sphere,
            state_name + "_cursor"
        )
        self._cursor.enable(True)
        self._cursor.show(False)

    def onMouseEvent(self, kwargs):
        # 光線の原点と方向を取得する。
        ui_event = kwargs["ui_event"]
        ray_origin, ray_dir = ui_event.ray()

        # ローカル空間で交差を求めます!
        intersected = -1
        if node.inputs() and node.inputs()[0]:
            # 入力ジオメトリを取得します。
            geometry = node.inputs()[0].geometry()
            intersected, pos, _, _ = sopGeometryIntersection(geometry, origin, direction)
        if intersected < 0:
            # 入力ジオメトリもなければ、光線も当たらなかった場合は、
            # Construction Planeとの交差を試します。
            position = cplaneIntersection(self.scene_viewer, origin, direction)

        # ジオメトリコンテナを検索し... この場合だとnode.parent()で見つかることが多いですが、そのノードが1つ以上のサブネットの中にある場合の制御が必要です。
        parent = ancestorObject(kwargs["node"])
        # 見つかったコンテナのトランスフォームを使って、カーソルをワールド空間で表示します。
        parent_xform = parent.worldTransform()
        world_pos = position * parent_xform
        # ワールド空間の移動からMatrix4を構築します。
        m = hou.hmath.buildTranslate(world_pos)
        self._cursor.setTransform(m)
        self._cursor.show(True)

    def onInterrupt(self, kwargs):
        # ツールを一時停止した時にカーソルガイドを表示しないようにします。
        self._cursor.show(False)