swissArmyManip/swissArmyManip.cpp
 
 
 
swissArmyManip/swissArmyManip.cpp
//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+

//
// swissArmyManip.cpp
//
// This plug-in is an example of a user-defined manipulator,
// which is comprised of a variety of the base manipulators:
// - MFnCircleSweepManip.h
// - MFnDirectionManip.h
// - MFnDiscManip.h
// - MFnDistanceManip.h
// - MFnFreePointTriadManip.h
// - MFnStateManip.h
// - MFnToggleManip.h
// - MFnRotateManip.h
// - MFnScaleManip.h
//
// To use this plug-in:
//
//     mel: loadPlugin "swissArmyManip.so";
//     mel: createNode swissArmyLocator;
//     click on the showManipTool
//

#include <math.h>
#include <maya/MIOStream.h>

#include <maya/MPxNode.h>

#include <maya/MPxLocatorNode.h>

#include <maya/MString.h>
#include <maya/MTypeId.h>
#include <maya/MPlug.h>
#include <maya/MVector.h>
#include <maya/MAngle.h>
#include <maya/MDataBlock.h>
#include <maya/MDataHandle.h>
#include <maya/MColor.h>
#include <maya/M3dView.h>
#include <maya/MFnPlugin.h>
#include <maya/MDistance.h>

#include <maya/MFnUnitAttribute.h>
#include <maya/MFnNumericAttribute.h>

#include <maya/MFn.h>
#include <maya/MPxNode.h>
#include <maya/MPxManipContainer.h>

#include <maya/MFnCircleSweepManip.h>
#include <maya/MFnDirectionManip.h>
#include <maya/MFnDiscManip.h>
#include <maya/MFnDistanceManip.h>
#include <maya/MFnFreePointTriadManip.h>
#include <maya/MFnStateManip.h>
#include <maya/MFnToggleManip.h>
#include <maya/MFnRotateManip.h>
#include <maya/MFnScaleManip.h>

#include <maya/MPxContext.h>
#include <maya/MPxSelectionContext.h>

#include <maya/MPxDrawOverride.h>
#include <maya/MStateManager.h>
#include <maya/MDrawRegistry.h>
#include <maya/MDrawContext.h>
#include <maya/MHWGeometryUtilities.h>

#include <maya/MFnNumericData.h>
#include <maya/MManipData.h>

#define e \
    counter++; \
    if (MS::kSuccess != s) { \
        cerr << "Status Error in method " << method \
             << " at checkpoint #" << counter << "." << "\n" \
                         << "    in File: " << __FILE__ \
                         << ", at Line: " << __LINE__ << endl; \
        s.perror("Error"); \
    }

const double delta1 = 0.01;
const double delta2 = 0.02;
const double delta3 = 0.03;
const double delta4 = 0.04;

// Locator Data
//
static float centre[][3] = { {  0.10f, 0.0f,  0.10f},
                                                         {  0.10f, 0.0f, -0.10f },
                                                         { -0.10f, 0.0f, -0.10f },
                                                         { -0.10f, 0.0f,  0.10f },
                                                         {  0.10f, 0.0f,  0.10f } };
static float state1[][3] = { {  1.00f, 0.0f,  1.00f},
                                                         {  1.00f, 0.0f,  0.50f },
                                                         {  0.50f, 0.0f,  0.50f },
                                                         {  0.50f, 0.0f,  1.00f },
                                                         {  1.00f, 0.0f,  1.00f } };
static float state2[][3] = { {  1.00f, 0.0f, -1.00f},
                                                         {  1.00f, 0.0f, -0.50f },
                                                         {  0.50f, 0.0f, -0.50f },
                                                         {  0.50f, 0.0f, -1.00f },
                                                         {  1.00f, 0.0f, -1.00f } };
static float state3[][3] = { { -1.00f, 0.0f, -1.00f},
                                                         { -1.00f, 0.0f, -0.50f },
                                                         { -0.50f, 0.0f, -0.50f },
                                                         { -0.50f, 0.0f, -1.00f },
                                                         { -1.00f, 0.0f, -1.00f } };
static float state4[][3] = { { -1.00f, 0.0f,  1.00f},
                                                         { -1.00f, 0.0f,  0.50f },
                                                         { -0.50f, 0.0f,  0.50f },
                                                         { -0.50f, 0.0f,  1.00f },
                                                         { -1.00f, 0.0f,  1.00f } };
static float arrow1[][3] = { {  0.00f, 0.0f,  1.00f},
                                                         {  0.10f, 0.0f,  0.20f },
                                                         { -0.10f, 0.0f,  0.20f },
                                                         {  0.00f, 0.0f,  1.00f } };
static float arrow2[][3] = { {  1.00f, 0.0f,  0.00f},
                                                         {  0.20f, 0.0f,  0.10f },
                                                         {  0.20f, 0.0f, -0.10f },
                                                         {  1.00f, 0.0f,  0.00f } };
static float arrow3[][3] = { {  0.00f, 0.0f, -1.00f},
                                                         {  0.10f, 0.0f, -0.20f },
                                                         { -0.10f, 0.0f, -0.20f },
                                                         {  0.00f, 0.0f, -1.00f } };
