swissArmyManip.py

#-
# ==========================================================================
# Copyright (C) 1995 - 2006 Autodesk, Inc. and/or its licensors.  All 
# rights reserved.
#
# The coded instructions, statements, computer programs, and/or related 
# material (collectively the "Data") in these files contain unpublished 
# information proprietary to Autodesk, Inc. ("Autodesk") and/or its 
# licensors, which is protected by U.S. and Canadian federal copyright 
# law and by international treaties.
#
# The Data is provided for use exclusively by You. You have the right 
# to use, modify, and incorporate this Data into other products for 
# purposes authorized by the Autodesk software license agreement, 
# without fee.
#
# The copyright notices in the Software and this entire statement, 
# including the above license grant, this restriction and the 
# following disclaimer, must be included in all copies of the 
# Software, in whole or in part, and all derivative works of 
# the Software, unless such copies or derivative works are solely 
# in the form of machine-executable object code generated by a 
# source language processor.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND. 
# AUTODESK DOES NOT MAKE AND HEREBY DISCLAIMS ANY EXPRESS OR IMPLIED 
# WARRANTIES INCLUDING, BUT NOT LIMITED TO, THE WARRANTIES OF 
# NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR 
# PURPOSE, OR ARISING FROM A COURSE OF DEALING, USAGE, OR 
# TRADE PRACTICE. IN NO EVENT WILL AUTODESK AND/OR ITS LICENSORS 
# BE LIABLE FOR ANY LOST REVENUES, DATA, OR PROFITS, OR SPECIAL, 
# DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES, EVEN IF AUTODESK 
# AND/OR ITS LICENSORS HAS BEEN ADVISED OF THE POSSIBILITY 
# OR PROBABILITY OF SUCH DAMAGES.
#
# ==========================================================================
#+

#
# Autodesk Script File
# MODIFY THIS AT YOUR OWN RISK
#
# Creation Date:   27 September 2006
#
# swissArmyManip.py
# 
# This plug-in is an example of a user-defined manipulator,
# which is comprised of a variety of the base manipulators:
# - MFnCircleSweepManip
# - MFnDirectionManip
# - MFnDiscManip
# - MFnDistanceManip
# - MFnFreePointTriadManip
# - MFnStateManip
# - MFnToggleManip
# - MFnRotateManip
# - MFnScaleManip
#
# To use this plug-in:
# 
#       import maya.cmds as cmds
#       cmds.createNode("spSwissArmyLocator")
#
#   click on the showManipTool
# 

import maya.OpenMaya as OpenMaya
import maya.OpenMayaUI as OpenMayaUI
import maya.OpenMayaRender as OpenMayaRender
import maya.OpenMayaMPx as OpenMayaMPx

import math,sys

glRenderer = OpenMayaRender.MHardwareRenderer.theRenderer()
glFT = glRenderer.glFunctionTable()

kSwissArmyLocatorName = "spSwissArmyLocator"
kSwissArmyLocatorId = OpenMaya.MTypeId(0x87006)
kSwissArmyLocatorManipName = "spSwissArmyLocatorManip"
kSwissArmyLocatorManipId = OpenMaya.MTypeId(0x87007)

delta1 = 0.01
delta2 = 0.02
delta3 = 0.03
delta4 = 0.04

# Locator Data
centre = [      [  0.10, 0.0,  0.10 ],
                        [  0.10, 0.0, -0.10 ],
                        [ -0.10, 0.0, -0.10 ],
                        [ -0.10, 0.0,  0.10 ], 
                        [  0.10, 0.0,  0.10 ] ] 
state1 = [      [  1.00, 0.0,  1.00 ],
                        [  1.00, 0.0,  0.50 ],
                        [  0.50, 0.0,  0.50 ],
                        [  0.50, 0.0,  1.00 ], 
                        [  1.00, 0.0,  1.00 ] ] 
state2 = [      [  1.00, 0.0, -1.00 ],
                        [  1.00, 0.0, -0.50 ],
                        [  0.50, 0.0, -0.50 ],
                        [  0.50, 0.0, -1.00 ], 
                        [  1.00, 0.0, -1.00 ] ] 
state3 = [      [ -1.00, 0.0, -1.00 ],
                        [ -1.00, 0.0, -0.50 ],
                        [ -0.50, 0.0, -0.50 ],
                        [ -0.50, 0.0, -1.00 ], 
                        [ -1.00, 0.0, -1.00 ] ] 