static float arrow4[][3] = { { -1.00f, 0.0f,  0.00f},
                                                         { -0.20f, 0.0f,  0.10f },
                                                         { -0.20f, 0.0f, -0.10f },
                                                         { -1.00f, 0.0f,  0.00f } };
static float perimeter[][3] = { {  1.10f, 0.0f,  1.10f},
                                                                {  1.10f, 0.0f, -1.10f },
                                                                { -1.10f, 0.0f, -1.10f },
                                                                { -1.10f, 0.0f,  1.10f },
                                                                {  1.10f, 0.0f,  1.10f } };

static int centreCount = 5;
static int state1Count = 5;
static int state2Count = 5;
static int state3Count = 5;
static int state4Count = 5;
static int arrow1Count = 4;
static int arrow2Count = 4;
static int arrow3Count = 4;
static int arrow4Count = 4;
static int perimeterCount = 5;


class swissArmyLocatorManip : public MPxManipContainer
{
public:
    swissArmyLocatorManip();
    virtual ~swissArmyLocatorManip();

    static void * creator();
    static MStatus initialize();
    virtual MStatus createChildren();
    virtual MStatus connectToDependNode(const MObject & node);

        //Viewport 2.0 manipulator draw overrides
        virtual void            preDrawUI( const M3dView &view );
        virtual void            drawUI( MHWRender::MUIDrawManager& drawManager ) const;

    virtual void draw(M3dView & view,
                                          const MDagPath & path,
                                          M3dView::DisplayStyle style,
                                          M3dView::DisplayStatus status);
        MManipData startPointCallback(unsigned index) const;
        MVector nodeTranslation() const;

    MDagPath fCircleSweepManip;
    MDagPath fDirectionManip;
    MDagPath fDiscManip;
    MDagPath fDistanceManip;
    MDagPath fFreePointTriadManip;
    MDagPath fStateManip;
    MDagPath fToggleManip;
        MDagPath fRotateManip;
    MDagPath fScaleManip;

        MDagPath fNodePath;

        //Value prepared for Viewport 2.0 draw
        MPoint fTextPosition;

public:
    static MTypeId id;
};


MManipData swissArmyLocatorManip::startPointCallback(unsigned /*index*/)
const
{
        MManipData manipData;
        MFnNumericData numData;
        MObject numDataObj = numData.create(MFnNumericData::k3Double);
        MVector vec = nodeTranslation();
        numData.setData(vec.x, vec.y, vec.z);
        manipData = numDataObj;
        return manipData;
}


MVector swissArmyLocatorManip::nodeTranslation() const
{
        MFnDagNode dagFn(fNodePath);
        MDagPath path;
        dagFn.getPath(path);
        path.pop();  // pop from the shape to the transform
        MFnTransform transformFn(path);
        return transformFn.translation(MSpace::kWorld);
}


MTypeId swissArmyLocatorManip::id( 0x8001e );


swissArmyLocatorManip::swissArmyLocatorManip()
{
    // Do not call createChildren from here
}


swissArmyLocatorManip::~swissArmyLocatorManip()
{
}


void* swissArmyLocatorManip::creator()
{
     return new swissArmyLocatorManip();
}


MStatus swissArmyLocatorManip::initialize()
{
    MStatus stat;
    stat = MPxManipContainer::initialize();
    return stat;
}


MStatus swissArmyLocatorManip::createChildren()
{
    MStatus stat = MStatus::kSuccess;
        MString method("swissArmyLocatorManip::createChildren");
        MStatus s;
        int counter = 0;

        // FreePointTriadManip
        //
        fFreePointTriadManip = addFreePointTriadManip("freePointTriadManip",
                                                                                                  "point");
        MFnFreePointTriadManip freePointTriadManipFn(fFreePointTriadManip);

        // DirectionManip
        //
        fDirectionManip = addDirectionManip("directionManip",
                                                                                "direction");
        MFnDirectionManip directionManipFn(fDirectionManip);

        // ToggleManip
        //
        fToggleManip = addToggleManip("toggleManip", "toggle");
        MFnToggleManip toggleManipFn(fToggleManip);

        // StateManip
        //
        fStateManip = addStateManip("stateManip", "state");
        MFnStateManip stateManipFn(fStateManip);

        // DiscManip
        //
        fDiscManip = addDiscManip("discManip",
                                                          "angle");
        MFnDiscManip discManipFn(fDiscManip);

        // CircleSweepManip
        //
        fCircleSweepManip = addCircleSweepManip("circleSweepManip",
                                                                                        "angle");
        MFnCircleSweepManip circleSweepManipFn(fCircleSweepManip, &s); e;
        circleSweepManipFn.setCenterPoint(MPoint(0, 0, 0));
        circleSweepManipFn.setNormal(MVector(0, 1, 0));
        circleSweepManipFn.setRadius(2.0);
        circleSweepManipFn.setDrawAsArc(true);

        // DistanceManip
        //
    MString manipName("distanceManip");
    MString distanceName("distance");
    MPoint startPoint(0.0, 0.0, 0.0);
    MVector direction(0.0, 1.0, 0.0);
    fDistanceManip = addDistanceManip(manipName,
                                                                          distanceName);
        MFnDistanceManip distanceManipFn(fDistanceManip);
        distanceManipFn.setStartPoint(startPoint);
        distanceManipFn.setDirection(direction);

        // RotateManip
        //
    MString RotateManipName("RotateManip");
    MString rotateName("rotation");
    fRotateManip = addRotateManip(RotateManipName, rotateName);
        MFnRotateManip rotateManipFn(fRotateManip);

        // ScaleManip
        //
    MString scaleManipName("scaleManip");
    MString scaleName("scale");
    fScaleManip = addScaleManip(scaleManipName, scaleName);
        MFnScaleManip scaleManipFn(fScaleManip);

    return stat;
}