state4 = [      [ -1.00, 0.0,  1.00 ],
                        [ -1.00, 0.0,  0.50 ],
                        [ -0.50, 0.0,  0.50 ],
                        [ -0.50, 0.0,  1.00 ], 
                        [ -1.00, 0.0,  1.00 ] ] 
arrow1 = [      [  0.00, 0.0,  1.00 ],
                        [  0.10, 0.0,  0.20 ],
                        [ -0.10, 0.0,  0.20 ],
                        [  0.00, 0.0,  1.00 ] ] 
arrow2 = [      [  1.00, 0.0,  0.00 ],
                        [  0.20, 0.0,  0.10 ],
                        [  0.20, 0.0, -0.10 ],
                        [  1.00, 0.0,  0.00 ] ] 
arrow3 = [      [  0.00, 0.0, -1.00 ],
                        [  0.10, 0.0, -0.20 ],
                        [ -0.10, 0.0, -0.20 ],
                        [  0.00, 0.0, -1.00 ] ] 
arrow4 = [      [ -1.00, 0.0,  0.00 ],
                        [ -0.20, 0.0,  0.10 ],
                        [ -0.20, 0.0, -0.10 ],
                        [ -1.00, 0.0,  0.00 ] ] 
perimeter=[     [  1.10, 0.0,  1.10 ],
                        [  1.10, 0.0, -1.10 ],
                        [ -1.10, 0.0, -1.10 ],
                        [ -1.10, 0.0,  1.10 ], 
                        [  1.10, 0.0,  1.10 ] ] 

kCentreCount = 5
kState1Count = 5
kState2Count = 5
kState3Count = 5
kState4Count = 5
kArrow1Count = 4
kArrow2Count = 4
kArrow3Count = 4
kArrow4Count = 4
kPerimeterCount = 5


########################################################################
########################################################################


class swissArmyLocatorManip(OpenMayaMPx.MPxManipContainer):
        def __init__(self):
                OpenMayaMPx.MPxManipContainer.__init__(self)

                
                self.fCircleSweepManip = OpenMaya.MDagPath()
                self.fDirectionManip = OpenMaya.MDagPath()
                self.fDiscManip = OpenMaya.MDagPath()
                self.fDistanceManip = OpenMaya.MDagPath()
                self.fFreePointTriadManip = OpenMaya.MDagPath()
                self.fStateManip = OpenMaya.MDagPath()
                self.fToggleManip = OpenMaya.MDagPath()
                self.fRotateManip = OpenMaya.MDagPath()
                self.fScaleManip = OpenMaya.MDagPath()
                self.fNodePath = OpenMaya.MDagPath()


        def createChildren(self):
                # FreePointTriadManip
                self.fFreePointTriadManip = self.addFreePointTriadManip("freePointTriadManip", "point")
                freePointTriadManipFn = OpenMayaUI.MFnFreePointTriadManip(self.fFreePointTriadManip)

                # DirectionManip
                self.fDirectionManip = self.addDirectionManip("directionManip", "direction")
                directionManipFn = OpenMayaUI.MFnDirectionManip(self.fDirectionManip)

                # ToggleManip
                self.fToggleManip = self.addToggleManip("toggleManip", "toggle")
                toggleManipFn = OpenMayaUI.MFnToggleManip(self.fToggleManip)

                # StateManip
                self.fStateManip = self.addStateManip("stateManip", "state")
                stateManipFn = OpenMayaUI.MFnStateManip(self.fStateManip)

                # DiscManip
                self.fDiscManip = self.addDiscManip("discManip", "angle")
                discManipFn = OpenMayaUI.MFnDiscManip(self.fDiscManip)

                # CircleSweepManip
                self.fCircleSweepManip = self.addCircleSweepManip("circleSweepManip", "angle")
                circleSweepManipFn = OpenMayaUI.MFnCircleSweepManip(self.fCircleSweepManip)
                circleSweepManipFn.setCenterPoint(OpenMaya.MPoint(0, 0, 0))
                circleSweepManipFn.setNormal(OpenMaya.MVector(0, 1, 0))
                circleSweepManipFn.setRadius(2.0)
                circleSweepManipFn.setDrawAsArc(True)

                # DistanceManip
                self.fDistanceManip = self.addDistanceManip("distanceManip", "distance")
                distanceManipFn = OpenMayaUI.MFnDistanceManip(self.fDistanceManip)
                distanceManipFn.setStartPoint(OpenMaya.MPoint(0, 0, 0))
                distanceManipFn.setDirection(OpenMaya.MVector(0, 1, 0))

                # RotateManip
                self.fRotateManip = self.addRotateManip("RotateManip", "rotation")
                rotateManipFn = OpenMayaUI.MFnRotateManip(self.fRotateManip)

                # ScaleManip
                self.fScaleManip = self.addScaleManip("scaleManip", "scale")
                scaleManipFn = OpenMayaUI.MFnScaleManip(self.fScaleManip)


        def connectToDependNode(self, node):
                # Get the DAG path
                dagNodeFn = OpenMaya.MFnDagNode(node)
                dagNodeFn.getPath(self.fNodePath)
                parentNode = dagNodeFn.parent(0)
                parentNodeFn = OpenMaya.MFnDagNode(parentNode)

                # Connect the plugs
                nodeFn = OpenMaya.MFnDependencyNode()
                nodeFn.setObject(node)   

                # FreePointTriadManip
                freePointTriadManipFn = OpenMayaUI.MFnFreePointTriadManip(self.fFreePointTriadManip)
                try:
                        translationPlug = parentNodeFn.findPlug("t")
                        freePointTriadManipFn.connectToPointPlug(translationPlug)
                except:
                        pass

                # DirectionManip
                directionManipFn = OpenMayaUI.MFnDirectionManip()
                directionManipFn.setObject(self.fDirectionManip)
                try:
                        directionPlug = nodeFn.findPlug("arrow2Direction")
                        directionManipFn.connectToDirectionPlug(directionPlug)
                        startPointIndex = directionManipFn.startPointIndex()
                        self.addPlugToManipConversion(startPointIndex)
                except:
                        pass

                # DistanceManip
                distanceManipFn = OpenMayaUI.MFnDistanceManip()
                distanceManipFn.setObject(self.fDistanceManip)
                try:
                        sizePlug = nodeFn.findPlug("size")
                        distanceManipFn.connectToDistancePlug(sizePlug)
                        startPointIndex = distanceManipFn.startPointIndex()
                        self.addPlugToManipConversion(startPointIndex)
                except:
                        pass

                # CircleSweepManip
                circleSweepManipFn = OpenMayaUI.MFnCircleSweepManip(self.fCircleSweepManip)
                try:
                        arrow1AnglePlug = nodeFn.findPlug("arrow1Angle")
                        circleSweepManipFn.connectToAnglePlug(arrow1AnglePlug)
                        centerIndex = circleSweepManipFn.centerIndex()
                        self.addPlugToManipConversion(centerIndex)
                except:
                        pass

                # DiscManip
                discManipFn = OpenMayaUI.MFnDiscManip(self.fDiscManip)
                try:
                        arrow3AnglePlug = nodeFn.findPlug("arrow3Angle")
                        discManipFn.connectToAnglePlug(arrow3AnglePlug)
                        centerIndex = discManipFn.centerIndex()
                        self.addPlugToManipConversion(centerIndex)
                except:
                        pass

                # StateManip
                stateManipFn = OpenMayaUI.MFnStateManip(self.fStateManip)
                try:
                        statePlug = nodeFn.findPlug("state")
                        stateManipFn.connectToStatePlug(statePlug)
                        positionIndex = stateManipFn.positionIndex()
                        self.addPlugToManipConversion(positionIndex)
                except:
                        pass

                # ToggleManip
                toggleManipFn = OpenMayaUI.MFnToggleManip(self.fToggleManip)
                try:
                        togglePlug = nodeFn.findPlug("toggle")
                        toggleManipFn.connectToTogglePlug(togglePlug)
                        startPointIndex = toggleManipFn.startPointIndex()
                        self.addPlugToManipConversion(startPointIndex)
                except:
                        pass

                # Determine the transform node for the locator
                transformPath = OpenMaya.MDagPath(self.fNodePath)
                transformPath.pop()

                transformNode = OpenMaya.MFnTransform(transformPath)

                # RotateManip
                rotateManipFn = OpenMayaUI.MFnRotateManip(self.fRotateManip)
                try:
                        rotatePlug = transformNode.findPlug("rotate")
                        rotateManipFn.connectToRotationPlug(rotatePlug)
                        rotateManipFn.displayWithNode(node)
                except:
                        pass

                # ScaleManip
                scaleManipFn = OpenMayaUI.MFnScaleManip(self.fScaleManip)
                try:
                        scalePlug = transformNode.findPlug("scale")
                        scaleManipFn.connectToScalePlug(scalePlug)
                        scaleManipFn.displayWithNode(node)
                except:
                        pass

                self.finishAddingManips()
                OpenMayaMPx.MPxManipContainer.connectToDependNode(self, node)


        def draw(self, view, path, style, status):
                OpenMayaMPx.MPxManipContainer.draw(self, view, path, style, status)
                view.beginGL()
                textPos = OpenMaya.MPoint(self.nodeTranslation())
                view.drawText("Swiss Army Manipulator", textPos, OpenMayaUI.M3dView.kLeft)
                view.endGL()


        def plugToManipConversion(self, theIndex):
                numData = OpenMaya.MFnNumericData()
                numDataObj = numData.create(OpenMaya.MFnNumericData.k3Float)
                vec = self.nodeTranslation()
                numData.setData3Float(vec.x, vec.y, vec.z)
                manipData = OpenMayaUI.MManipData(numDataObj)
                return manipData

        
        def nodeTranslation(self):
                dagFn = OpenMaya.MFnDagNode(self.fNodePath)
                path = OpenMaya.MDagPath()
                dagFn.getPath(path)
                path.pop()  # pop from the shape to the transform
                transformFn = OpenMaya.MFnTransform(path)
                return transformFn.getTranslation(OpenMaya.MSpace.kWorld)