MStatus swissArmyLocatorManip::connectToDependNode(const MObject &node)
{
    MStatus stat;

        // Get the DAG path
        //
        MFnDagNode dagNodeFn(node);
        dagNodeFn.getPath(fNodePath);
        MObject parentNode = dagNodeFn.parent(0);
        MFnDagNode parentNodeFn(parentNode);

    // Connect the plugs
    //
    MFnDependencyNode nodeFn;
    nodeFn.setObject(node);

        // FreePointTriadManip
        //
    MFnFreePointTriadManip freePointTriadManipFn(fFreePointTriadManip);
        MPlug translationPlug = parentNodeFn.findPlug("t", &stat);
    if (MStatus::kFailure != stat) {
            freePointTriadManipFn.connectToPointPlug(translationPlug);
        }

        // DirectionManip
        //
    MFnDirectionManip directionManipFn;
    directionManipFn.setObject(fDirectionManip);
        MPlug directionPlug = nodeFn.findPlug("arrow2Direction", &stat);
    if (MStatus::kFailure != stat) {
            directionManipFn.connectToDirectionPlug(directionPlug);
                unsigned startPointIndex = directionManipFn.startPointIndex();
            addPlugToManipConversionCallback(startPointIndex,
                                                                                 (plugToManipConversionCallback)
                                                                                 &swissArmyLocatorManip::startPointCallback);
        }

        // DistanceManip
        //
    MFnDistanceManip distanceManipFn;
    distanceManipFn.setObject(fDistanceManip);
        MPlug sizePlug = nodeFn.findPlug("size", &stat);
    if (MStatus::kFailure != stat) {
            distanceManipFn.connectToDistancePlug(sizePlug);
                unsigned startPointIndex = distanceManipFn.startPointIndex();
            addPlugToManipConversionCallback(startPointIndex,
                                                                                 (plugToManipConversionCallback)
                                                                                 &swissArmyLocatorManip::startPointCallback);
        }

        // CircleSweepManip
        //
        MFnCircleSweepManip circleSweepManipFn(fCircleSweepManip);
        MPlug arrow1AnglePlug = nodeFn.findPlug("arrow1Angle", &stat);
    if (MStatus::kFailure != stat) {
            circleSweepManipFn.connectToAnglePlug(arrow1AnglePlug);
                unsigned centerIndex = circleSweepManipFn.centerIndex();
            addPlugToManipConversionCallback(centerIndex,
                                                                                 (plugToManipConversionCallback)
                                                                                 &swissArmyLocatorManip::startPointCallback);
        }

        // DiscManip
        //
        MFnDiscManip discManipFn(fDiscManip);
        MPlug arrow3AnglePlug = nodeFn.findPlug("arrow3Angle", &stat);
    if (MStatus::kFailure != stat) {
            discManipFn.connectToAnglePlug(arrow3AnglePlug);
                unsigned centerIndex = discManipFn.centerIndex();
            addPlugToManipConversionCallback(centerIndex,
                                                                                 (plugToManipConversionCallback)
                                                                                 &swissArmyLocatorManip::startPointCallback);
        }

        // StateManip
        //
        MFnStateManip stateManipFn(fStateManip);

        MPlug statePlug = nodeFn.findPlug("state", &stat);
    if (MStatus::kFailure != stat) {
            stateManipFn.connectToStatePlug(statePlug);
                unsigned positionIndex = stateManipFn.positionIndex();
            addPlugToManipConversionCallback(positionIndex,
                                                                                 (plugToManipConversionCallback)
                                                                                 &swissArmyLocatorManip::startPointCallback);
        }

        // ToggleManip
        //
        MFnToggleManip toggleManipFn(fToggleManip);

        MPlug togglePlug = nodeFn.findPlug("toggle", &stat);
    if (MStatus::kFailure != stat) {
            toggleManipFn.connectToTogglePlug(togglePlug);
                unsigned startPointIndex = toggleManipFn.startPointIndex();
            addPlugToManipConversionCallback(startPointIndex,
                                                                                 (plugToManipConversionCallback)
                                                                                 &swissArmyLocatorManip::startPointCallback);
        }

        // Determine the transform node for the locator
        //
        MDagPath transformPath(fNodePath);
        transformPath.pop();

        MFnTransform transformNode(transformPath);

        // RotateManip
        //
        MFnRotateManip rotateManipFn(fRotateManip);

        MPlug rotatePlug = transformNode.findPlug("rotate", &stat);
        if (MStatus::kFailure != stat) {
            rotateManipFn.connectToRotationPlug(rotatePlug);
                rotateManipFn.displayWithNode(node);
        }

        // ScaleManip
        //
        MFnScaleManip scaleManipFn(fScaleManip);

        MPlug scalePlug = transformNode.findPlug("scale", &stat);
    if (MStatus::kFailure != stat) {
            scaleManipFn.connectToScalePlug(scalePlug);
                scaleManipFn.displayWithNode(node);
        }

        finishAddingManips();
        MPxManipContainer::connectToDependNode(node);

    return stat;
}


void swissArmyLocatorManip::draw(M3dView & view,
                                                                 const MDagPath &path,
                                                                 M3dView::DisplayStyle style,
                                                                 M3dView::DisplayStatus status)
{
    MPxManipContainer::draw(view, path, style, status);
    view.beginGL();

    MPoint textPos = nodeTranslation();
        char str[100];
    sprintf(str, "Swiss Army Manipulator");
    MString distanceText(str);
    view.drawText(distanceText, textPos, M3dView::kLeft);
    view.endGL();
}

// Viewport 2.0 manipulator draw overrides
void swissArmyLocatorManip::preDrawUI( const M3dView &view )
{
        // Update text drawing position
        fTextPosition = nodeTranslation();
}

void swissArmyLocatorManip::drawUI( MHWRender::MUIDrawManager& drawManager ) const
{
        drawManager.beginDrawable();

        drawManager.setColor( MColor( 0.0f, 1.0f, 0.1f ) );
        drawManager.text( fTextPosition, "Swiss Army Manipulator", MHWRender::MUIDrawManager::kLeft );

        drawManager.endDrawable();
}

class swissArmyLocator : public MPxLocatorNode
{
public:
        swissArmyLocator();
        virtual ~swissArmyLocator();

    virtual MStatus             compute(const MPlug& plug, MDataBlock &data);

        virtual void            draw(M3dView &view, const MDagPath &path,
                                                                 M3dView::DisplayStyle style,
                                                                 M3dView::DisplayStatus status);

        virtual bool            isBounded() const;
        virtual MBoundingBox    boundingBox() const;

        // Access data from node for drawing, reused by VP1 and VP2 implementations
        struct DrawData
        {
                float multiplier;
                double angle1;
                double angle2;
                double angle3;
                int state;
                bool toggle;
        };
        void getDrawData(DrawData& data);

        // Draw helper methods
        static void drawOutline(const DrawData& data);

        static  void *          creator();
        static  MStatus         initialize();
        static  MObject         aSize;         // The size of the locator
        static  MObject                 aPoint;
        static  MObject                 aPointX;
        static  MObject                 aPointY;
        static  MObject                 aPointZ;
        static  MObject                 aArrow1Angle;
        static  MObject                 aArrow2Direction;
        static  MObject                 aArrow2DirectionX;
        static  MObject                 aArrow2DirectionY;
        static  MObject                 aArrow2DirectionZ;
        static  MObject                 aArrow3Angle;
        static  MObject                 aArrow4Distance;
        static  MObject                 aState;
        static  MObject                 aToggle;

public:
        static  MTypeId         id;
        static  MString         classification;
        static  MString         registrantId;
};


MTypeId swissArmyLocator::id( 0x8001f );
MString swissArmyLocator::classification("drawdb/geometry/swissArmyLocator");
MString swissArmyLocator::registrantId("SwissArmyLocatorNodePlugin");
MObject swissArmyLocator::aSize;
MObject swissArmyLocator::aPoint;
MObject swissArmyLocator::aPointX;
MObject swissArmyLocator::aPointY;
MObject swissArmyLocator::aPointZ;
MObject swissArmyLocator::aArrow1Angle;
MObject swissArmyLocator::aArrow2Direction;
MObject swissArmyLocator::aArrow2DirectionX;
MObject swissArmyLocator::aArrow2DirectionY;
MObject swissArmyLocator::aArrow2DirectionZ;
MObject swissArmyLocator::aArrow3Angle;
MObject swissArmyLocator::aArrow4Distance;
MObject swissArmyLocator::aState;
MObject swissArmyLocator::aToggle;


swissArmyLocator::swissArmyLocator()
{}


swissArmyLocator::~swissArmyLocator()
{}


MStatus swissArmyLocator::compute(const MPlug &/*plug*/, MDataBlock &/*data*/)
{
        return MS::kUnknownParameter;
}

void swissArmyLocator::getDrawData(DrawData& data)
{
        MObject node = thisMObject();

        MPlug plug(node, swissArmyLocator::aSize);
        MDistance sizeVal;
        plug.getValue(sizeVal);
        data.multiplier = (float)sizeVal.asCentimeters();

        MPlug arrow1AnglePlug(node, swissArmyLocator::aArrow1Angle);
        MAngle arrow1Angle;
        arrow1AnglePlug.getValue(arrow1Angle);
        data.angle1 = -arrow1Angle.asRadians() - 3.1415927/2.0;

        MPlug directionXPlug(node, swissArmyLocator::aArrow2DirectionX);
        MPlug directionZPlug(node, swissArmyLocator::aArrow2DirectionZ);
        double dirX, dirZ;
        directionXPlug.getValue(dirX);
        directionZPlug.getValue(dirZ);
        data.angle2 = atan2(dirZ,dirX) + 3.1415927;

        MPlug arrow3AnglePlug(node, swissArmyLocator::aArrow3Angle);
        MAngle arrow3Angle;
        arrow3AnglePlug.getValue(arrow3Angle);
        data.angle3 = arrow3Angle.asRadians();

        MPlug statePlug(node, swissArmyLocator::aState);
        statePlug.getValue(data.state);

        MPlug togglePlug(node, swissArmyLocator::aToggle);
        togglePlug.getValue(data.toggle);
}