########################################################################
########################################################################

class swissArmyLocator(OpenMayaMPx.MPxLocatorNode):
        aSize = OpenMaya.MObject()         # The size of the locator
        aPoint = OpenMaya.MObject()
        aPointX = OpenMaya.MObject()
        aPointY = OpenMaya.MObject()
        aPointZ = OpenMaya.MObject()
        aArrow1Angle = OpenMaya.MObject()
        aArrow2Direction = OpenMaya.MObject()
        aArrow2DirectionX = OpenMaya.MObject()
        aArrow2DirectionY = OpenMaya.MObject()
        aArrow2DirectionZ = OpenMaya.MObject()
        aArrow3Angle = OpenMaya.MObject()
        aArrow4Distance = OpenMaya.MObject()
        aState = OpenMaya.MObject()
        aToggle = OpenMaya.MObject()

        def __init__(self):
                OpenMayaMPx.MPxLocatorNode.__init__(self)


        def compute(self, plug, data):
                return OpenMaya.kUnknownParameter


        def draw(self, view, path, style, status):

                # Get the size
                thisNode = self.thisMObject()

                plug = OpenMaya.MPlug(thisNode, swissArmyLocator.aSize)
                sizeVal = plug.asMDistance()

                arrow1AnglePlug = OpenMaya.MPlug(thisNode, swissArmyLocator.aArrow1Angle)
                arrow1Angle = arrow1AnglePlug.asMAngle()
                angle1 = -arrow1Angle.asRadians() - 3.1415927/2.0

                arrow3AnglePlug = OpenMaya.MPlug(thisNode, swissArmyLocator.aArrow3Angle)
                arrow3Angle = arrow3AnglePlug.asMAngle()
                angle3 = arrow3Angle.asRadians()

                statePlug = OpenMaya.MPlug(thisNode, swissArmyLocator.aState)
                state = statePlug.asInt()

                togglePlug = OpenMaya.MPlug(thisNode, swissArmyLocator.aToggle)
                toggle = togglePlug.asBool()

                directionXPlug = OpenMaya.MPlug(thisNode, swissArmyLocator.aArrow2DirectionX)
                directionYPlug = OpenMaya.MPlug(thisNode, swissArmyLocator.aArrow2DirectionY)
                directionZPlug = OpenMaya.MPlug(thisNode, swissArmyLocator.aArrow2DirectionZ)
                dirX = directionXPlug.asDouble()
                dirY = directionYPlug.asDouble()
                dirZ = directionZPlug.asDouble()

                angle2 = math.atan2(dirZ, dirX)
                angle2 += 3.1415927

                multiplier = sizeVal.asCentimeters()

                view.beginGL() 

                if ((style == OpenMayaUI.M3dView.kFlatShaded) or
                                (style == OpenMayaUI.M3dView.kGouraudShaded)):
                        # Push the color settings
                        glFT.glPushAttrib(OpenMayaRender.MGL_CURRENT_BIT)

                        if (status == OpenMayaUI.M3dView.kActive):
                                view.setDrawColor(13, OpenMayaUI.M3dView.kActiveColors)
                        else:
                                view.setDrawColor(13, OpenMayaUI.M3dView.kDormantColors)

                        if (toggle):
                                if (status == OpenMayaUI.M3dView.kActive):
                                        view.setDrawColor(15, OpenMayaUI.M3dView.kActiveColors)
                                else:
                                        view.setDrawColor(15, OpenMayaUI.M3dView.kDormantColors)
                                glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                                last = kCentreCount - 1
                                for i in range(last):
                                        glFT.glVertex3f(centre[i][0] * multiplier,
                                                           centre[i][1] * multiplier,
                                                           centre[i][2] * multiplier)
                                glFT.glEnd()

                        if (state == 0):
                                if (status == OpenMayaUI.M3dView.kActive):
                                        view.setDrawColor(19, OpenMayaUI.M3dView.kActiveColors)
                                else:
                                        view.setDrawColor(19, OpenMayaUI.M3dView.kDormantColors)
                                glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                                last = kState1Count - 1
                                for i in range(last):
                                        glFT.glVertex3f(state1[i][0] * multiplier,
                                                                        state1[i][1] * multiplier,
                                                                        state1[i][2] * multiplier)
                                glFT.glEnd()

                        if (state == 1):
                                if (status == OpenMayaUI.M3dView.kActive):
                                        view.setDrawColor(21, OpenMayaUI.M3dView.kActiveColors)
                                else:
                                        view.setDrawColor(21, OpenMayaUI.M3dView.kDormantColors)
                                glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                                last = kState2Count - 1
                                for i in range(last):
                                        glFT.glVertex3f(state2[i][0] * multiplier,
                                                                        state2[i][1] * multiplier,
                                                                        state2[i][2] * multiplier)
                                glFT.glEnd()

                        if (state == 2):
                                if (status == OpenMayaUI.M3dView.kActive):
                                        view.setDrawColor(18, OpenMayaUI.M3dView.kActiveColors)
                                else:
                                        view.setDrawColor(18, OpenMayaUI.M3dView.kDormantColors)
                                        glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                                        last = kState3Count - 1
                                        for i in range(last):
                                                glFT.glVertex3f(state3[i][0] * multiplier,
                                                                                state3[i][1] * multiplier,
                                                                                state3[i][2] * multiplier)
                                        glFT.glEnd()

                        if (state == 3):
                                if (status == OpenMayaUI.M3dView.kActive):
                                        view.setDrawColor(17, OpenMayaUI.M3dView.kActiveColors)
                                else:
                                        view.setDrawColor(17, OpenMayaUI.M3dView.kDormantColors)
                                glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                                last = kState4Count - 1
                                for i in range(last):
                                        glFT.glVertex3f(state4[i][0] * multiplier,
                                                                        state4[i][1] * multiplier,
                                                                        state4[i][2] * multiplier)
                                glFT.glEnd()

                        if (status == OpenMayaUI.M3dView.kActive):
                                view.setDrawColor(12, OpenMayaUI.M3dView.kActiveColors)
                        else:
                                view.setDrawColor(12, OpenMayaUI.M3dView.kDormantColors)
                        glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                        last = kArrow1Count - 1
                        for i in range(last):
                                glFT.glVertex3f((-arrow1[i][0] * multiplier * math.cos(angle1) - arrow1[i][2] * multiplier * math.sin(angle1)),
                                                                (arrow1[i][1] * multiplier + delta1),
                                                                (arrow1[i][2] * multiplier * math.cos(angle1) - arrow1[i][0] * multiplier * math.sin(angle1)))
                        glFT.glEnd()

                        if (status == OpenMayaUI.M3dView.kActive):
                                view.setDrawColor(16, OpenMayaUI.M3dView.kActiveColors)
                        else:
                                view.setDrawColor(16, OpenMayaUI.M3dView.kDormantColors)
                        glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                        last = kArrow2Count - 1
                        for i in range(last):
                                glFT.glVertex3f((-arrow2[i][0] * multiplier * math.cos(angle2) - arrow2[i][2] * multiplier * math.sin(angle2)),
                                                                (arrow2[i][1] * multiplier + delta2),
                                                                (arrow2[i][2] * multiplier * math.cos(angle2) - arrow2[i][0] * multiplier * math.sin(angle2)))
                        glFT.glEnd()

                        if (status == OpenMayaUI.M3dView.kActive):
                                view.setDrawColor(13, OpenMayaUI.M3dView.kActiveColors)
                        else:
                                view.setDrawColor(13, OpenMayaUI.M3dView.kDormantColors)
                        glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                        last = kArrow3Count - 1
                        for i in range(last):
                                glFT.glVertex3f((-arrow3[i][0] * multiplier * math.cos(angle3) - arrow3[i][2] * multiplier * math.sin(angle3)),
                                                                (arrow3[i][1] * multiplier + delta3),
                                                                (arrow3[i][2] * multiplier * math.cos(angle3) - arrow3[i][0] * multiplier * math.sin(angle3)))
                        glFT.glEnd()

                        if (status == OpenMayaUI.M3dView.kActive):
                                view.setDrawColor(5, OpenMayaUI.M3dView.kActiveColors)
                        else:
                                view.setDrawColor(5, OpenMayaUI.M3dView.kDormantColors)
                        glFT.glBegin(OpenMayaRender.MGL_TRIANGLE_FAN)
                        last = kArrow4Count - 1
                        for i in range(last):
                                glFT.glVertex3f((arrow4[i][0] * multiplier),
                                                                (arrow4[i][1] * multiplier + delta4),
                                                                (arrow4[i][2] * multiplier))
                        glFT.glEnd()

                        glFT.glPopAttrib()

                # Draw the outline of the locator
                glFT.glBegin(OpenMayaRender.MGL_LINES)

                if toggle:
                        last = kCentreCount - 1
                        for i in range(last): 
                                glFT.glVertex3f(centre[i][0] * multiplier, 
                                                                centre[i][1] * multiplier, 
                                                                centre[i][2] * multiplier)
                                glFT.glVertex3f(centre[i+1][0] * multiplier, 
                                                                centre[i+1][1] * multiplier, 
                                                                centre[i+1][2] * multiplier)

                if (state == 0):
                        last = kState1Count - 1
                        for i in range(last): 
                                glFT.glVertex3f(state1[i][0] * multiplier, 
                                                                state1[i][1] * multiplier, 
                                                                state1[i][2] * multiplier)
                                glFT.glVertex3f(state1[i+1][0] * multiplier, 
                                                                state1[i+1][1] * multiplier, 
                                                                state1[i+1][2] * multiplier)

                if (state == 1):
                        last = kState2Count - 1
                        for i in range(last): 
                                glFT.glVertex3f(state2[i][0] * multiplier, 
                                                                state2[i][1] * multiplier, 
                                                                state2[i][2] * multiplier)
                                glFT.glVertex3f(state2[i+1][0] * multiplier, 
                                                                state2[i+1][1] * multiplier, 
                                                                state2[i+1][2] * multiplier)

                if (state == 2):
                        last = kState3Count - 1
                        for i in range(last): 
                                glFT.glVertex3f(state3[i][0] * multiplier, 
                                                                state3[i][1] * multiplier, 
                                                                state3[i][2] * multiplier)
                                glFT.glVertex3f(state3[i+1][0] * multiplier, 
                                                                state3[i+1][1] * multiplier, 
                                                                state3[i+1][2] * multiplier)

                if (state == 3):
                        last = kState4Count - 1
                        for i in range(last): 
                                glFT.glVertex3f(state4[i][0] * multiplier, 
                                                                state4[i][1] * multiplier, 
                                                                state4[i][2] * multiplier)
                                glFT.glVertex3f(state4[i+1][0] * multiplier, 
                                                                state4[i+1][1] * multiplier, 
                                                                state4[i+1][2] * multiplier)

                last = kArrow1Count - 1
                for i in range(last): 
                        glFT.glVertex3f((-arrow1[i][0] * multiplier * math.cos(angle1) - arrow1[i][2] * multiplier * math.sin(angle1)),
                                                        (arrow1[i][1] * multiplier + delta1),
                                                        (arrow1[i][2] * multiplier * math.cos(angle1) - arrow1[i][0] * multiplier * math.sin(angle1)))
                        glFT.glVertex3f((-arrow1[i+1][0] * multiplier * math.cos(angle1) - arrow1[i+1][2] * multiplier * math.sin(angle1)),
                                                        (arrow1[i+1][1] * multiplier + delta1),
                                                        (arrow1[i+1][2] * multiplier * math.cos(angle1) - arrow1[i+1][0] * multiplier * math.sin(angle1)))

                last = kArrow2Count - 1
                for i in range(last): 
                        glFT.glVertex3f((-arrow2[i][0] * multiplier * math.cos(angle2) - arrow2[i][2] * multiplier * math.sin(angle2)),
                                                        (arrow2[i][1] * multiplier + delta2),
                                                        (arrow2[i][2] * multiplier * math.cos(angle2) - arrow2[i][0] * multiplier * math.sin(angle2)))
                        glFT.glVertex3f((-arrow2[i+1][0] * multiplier * math.cos(angle2) - arrow2[i+1][2] * multiplier * math.sin(angle2)),
                                                        (arrow2[i+1][1] * multiplier + delta2),
                                                        (arrow2[i+1][2] * multiplier * math.cos(angle2) - arrow2[i+1][0] * multiplier * math.sin(angle2)))

                last = kArrow3Count - 1
                for i in range(last): 
                        glFT.glVertex3f((-arrow3[i][0] * multiplier * math.cos(angle3) - arrow3[i][2] * multiplier * math.sin(angle3)),
                                                        (arrow3[i][1] * multiplier + delta3),
                                                        (arrow3[i][2] * multiplier * math.cos(angle3) - arrow3[i][0] * multiplier * math.sin(angle3)))
                        glFT.glVertex3f((-arrow3[i+1][0] * multiplier * math.cos(angle3) - arrow3[i+1][2] * multiplier * math.sin(angle3)),
                                                        (arrow3[i+1][1] * multiplier + delta3),
                                                        (arrow3[i+1][2] * multiplier * math.cos(angle3) - arrow3[i+1][0] * multiplier * math.sin(angle3)))

                last = kArrow4Count - 1
                for i in range(last): 
                        glFT.glVertex3f((arrow4[i][0] * multiplier),
                                                        (arrow4[i][1] * multiplier + delta4),
                                                        (arrow4[i][2] * multiplier))
                        glFT.glVertex3f((arrow4[i+1][0] * multiplier),
                                                        (arrow4[i+1][1] * multiplier + delta4),
                                                        (arrow4[i+1][2] * multiplier))

                last = kPerimeterCount - 1
                for i in range(last): 
                        glFT.glVertex3f(perimeter[i][0] * multiplier,
                                                        perimeter[i][1] * multiplier,
                                                        perimeter[i][2] * multiplier)
                        glFT.glVertex3f(perimeter[i+1][0] * multiplier,
                                                        perimeter[i+1][1] * multiplier,
                                                        perimeter[i+1][2] * multiplier)

                glFT.glEnd()

                view.endGL()


        def isBounded(self):
                return True


        def boundingBox(self):
                thisNode = self.thisMObject()
                plug = OpenMaya.MPlug(thisNode, swissArmyLocator.aSize)
                sizeVal = plug.asMDistance()

                multiplier = sizeVal.asCentimeters()

                corner1 = OpenMaya.MPoint(-1.1, 0.0, -1.1)
                corner2 = OpenMaya.MPoint(1.1, 0.0, 1.1)

                corner1 = corner1 * multiplier
                corner2 = corner2 * multiplier

                return OpenMaya.MBoundingBox(corner1, corner2)



########################################################################
########################################################################


def locatorCreator():
        return swissArmyLocator()


def locatorInit():
        unitFn = OpenMaya.MFnUnitAttribute()
        numericFn = OpenMaya.MFnNumericAttribute()

        # aSize
        swissArmyLocator.aSize = unitFn.create("size", "sz", OpenMaya.MFnUnitAttribute.kDistance, 10.0)
        unitFn.setStorable(True)
        unitFn.setWritable(True)

        # aPoint
        swissArmyLocator.aPointX = numericFn.create("pointX", "ptx", OpenMaya.MFnNumericData.kDouble, 0.0)
        swissArmyLocator.aPointY = numericFn.create("pointY", "pty", OpenMaya.MFnNumericData.kDouble, 0.0)
        swissArmyLocator.aPointZ = numericFn.create("pointZ", "ptz", OpenMaya.MFnNumericData.kDouble, 0.0)
        swissArmyLocator.aPoint = numericFn.create("point", "pt", swissArmyLocator.aPointX, swissArmyLocator.aPointY, swissArmyLocator.aPointZ)

        # aArrow1Angle
        swissArmyLocator.aArrow1Angle = unitFn.create("arrow1Angle", "a1a", OpenMaya.MFnUnitAttribute.kAngle, 0.0)

        # aArrow2Direction
        swissArmyLocator.aArrow2DirectionX = numericFn.create("arrow2DirectionX", "a2x", OpenMaya.MFnNumericData.kDouble, 1.0)
        swissArmyLocator.aArrow2DirectionY = numericFn.create("arrow2DirectionY", "a2y", OpenMaya.MFnNumericData.kDouble, 0.0)
        swissArmyLocator.aArrow2DirectionZ = numericFn.create("arrow2DirectionZ", "a2z", OpenMaya.MFnNumericData.kDouble, 0.0)
        swissArmyLocator.aArrow2Direction = numericFn.create("arrow2Direction", "dir", swissArmyLocator.aArrow2DirectionX, swissArmyLocator.aArrow2DirectionY, swissArmyLocator.aArrow2DirectionZ)

        # aArrow3Angle
        swissArmyLocator.aArrow3Angle = unitFn.create("arrow3Angle", "a3a", OpenMaya.MFnUnitAttribute.kAngle, 0.0)
        # aArrow4Distance
        swissArmyLocator.aArrow4Distance = unitFn.create("arrow2Distance", "dis", OpenMaya.MFnUnitAttribute.kDistance, 0.0)

        # aState
        swissArmyLocator.aState = numericFn.create("state", "s", OpenMaya.MFnNumericData.kLong, 0)

        # aToggle
        swissArmyLocator.aToggle = numericFn.create("toggle", "t", OpenMaya.MFnNumericData.kBoolean, False)

        swissArmyLocator.addAttribute(swissArmyLocator.aPoint)
        swissArmyLocator.addAttribute(swissArmyLocator.aArrow1Angle)
        swissArmyLocator.addAttribute(swissArmyLocator.aArrow2Direction)
        swissArmyLocator.addAttribute(swissArmyLocator.aArrow3Angle)
        swissArmyLocator.addAttribute(swissArmyLocator.aArrow4Distance)
        swissArmyLocator.addAttribute(swissArmyLocator.aState)
        swissArmyLocator.addAttribute(swissArmyLocator.aToggle)
        swissArmyLocator.addAttribute(swissArmyLocator.aSize)

        OpenMayaMPx.MPxManipContainer.addToManipConnectTable(kSwissArmyLocatorId)