void swissArmyLocator::draw(M3dView &view, const MDagPath &/*path*/,
                                                        M3dView::DisplayStyle style,
                                                        M3dView::DisplayStatus status)
{
        // Get draw data
        //
        DrawData data;
        getDrawData(data);

        view.beginGL();

        if ((style == M3dView::kFlatShaded) ||
                (style == M3dView::kGouraudShaded))
        {
                // Push the color settings
                //
                glPushAttrib(GL_CURRENT_BIT);

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

                int i;
                int last;

                if (data.toggle) {
                if (status == M3dView::kActive)
                        view.setDrawColor(15, M3dView::kActiveColors);
                else
                        view.setDrawColor(15, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = centreCount - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f(centre[i][0] * data.multiplier,
                                                   centre[i][1] * data.multiplier,
                                                   centre[i][2] * data.multiplier);
                        }
                glEnd();
                }

                if (data.state == 0) {
                if (status == M3dView::kActive)
                        view.setDrawColor(19, M3dView::kActiveColors);
                else
                        view.setDrawColor(19, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = state1Count - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f(state1[i][0] * data.multiplier,
                                                   state1[i][1] * data.multiplier,
                                                   state1[i][2] * data.multiplier);
                        }
                glEnd();
                }

                if (data.state == 1) {
                if (status == M3dView::kActive)
                        view.setDrawColor(21, M3dView::kActiveColors);
                else
                        view.setDrawColor(21, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = state2Count - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f(state2[i][0] * data.multiplier,
                                                   state2[i][1] * data.multiplier,
                                                   state2[i][2] * data.multiplier);
                        }
                glEnd();
                }

                if (data.state == 2) {
                if (status == M3dView::kActive)
                        view.setDrawColor(18, M3dView::kActiveColors);
                else
                        view.setDrawColor(18, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = state3Count - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f(state3[i][0] * data.multiplier,
                                                   state3[i][1] * data.multiplier,
                                                   state3[i][2] * data.multiplier);
                        }
                glEnd();
                }

                if (data.state == 3) {
                if (status == M3dView::kActive)
                        view.setDrawColor(17, M3dView::kActiveColors);
                else
                        view.setDrawColor(17, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = state4Count - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f(state4[i][0] * data.multiplier,
                                                   state4[i][1] * data.multiplier,
                                                   state4[i][2] * data.multiplier);
                        }
                glEnd();
                }

                if (status == M3dView::kActive)
                        view.setDrawColor(12, M3dView::kActiveColors);
                else
                        view.setDrawColor(12, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = arrow1Count - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f( (float) (- arrow1[i][0] * data.multiplier * cos(data.angle1)
                                                   - arrow1[i][2] * data.multiplier * sin(data.angle1)),
                                                   (float) (arrow1[i][1] * data.multiplier + delta1),
                                                   (float) (arrow1[i][2] * data.multiplier * cos(data.angle1) -
                                                   arrow1[i][0] * data.multiplier * sin(data.angle1)));
                        }
                glEnd();

                if (status == M3dView::kActive)
                        view.setDrawColor(16, M3dView::kActiveColors);
                else
                        view.setDrawColor(16, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = arrow2Count - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f( (float) (- arrow2[i][0] * data.multiplier * cos(data.angle2)
                                                   - arrow2[i][2] * data.multiplier * sin(data.angle2)),
                                                   (float) (arrow2[i][1] * data.multiplier + delta2),
                                                   (float) (arrow2[i][2] * data.multiplier * cos(data.angle2) -
                                                   arrow2[i][0] * data.multiplier * sin(data.angle2)));
                        }
                glEnd();

                if (status == M3dView::kActive)
                        view.setDrawColor(13, M3dView::kActiveColors);
                else
                        view.setDrawColor(13, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = arrow3Count - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f( (float) (- arrow3[i][0] * data.multiplier * cos(data.angle3)
                                                   - arrow3[i][2] * data.multiplier * sin(data.angle3)),
                                                   (float) (arrow3[i][1] * data.multiplier + delta3),
                                                   (float) (arrow3[i][2] * data.multiplier * cos(data.angle3) -
                                                   arrow3[i][0] * data.multiplier * sin(data.angle3)));
                        }
                glEnd();

                if (status == M3dView::kActive)
                        view.setDrawColor(5, M3dView::kActiveColors);
                else
                        view.setDrawColor(5, M3dView::kDormantColors);
                glBegin(GL_TRIANGLE_FAN);
                        last = arrow4Count - 1;
                        for (i = 0; i < last; ++i) {
                                glVertex3f((float) (arrow4[i][0] * data.multiplier),
                                                   (float) (arrow4[i][1] * data.multiplier + delta4),
                                                   (float) (arrow4[i][2] * data.multiplier));
                        }
                glEnd();

                glPopAttrib();
        }

        // Draw the outline of the locator
        //
        drawOutline(data);

        view.endGL();
}