def locatorManipCreator():
     return swissArmyLocatorManip()


def locatorManipInit():
    OpenMayaMPx.MPxManipContainer.initialize()


# initialize the script plug-in
def initializePlugin(mobject):
        mplugin = OpenMayaMPx.MFnPlugin(mobject, "Autodesk", "1.0", "Any")

        try:
                mplugin.registerNode(kSwissArmyLocatorName, 
                                                                kSwissArmyLocatorId,
                                                                locatorCreator,
                                                                locatorInit,
                                                                OpenMayaMPx.MPxNode.kLocatorNode)
        except:
                print "Failed to register context command: %s" % kSwissArmyLocatorName
                raise

        try:
                mplugin.registerNode(kSwissArmyLocatorManipName, 
                                                                kSwissArmyLocatorManipId, 
                                                                locatorManipCreator, 
                                                                locatorManipInit,
                                                                OpenMayaMPx.MPxNode.kManipContainer)
        except:
                print "Failed to register node: %s" % kSwissArmyLocatorManipName
                raise


# uninitialize the script plug-in
def uninitializePlugin(mobject):
        mplugin = OpenMayaMPx.MFnPlugin(mobject)

        try:
                mplugin.deregisterNode(kSwissArmyLocatorId)
        except:
                print "Failed to deregister context command: %s" % kSwissArmyLocatorName
                raise

        try:
                mplugin.deregisterNode(kSwissArmyLocatorManipId)
        except:
                print "Failed to deregister node: %s" % kSwissArmyLocatorManipName
                raise