void swissArmyLocator::drawOutline(const DrawData& data)
{
        glBegin(GL_LINES);
            int i;
                int last;

                if (data.toggle) {
                last = centreCount - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f(centre[i][0] * data.multiplier,
                                           centre[i][1] * data.multiplier,
                                           centre[i][2] * data.multiplier);
                        glVertex3f(centre[i+1][0] * data.multiplier,
                                           centre[i+1][1] * data.multiplier,
                                           centre[i+1][2] * data.multiplier);
                }
                }

                if (data.state == 0) {
                last = state1Count - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f(state1[i][0] * data.multiplier,
                                           state1[i][1] * data.multiplier,
                                           state1[i][2] * data.multiplier);
                        glVertex3f(state1[i+1][0] * data.multiplier,
                                           state1[i+1][1] * data.multiplier,
                                           state1[i+1][2] * data.multiplier);
                }
                }

                if (data.state == 1) {
                last = state2Count - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f(state2[i][0] * data.multiplier,
                                           state2[i][1] * data.multiplier,
                                           state2[i][2] * data.multiplier);
                        glVertex3f(state2[i+1][0] * data.multiplier,
                                           state2[i+1][1] * data.multiplier,
                                           state2[i+1][2] * data.multiplier);
                }
                }

                if (data.state == 2) {
                last = state3Count - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f(state3[i][0] * data.multiplier,
                                           state3[i][1] * data.multiplier,
                                           state3[i][2] * data.multiplier);
                        glVertex3f(state3[i+1][0] * data.multiplier,
                                           state3[i+1][1] * data.multiplier,
                                           state3[i+1][2] * data.multiplier);
                }
                }

                if (data.state == 3) {
                last = state4Count - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f(state4[i][0] * data.multiplier,
                                           state4[i][1] * data.multiplier,
                                           state4[i][2] * data.multiplier);
                        glVertex3f(state4[i+1][0] * data.multiplier,
                                           state4[i+1][1] * data.multiplier,
                                           state4[i+1][2] * data.multiplier);
                }
                }

                last = arrow1Count - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f((float) (- arrow1[i][0] * data.multiplier * cos(data.angle1)
                                           - arrow1[i][2] * data.multiplier * sin(data.angle1)),
                                           (float) (arrow1[i][1] * data.multiplier + delta1),
                                           (float) (arrow1[i][2] * data.multiplier * cos(data.angle1) -
                                           arrow1[i][0] * data.multiplier * sin(data.angle1)));
                        glVertex3f((float) (- arrow1[i+1][0] * data.multiplier * cos(data.angle1)
                                           - arrow1[i+1][2] * data.multiplier * sin(data.angle1)),
                                           (float) (arrow1[i+1][1] * data.multiplier + delta1),
                                           (float) (arrow1[i+1][2] * data.multiplier * cos(data.angle1) -
                                           arrow1[i+1][0] * data.multiplier * sin(data.angle1)));
                }

                last = arrow2Count - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f((float) (- arrow2[i][0] * data.multiplier * cos(data.angle2)
                                           - arrow2[i][2] * data.multiplier * sin(data.angle2)),
                                           (float) (arrow2[i][1] * data.multiplier + delta2),
                                           (float) (arrow2[i][2] * data.multiplier * cos(data.angle2) -
                                           arrow2[i][0] * data.multiplier * sin(data.angle2)));
                        glVertex3f((float) (- arrow2[i+1][0] * data.multiplier * cos(data.angle2)
                                           - arrow2[i+1][2] * data.multiplier * sin(data.angle2)),
                                           (float) (arrow2[i+1][1] * data.multiplier + delta2),
                                           (float) (arrow2[i+1][2] * data.multiplier * cos(data.angle2) -
                                           arrow2[i+1][0] * data.multiplier * sin(data.angle2)));
                }

                last = arrow3Count - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f((float) (- arrow3[i][0] * data.multiplier * cos(data.angle3)
                                           - arrow3[i][2] * data.multiplier * sin(data.angle3)),
                                           (float) (arrow3[i][1] * data.multiplier + delta3),
                                           (float) (arrow3[i][2] * data.multiplier * cos(data.angle3) -
                                           arrow3[i][0] * data.multiplier * sin(data.angle3)));
                        glVertex3f((float) (- arrow3[i+1][0] * data.multiplier * cos(data.angle3)
                                           - arrow3[i+1][2] * data.multiplier * sin(data.angle3)),
                                           (float) (arrow3[i+1][1] * data.multiplier + delta3),
                                           (float) (arrow3[i+1][2] * data.multiplier * cos(data.angle3) -
                                           arrow3[i+1][0] * data.multiplier * sin(data.angle3)));
                }

                last = arrow4Count - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f((float) (arrow4[i][0] * data.multiplier),
                                           (float) (arrow4[i][1] * data.multiplier + delta4),
                                           (float) (arrow4[i][2] * data.multiplier));
                        glVertex3f((float) (arrow4[i+1][0] * data.multiplier),
                                           (float) (arrow4[i+1][1] * data.multiplier + delta4),
                                           (float) (arrow4[i+1][2] * data.multiplier));
                }

                last = perimeterCount - 1;
            for (i = 0; i < last; ++i) {
                        glVertex3f(perimeter[i][0] * data.multiplier,
                                           perimeter[i][1] * data.multiplier,
                                           perimeter[i][2] * data.multiplier);
                        glVertex3f(perimeter[i+1][0] * data.multiplier,
                                           perimeter[i+1][1] * data.multiplier,
                                           perimeter[i+1][2] * data.multiplier);
                }
        glEnd();
}


bool swissArmyLocator::isBounded() const
{
        return true;
}


MBoundingBox swissArmyLocator::boundingBox() const
{
        // Get the size
        //
        MObject thisNode = thisMObject();
        MPlug plug(thisNode, aSize);
        MDistance sizeVal;
        plug.getValue(sizeVal);

        double multiplier = sizeVal.asCentimeters();

        MPoint corner1(-1.1, 0.0, -1.1);
        MPoint corner2(1.1, 0.0, 1.1);

        corner1 = corner1 * multiplier;
        corner2 = corner2 * multiplier;

        return MBoundingBox(corner1, corner2);
}


void* swissArmyLocator::creator()
{
        return new swissArmyLocator();
}


MStatus swissArmyLocator::initialize()
{
        MFnUnitAttribute unitFn;
        MFnNumericAttribute numericFn;
        MStatus                  stat;
        MString method("swissArmyLocator::initialize");
        MStatus s;
        int counter = 0;

        // aSize
        aSize = unitFn.create("size", "sz", MFnUnitAttribute::kDistance,
                                                  0.0, &s); e;
        unitFn.setDefault(10.0);
        unitFn.setStorable(true);
        unitFn.setWritable(true);

        // aPoint
        aPointX = numericFn.create("pointX", "ptx",
                                                           MFnNumericData::kDouble, 0.0, &s); e;
        aPointY = numericFn.create("pointY", "pty",
                                                           MFnNumericData::kDouble, 0.0, &s); e;
        aPointZ = numericFn.create("pointZ", "ptz",
                                                           MFnNumericData::kDouble, 0.0, &s); e;
        aPoint = numericFn.create("point", "pt",
                                                          aPointX,
                                                          aPointY,
                                                          aPointZ, &s); e;

        // aArrow1Angle
        aArrow1Angle = unitFn.create("arrow1Angle", "a1a",
                                                                 MFnUnitAttribute::kAngle, 0.0, &s); e;

        // aArrow2Direction
        aArrow2DirectionX = numericFn.create("arrow2DirectionX", "a2x",
                                                                                 MFnNumericData::kDouble, 1.0, &s); e;
        aArrow2DirectionY = numericFn.create("arrow2DirectionY", "a2y",
                                                                                 MFnNumericData::kDouble, 0.0, &s); e;
        aArrow2DirectionZ = numericFn.create("arrow2DirectionZ", "a2z",
                                                                                 MFnNumericData::kDouble, 0.0, &s); e;
        aArrow2Direction = numericFn.create("arrow2Direction", "dir",
                                                                                aArrow2DirectionX,
                                                                                aArrow2DirectionY,
                                                                                aArrow2DirectionZ, &s); e;

        // aArrow3Angle
        aArrow3Angle = unitFn.create("arrow3Angle", "a3a",
                                                                 MFnUnitAttribute::kAngle, 0.0, &s); e;
        // aArrow4Distance
        aArrow4Distance = unitFn.create("arrow2Distance", "dis",
                                                                        MFnUnitAttribute::kDistance, 0.0, &s); e;

        // aState;
        aState = numericFn.create("state", "s",
                                                          MFnNumericData::kLong, 0, &s); e;

        // aToggle;
        aToggle = numericFn.create("toggle", "t",
                                                           MFnNumericData::kBoolean, false, &s); e;

        s = addAttribute(aPoint); e;
        s = addAttribute(aArrow1Angle); e;
        s = addAttribute(aArrow2Direction); e;
        s = addAttribute(aArrow3Angle); e;
        s = addAttribute(aArrow4Distance); e;
        s = addAttribute(aState); e;
        s = addAttribute(aToggle); e;

        stat = addAttribute(aSize);
        if (!stat) {
                stat.perror("addAttribute");
                return stat;
        }

        MPxManipContainer::addToManipConnectTable(id);

        return MS::kSuccess;
}


//
// Draw override class for drawing manip in VP2.0
//
class swissArmyLocatorOverride : public MHWRender::MPxDrawOverride
{
public:
        static MHWRender::MPxDrawOverride* Creator(const MObject& obj)
        {
                return new swissArmyLocatorOverride(obj);
        }

        virtual ~swissArmyLocatorOverride();

        virtual MHWRender::DrawAPI supportedDrawAPIs() const;

    virtual bool isBounded(
        const MDagPath& objPath,
        const MDagPath& cameraPath) const;

        virtual MBoundingBox boundingBox(
                const MDagPath& objPath,
                const MDagPath& cameraPath) const;

        virtual MUserData* prepareForDraw(
                const MDagPath& objPath,
                const MDagPath& cameraPath,
                const MHWRender::MFrameContext& frameContext,
                MUserData* oldData);

        static void draw(
                const MHWRender::MDrawContext& context,
                const MUserData* data);

private:
        swissArmyLocatorOverride(const MObject& obj);
};

class swissArmyLocatorData : public MUserData
{
public:
        swissArmyLocatorData() : MUserData(false) {} // don't delete after draw
        virtual ~swissArmyLocatorData() {}
        swissArmyLocator::DrawData drawData;
        float color[4];
};

swissArmyLocatorOverride::swissArmyLocatorOverride(const MObject& obj)
: MHWRender::MPxDrawOverride(obj, swissArmyLocatorOverride::draw)
{
}

swissArmyLocatorOverride::~swissArmyLocatorOverride()
{
}

MHWRender::DrawAPI swissArmyLocatorOverride::supportedDrawAPIs() const
{
        return MHWRender::kOpenGL;
}

bool swissArmyLocatorOverride::isBounded(
        const MDagPath& objPath,
        const MDagPath& cameraPath) const
{
        return true;
}

MBoundingBox swissArmyLocatorOverride::boundingBox(
        const MDagPath& objPath,
        const MDagPath& cameraPath) const
{
        MStatus status;
        MFnDependencyNode node(objPath.node(), &status);
        if (!status) return MBoundingBox();
        swissArmyLocator* swissNode =
                dynamic_cast<swissArmyLocator*>(node.userNode());
        if (!swissNode) return MBoundingBox();
        return swissNode->boundingBox();
}

MUserData* swissArmyLocatorOverride::prepareForDraw(
        const MDagPath& objPath,
        const MDagPath& cameraPath,
        const MHWRender::MFrameContext& frameContext,
        MUserData* oldData)
{
        // get the node
        MStatus status;
        MFnDependencyNode node(objPath.node(), &status);
        if (!status) return NULL;
        swissArmyLocator* swissNode =
                dynamic_cast<swissArmyLocator*>(node.userNode());
        if (!swissNode) return NULL;

        // access/create user data for draw callback
        swissArmyLocatorData* data =
                dynamic_cast<swissArmyLocatorData*>(oldData);
        if (!data)
        {
                data = new swissArmyLocatorData();
        }

        // compute data and cache it
        swissNode->getDrawData(data->drawData);
    MColor color = MHWRender::MGeometryUtilities::wireframeColor(objPath);
        data->color[0] = color.r;
        data->color[1] = color.g;
        data->color[2] = color.b;
        data->color[3] = 1.0f;

        return data;
}

void swissArmyLocatorOverride::draw(
        const MHWRender::MDrawContext& context,
        const MUserData* data)
{
        // data
        MStatus status;
        MHWRender::MStateManager* stateMgr = context.getStateManager();
        const swissArmyLocatorData* locatorData =
                dynamic_cast<const swissArmyLocatorData*>(data);
        if (!stateMgr || !locatorData) return;

        // matrices
        const MMatrix transform =
                context.getMatrix(MHWRender::MFrameContext::kWorldViewMtx, &status);
        if (status != MStatus::kSuccess) return;
        const MMatrix projection =
                context.getMatrix(MHWRender::MFrameContext::kProjectionMtx, &status);
        if (status != MStatus::kSuccess) return;

        // do drawing of outline only for now
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadMatrixd(transform.matrix[0]);
        glMatrixMode(GL_PROJECTION);
        glPushMatrix();
        glLoadMatrixd(projection.matrix[0]);

        glPushAttrib(GL_CURRENT_BIT);
        glColor4fv(locatorData->color);
        swissArmyLocator::drawOutline(locatorData->drawData);
        glPopAttrib();

        glPopMatrix();
        glMatrixMode(GL_MODELVIEW);
        glPopMatrix();
}


//
//      Entry points
//
MStatus initializePlugin(MObject obj)
{
        MStatus status;
        MFnPlugin plugin(obj, PLUGIN_COMPANY, "6.0", "Any");

        status = plugin.registerNode("swissArmyLocator",
                                                                 swissArmyLocator::id,
                                                                 &swissArmyLocator::creator,
                                                                 &swissArmyLocator::initialize,
                                                                 MPxNode::kLocatorNode,
                                                                 &swissArmyLocator::classification);
        if (!status) {
                status.perror("registerNode");
                return status;
        }

    status = MHWRender::MDrawRegistry::registerDrawOverrideCreator(
                swissArmyLocator::classification,
                swissArmyLocator::registrantId,
                swissArmyLocatorOverride::Creator);
        if (!status) {
                status.perror("registerDrawOverrideCreator");
                return status;
        }

    status = plugin.registerNode("swissArmyLocatorManip",
                                                                 swissArmyLocatorManip::id,
                                                                 &swissArmyLocatorManip::creator,
                                                                 &swissArmyLocatorManip::initialize,
                                                                 MPxNode::kManipContainer);
    if (!status) {
        status.perror("registerNode");
        return status;
    }

        return status;
}


MStatus uninitializePlugin(MObject obj)
{
        MStatus status;
        MFnPlugin plugin(obj);

        status = plugin.deregisterNode(swissArmyLocator::id);
        if (!status) {
                status.perror("deregisterNode");
                return status;
        }

        status = MHWRender::MDrawRegistry::deregisterDrawOverrideCreator(
                swissArmyLocator::classification,
                swissArmyLocator::registrantId);
        if (!status) {
                status.perror("deregisterDrawOverrideCreator");
                return status;
        }

        status = plugin.deregisterNode(swissArmyLocatorManip::id);
        if (!status) {
                status.perror("deregisterNode");
                return status;
        }

        return status;
}