//-
// ==========================================================================
// Copyright 2012 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.
// ==========================================================================
//+

// Plugin: uiDrawManager.cpp

// This plugin demonstrates the use of MUIDrawManager.
//
// It provides the 'uiDrawManager' node which uses MUIDrawManager to display 3D (world coordinates) 
// or 2D (screen coordinates) primitives such as text, lines, spheres, etc, based on values set 
// on its attributes.
//
// For example, to draw a 2D, 15x30 pixel rectangle in the viewport, centered on pixel position 
// (50, 20) and tilted at a 45 degree angle, you would do the following:
// createNode -n testo uiDrawManager;
// setAttr testo.draw2D true;
// setAttr testo.rectScale -type double 2 15 30;
// setAttr testo.position -type double 3 50 20 0;
// setAttr testo.rectUp -type double3 1 1 0;

#include <maya/MPxLocatorNode.h>
#include <maya/MFnPlugin.h>
#include <maya/MFnEnumAttribute.h>
#include <maya/MFnNumericAttribute.h>
#include <maya/MFnTypedAttribute.h>
#include <maya/MFnStringData.h>
#include <maya/MFnPointArrayData.h>
#include <maya/MPointArray.h>
#include <maya/MUintArray.h>

// Viewport 2.0 includes
#include <maya/MDrawRegistry.h>
#include <maya/MPxDrawOverride.h>
#include <maya/MUserData.h>
#include <algorithm>

using namespace MHWRender;

class uiDrawManager : public MPxLocatorNode
{
public:
	enum EuiType {
		kText,
		kLine,
		kPoint,
		kRect,
		kQuad,
		kSphere,
		kCircle,		
		kArc,		
	};

public:
	uiDrawManager();
	virtual ~uiDrawManager();

	static void*			creator();
	static MStatus			initialize();

	// ui type attribute
	static MObject			aUIType;

	// color
	static MObject			aPrimitiveColor;
	static MObject			aPrimitiveTransparency;

	// line width and line style attributes	
	static MObject			aLineWidth;
	static MObject			aLineStyle;

	// fill attribute
	static MObject			aIsFilled;

	// radius attribute
	static MObject			aRadius;

	// 2D attributes
	static MObject			aDraw2D;
	static MObject			aPosition;

	// Text attributes
	static MObject			aTextAlignment;
	static MObject			aTextBoxSize;
	static MObject			aText;	
	static MObject			aTextBoxColor;
	static MObject			aTextBoxTransparency;
	static MObject			aTextFontSize;
	static MObject			aFontFaceName;

	// point attributes
	static MObject			aPointSize;

	// line attributes
	static MObject			aLineStartPoint;
	static MObject			aLineEndPoint;

	// rect attributes
	static MObject			aRectUp;
	static MObject			aRectNormal;
	static MObject			aRectScale;

	// quad attributes
	static MObject			aQuadVertex[4];

	// circle attributes
	static MObject			aCircleNormal;

	// arc attributes
	static MObject			aArcStart;
	static MObject			aArcEnd;
	static MObject			aArcNormal;
public:
	static	MTypeId		id;
	static	MString		drawDbClassification;
	static	MString		drawRegistrantId;
};

MObject uiDrawManager::aUIType;

MObject uiDrawManager::aPrimitiveColor;
MObject uiDrawManager::aPrimitiveTransparency;

MObject uiDrawManager::aLineWidth;
MObject uiDrawManager::aLineStyle;

MObject uiDrawManager::aIsFilled;

MObject uiDrawManager::aRadius;

MObject uiDrawManager::aDraw2D;
MObject uiDrawManager::aPosition;

MObject uiDrawManager::aTextAlignment;
MObject uiDrawManager::aTextBoxSize;
MObject uiDrawManager::aText;
MObject uiDrawManager::aTextBoxColor;
MObject uiDrawManager::aTextBoxTransparency;
MObject uiDrawManager::aTextFontSize;
MObject uiDrawManager::aFontFaceName;

MObject uiDrawManager::aPointSize;

MObject uiDrawManager::aLineStartPoint;
MObject uiDrawManager::aLineEndPoint;

MObject	uiDrawManager::aRectUp;
MObject	uiDrawManager::aRectNormal;
MObject	uiDrawManager::aRectScale;

MObject uiDrawManager::aQuadVertex[4];

MObject	uiDrawManager::aCircleNormal;

MObject	uiDrawManager::aArcStart;
MObject	uiDrawManager::aArcEnd;
MObject	uiDrawManager::aArcNormal;

MTypeId uiDrawManager::id(0x0008002A);
MString	uiDrawManager::drawDbClassification("drawdb/geometry/uiDrawManager");
MString	uiDrawManager::drawRegistrantId("uiDrawManagerPlugin");

uiDrawManager::uiDrawManager() {}

uiDrawManager::~uiDrawManager() {}

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


//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Viewport 2.0 override implementation
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
class uiDrawManagerData : public MUserData 
{
public:
	uiDrawManagerData();
	virtual ~uiDrawManagerData() {};

	uiDrawManager::EuiType fUIType;

	MColor fColor;	

	float fLineWidth;
	MUIDrawManager::LineStyle fLineStyle;

	bool fIsFilled;

	double fRadius;

	bool fDraw2D;

	MPoint fPosition;

	// text
	MString fText;
	unsigned int fTextFontSize;
	unsigned int fFontFaceIndex;
	static MStringArray fFontList;

	MUIDrawManager::TextAlignment fTextAlignment;	
	int fTextBoxWidth;
	int fTextBoxHeight;	
	MColor fTextBoxColor;

	// point
	float fPointSize;

	// line
	MPoint fLineStartPoint;
	MPoint fLineEndPoint;

	// rect
	MVector fRectUp;
	MVector fRectNormal;
	double fRectScaleX;
	double fRectScaleY;

	// quad
	MPoint fQuadVertex[4];

	// circle
	MVector fCircleNormal;

	// arc
	MVector fArcStart;
	MVector fArcEnd;
	MVector fArcNormal;
};

MStringArray uiDrawManagerData::fFontList;

uiDrawManagerData::uiDrawManagerData() : MUserData(false) 
	, fUIType(uiDrawManager::kText)
	, fColor(1.0f, 0.0f, 0.0f, 1.0f)	
	, fLineWidth(2.0f)
	, fLineStyle(MUIDrawManager::kSolid)	
	, fIsFilled(false)
	, fRadius(1.0)
	, fDraw2D(false)
	, fPosition(0.0, 0.0, 0.001)
	// text
	, fText("uiDrawManager-Text")
	, fTextFontSize(MUIDrawManager::kDefaultFontSize)
	, fFontFaceIndex(0)
	, fTextAlignment(MUIDrawManager::kLeft)
	, fTextBoxWidth(0)
	, fTextBoxHeight(0)
	, fTextBoxColor(0.0f, 1.0f, 1.0f, 1.0f)	
	// point
	, fPointSize(2.0f)
	// line
	, fLineStartPoint(0.0, 0.0, 0.0)
	, fLineEndPoint(1.0, 1.0, 1.0)
	// rect
	, fRectUp(0.0, 1.0, 0.0)
	, fRectNormal(0.0, 0.0, 1.0)
	, fRectScaleX(1.0)
	, fRectScaleY(1.0)	
	// circle
	, fCircleNormal(0.0, 0.0, 1.0)
	// arc
	, fArcStart(1.0, 0.0, 0.0)
	, fArcEnd(0.0, 1.0, 0.0)
	, fArcNormal(0.0, 0.0, 1.0)
{
	// quad
	fQuadVertex[0] = MPoint(0.0, 0.0, 0.0);
	fQuadVertex[1] = MPoint(1.0, 0.0, 0.0);
	fQuadVertex[2] = MPoint(1.0, 1.0, 0.0);
	fQuadVertex[3] = MPoint(0.0, 1.0, 0.0);

}

class uiDrawManagerDrawOverride : public MPxDrawOverride
{
public:
	static MPxDrawOverride* Creator(const MObject& obj)
	{
		return new uiDrawManagerDrawOverride(obj);
	}

	virtual ~uiDrawManagerDrawOverride();

	virtual 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 MFrameContext& frameContext,
		MUserData* oldData);

	virtual bool hasUIDrawables() const { return true; }

	virtual void addUIDrawables(
		const MDagPath& objPath,
		MHWRender::MUIDrawManager& drawManager,
		const MHWRender::MFrameContext& frameContext,
		const MUserData* data);

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

protected:

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

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

uiDrawManagerDrawOverride::~uiDrawManagerDrawOverride()
{
}

DrawAPI uiDrawManagerDrawOverride::supportedDrawAPIs() const
{
	// this plugin supports both GL and DX
	return (kOpenGL | kDirectX11);
}

bool uiDrawManagerDrawOverride::isBounded(const MDagPath& /*objPath*/,
	const MDagPath& /*cameraPath*/) const
{
	return false;
}

MBoundingBox uiDrawManagerDrawOverride::boundingBox(
	const MDagPath& objPath,
	const MDagPath& cameraPath) const
{
	return MBoundingBox();
}

MUserData* uiDrawManagerDrawOverride::prepareForDraw(
	const MDagPath& objPath,
	const MDagPath& cameraPath,
	const MHWRender::MFrameContext& frameContext,
	MUserData* oldData)
{
	uiDrawManagerData* data = dynamic_cast<uiDrawManagerData*>(oldData);
	if (!data) {
		data = new uiDrawManagerData();
	}

	MStatus status;
	MObject uiDrawManagerNode = objPath.node(&status);
	if (status) {
		// retrieve uiType
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aUIType);
			data->fUIType = (uiDrawManager::EuiType)plug.asShort();
		}

		// common attributes
		// retrieve color
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aPrimitiveColor);
			MObject o = plug.asMObject();
			MFnNumericData nData(o);
			nData.getData(data->fColor.r, data->fColor.g, data->fColor.b);			
		}

		// retrieve transparency
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aPrimitiveTransparency);
			data->fColor.a = 1.0f - plug.asFloat();
		}
		
		// retrieve line width
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aLineWidth);
			data->fLineWidth = plug.asFloat();
		}

		// retrieve line style
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aLineStyle);
			data->fLineStyle = (MUIDrawManager::LineStyle)plug.asShort();
		}
		
		// retrieve filled flag		
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aIsFilled);
			data->fIsFilled = plug.asBool();
		}

		// retrieve radius
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aRadius);
			data->fRadius = plug.asDouble();
		}

		// retrieve 2D flag
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aDraw2D);
			data->fDraw2D = plug.asBool();
		}

		// retrieve screen position
		{
			MPlug plug(uiDrawManagerNode, uiDrawManager::aPosition);
			MObject o = plug.asMObject();
			MFnNumericData nData(o);				
			nData.getData(data->fPosition.x, data->fPosition.y, data->fPosition.z);
			data->fPosition.w = 1.0f;
		}

		switch (data->fUIType) 
		{
		case uiDrawManager::kText:
			// retrieve text
			{		
				MPlug plug(uiDrawManagerNode, uiDrawManager::aText);
				data->fText = plug.asString();
			}	

			// retrieve text font size
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aTextFontSize);
				data->fTextFontSize = std::max(plug.asInt(), 0);			
			}

			// retrieve font face index
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aFontFaceName);
				data->fFontFaceIndex = (unsigned int)plug.asInt();
			}

			// retrieve text alignment
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aTextAlignment);
				data->fTextAlignment = (MUIDrawManager::TextAlignment)plug.asShort();
			}		

			// retrieve text box size
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aTextBoxSize);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);			
				nData.getData(data->fTextBoxWidth, data->fTextBoxHeight);			
			}		

			// retrieve text box color
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aTextBoxColor);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);
				nData.getData(data->fTextBoxColor.r, data->fTextBoxColor.g, data->fTextBoxColor.b);				
			}

			// retrieve text box transparency
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aTextBoxTransparency);
				data->fTextBoxColor.a = 1.0f - plug.asFloat();
			}
			break;			

		case uiDrawManager::kPoint:
			// retrieve point size
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aPointSize);
				data->fPointSize = plug.asFloat();
			}

			break;

		case uiDrawManager::kLine:
			// retrieve line start point
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aLineStartPoint);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fLineStartPoint.x, data->fLineStartPoint.y, data->fLineStartPoint.z);
				data->fLineStartPoint.w = 1.0f;
			}

			// retrieve line end point
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aLineEndPoint);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fLineEndPoint.x, data->fLineEndPoint.y, data->fLineEndPoint.z);
				data->fLineEndPoint.w = 1.0f;
			}

			break;

		case uiDrawManager::kRect:
			// retrieve rect up vector
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aRectUp);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fRectUp.x, data->fRectUp.y, data->fRectUp.z);				
			}

			// retrieve rect normal vector
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aRectNormal);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fRectNormal.x, data->fRectNormal.y, data->fRectNormal.z);		
			}

			// retrieve rect scale
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aRectScale);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fRectScaleX, data->fRectScaleY);
			}

			break;

		case uiDrawManager::kQuad:
			// retrieve quad vertices
			{
				for (int i = 0; i < 4; ++i)
				{
					MPlug plug(uiDrawManagerNode, uiDrawManager::aQuadVertex[i]);
					MObject o = plug.asMObject();
					MFnNumericData nData(o);
					nData.getData(data->fQuadVertex[i].x, data->fQuadVertex[i].y, data->fQuadVertex[i].z);
				}
			}

			break;

		case uiDrawManager::kCircle:
			// retrieve circle normal
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aCircleNormal);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fCircleNormal.x, data->fCircleNormal.y, data->fCircleNormal.z);	
			}

			break;

		case uiDrawManager::kArc:
			// retrieve arc start vector
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aArcStart);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fArcStart.x, data->fArcStart.y, data->fArcStart.z);
			}

			// retrieve arc end vector
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aArcEnd);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fArcEnd.x, data->fArcEnd.y, data->fArcEnd.z);	
			}

			// retrieve arc normal
			{
				MPlug plug(uiDrawManagerNode, uiDrawManager::aArcNormal);
				MObject o = plug.asMObject();
				MFnNumericData nData(o);				
				nData.getData(data->fArcNormal.x, data->fArcNormal.y, data->fArcNormal.z);	
			}

			break;

		case uiDrawManager::kSphere:
			break;

		default:
			perror("unhandled ui type.");
			break;
		}			
	}

	return data;
}

void uiDrawManagerDrawOverride::addUIDrawables(
	const MDagPath& objPath,
	MHWRender::MUIDrawManager& drawManager,
	const MHWRender::MFrameContext& frameContext,
	const MUserData* data)
{
	const uiDrawManagerData* thisdata = dynamic_cast<const uiDrawManagerData*>(data);
	if (!thisdata) {
		return;
	}

	switch (thisdata->fUIType) 
	{
	case uiDrawManager::kText: 
		{
			// Draw a text "uiDrawManager"
			// All drawing operations must take place between calls to beginDrawable()
			// and endDrawable().
			drawManager.beginDrawable();

			drawManager.setColor(thisdata->fColor);
			drawManager.setFontSize(thisdata->fTextFontSize);

			MString faceName = uiDrawManagerData::fFontList[thisdata->fFontFaceIndex];
			drawManager.setFontName(faceName);
			int boxSize[] = { thisdata->fTextBoxWidth, thisdata->fTextBoxHeight };
			if (thisdata->fDraw2D) {
				// uiDrawManagerData::fPosition gives a screen space position 
				// where 2D UI item is located.				
				drawManager.text2d(thisdata->fPosition, thisdata->fText, thisdata->fTextAlignment, 
					boxSize[0]+boxSize[1] == 0 ? NULL : boxSize, &thisdata->fTextBoxColor, false);
			}
			else {
				// for 3D items, place it at the origin of the world space.
				drawManager.text(thisdata->fPosition, thisdata->fText, thisdata->fTextAlignment, 
					boxSize[0]+boxSize[1] == 0 ? NULL : boxSize, &thisdata->fTextBoxColor, false);
			}			

			drawManager.endDrawable();
		}
		break;

	case uiDrawManager::kLine:
		{
			drawManager.beginDrawable();

			drawManager.setColor(thisdata->fColor);
			drawManager.setLineWidth(thisdata->fLineWidth);
			drawManager.setLineStyle(thisdata->fLineStyle);
			if (thisdata->fDraw2D) {
				drawManager.line2d(thisdata->fLineStartPoint, thisdata->fLineEndPoint);
			}
			else {
				drawManager.line(thisdata->fLineStartPoint, thisdata->fLineEndPoint);
			}

			drawManager.endDrawable();
		}
		break;

	case uiDrawManager::kPoint:
		{
			drawManager.beginDrawable();

			drawManager.setColor(thisdata->fColor);
			drawManager.setPointSize(thisdata->fPointSize);
			if (thisdata->fDraw2D) {
				drawManager.point2d(thisdata->fPosition);
			}
			else {
				drawManager.point(thisdata->fPosition);
			}		

			drawManager.endDrawable();
		}
		break;

	case uiDrawManager::kRect:
		{
			drawManager.beginDrawable();

			drawManager.setColor(thisdata->fColor);
			drawManager.setLineWidth(thisdata->fLineWidth);
			drawManager.setLineStyle(thisdata->fLineStyle);
			if (thisdata->fDraw2D) {
				// For 2d rectangle, an up vector in screen space is used to determine its X 
				// and Y directions. In addition, "fRectScaleX" and "fRectScaleY"(in pixels)
				// specify the half-lengths of the 2d rectangle.
				drawManager.rect2d(thisdata->fPosition, thisdata->fRectUp,
					thisdata->fRectScaleX, thisdata->fRectScaleY, thisdata->fIsFilled);
			}
			else {
				// For 3d rectangle, the up vector should not be parallel with the normal vector.
				drawManager.rect(thisdata->fPosition, thisdata->fRectUp, thisdata->fRectNormal,
					thisdata->fRectScaleX, thisdata->fRectScaleY, thisdata->fIsFilled);
			}

			drawManager.endDrawable();
		}
		break;

	case uiDrawManager::kQuad:
		{
			drawManager.beginDrawable();

			drawManager.setColor(thisdata->fColor);
			drawManager.setLineWidth(thisdata->fLineWidth);
			drawManager.setLineStyle(thisdata->fLineStyle);

			// prepare primitive type
			MUIDrawManager::Primitive mode = 
				thisdata->fIsFilled ? MUIDrawManager::kTriStrip : MUIDrawManager::kClosedLine;
			// prepare position list
			MPointArray position;
			for (int i = 0; i < 4; ++i) {
				position.append(thisdata->fQuadVertex[i]);
			}
			// prepare index
			MUintArray index;
			index.append(0);
			index.append(1);
			index.append(3);
			index.append(2);			

			// draw mesh
			if (thisdata->fDraw2D) {
				drawManager.mesh2d(mode, position, NULL, thisdata->fIsFilled ? &index : NULL);
			}
			else {
				drawManager.mesh(mode, position, NULL, NULL, thisdata->fIsFilled ? &index : NULL);
			}

			drawManager.endDrawable();
		}
		break;

	case uiDrawManager::kSphere:
		{
			drawManager.beginDrawable();

			drawManager.setColor(thisdata->fColor);
			drawManager.setLineWidth(thisdata->fLineWidth);
			drawManager.setLineStyle(thisdata->fLineStyle);
			drawManager.sphere(thisdata->fPosition, thisdata->fRadius, thisdata->fIsFilled);

			drawManager.endDrawable();
		}
		break;

	case uiDrawManager::kCircle:
		{
			drawManager.beginDrawable();

			drawManager.setColor(thisdata->fColor);
			drawManager.setLineWidth(thisdata->fLineWidth);
			drawManager.setLineStyle(thisdata->fLineStyle);
			if (thisdata->fDraw2D) {
				// The radius in specified as pixel unit for 2d items.
				drawManager.circle2d(thisdata->fPosition, thisdata->fRadius, 
					thisdata->fIsFilled);
			}
			else {
				drawManager.circle(thisdata->fPosition, thisdata->fCircleNormal, thisdata->fRadius, 
					thisdata->fIsFilled);
			}

			drawManager.endDrawable();
		}
		break;

	case uiDrawManager::kArc:
		{
			drawManager.beginDrawable();

			drawManager.setColor(thisdata->fColor);
			drawManager.setLineWidth(thisdata->fLineWidth);
			drawManager.setLineStyle(thisdata->fLineStyle);
			if (thisdata->fDraw2D) {
				// If 2d, the range of the arc is defined by the start and end vectors 
				// specified in screen space.
				drawManager.arc2d(thisdata->fPosition, thisdata->fArcStart, thisdata->fArcEnd, 
					thisdata->fRadius, thisdata->fIsFilled);
			}
			else {
				// For 3d arc, the projections of the start and end vectors onto the arc plane(
				// determined by the normal vector) determine the range of the arc.
				drawManager.arc(thisdata->fPosition, thisdata->fArcStart, thisdata->fArcEnd, 
					thisdata->fArcNormal, thisdata->fRadius, thisdata->fIsFilled);
			}

			drawManager.endDrawable();
		}
		break;

	default:
		perror("unhandled ui types.");
		break;
	}
	
}

void uiDrawManagerDrawOverride::draw(const MHWRender::MDrawContext& context, const MUserData* data)
{

}

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Plugin Registration
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

MStatus uiDrawManager::initialize()
{
	MStatus status;

	MFnNumericAttribute nAttr;
	MFnEnumAttribute eAttr;
	MFnTypedAttribute typedAttr;

	// Add ui type attribute
	aUIType = eAttr.create("uiType", "ut", uiDrawManager::kText);
	eAttr.addField("text", uiDrawManager::kText);
	eAttr.addField("line", uiDrawManager::kLine);
	eAttr.addField("point", uiDrawManager::kPoint);
	eAttr.addField("rect", uiDrawManager::kRect);	
	eAttr.addField("quad", uiDrawManager::kQuad);
	eAttr.addField("sphere", uiDrawManager::kSphere);
	eAttr.addField("circle", uiDrawManager::kCircle);	
	eAttr.addField("arc", uiDrawManager::kArc);	
	MPxNode::addAttribute(aUIType);
	
	// Add color attribute
	aPrimitiveColor = nAttr.create("primitiveColor", "pc", MFnNumericData::k3Float);
	nAttr.setDefault(1.0f, 0.0f, 0.0f);
	nAttr.setUsedAsColor(true);
	MPxNode::addAttribute(aPrimitiveColor);

	// Add transparency attribute
	aPrimitiveTransparency = nAttr.create("primitiveTransparency", "pt", MFnNumericData::kFloat, 0.0);
	nAttr.setSoftMin(0.0);
	nAttr.setSoftMax(1.0);	
	MPxNode::addAttribute(aPrimitiveTransparency);

	// add line width and line style attributes
	aLineWidth = nAttr.create("lineWidth", "lw", MFnNumericData::kFloat, 2.0);
	MPxNode::addAttribute(aLineWidth);

	aLineStyle = eAttr.create("lineStyle", "ls", MUIDrawManager::kSolid);
	eAttr.addField("solid", MUIDrawManager::kSolid);
	eAttr.addField("shortdotted", MUIDrawManager::kShortDotted);
	eAttr.addField("shortdashed", MUIDrawManager::kShortDashed);
	eAttr.addField("dashed", MUIDrawManager::kDashed);
	eAttr.addField("dotted", MUIDrawManager::kDotted);
	MPxNode::addAttribute(aLineStyle);

	// Add filled attribute
	aIsFilled = nAttr.create("isFilled", "if", MFnNumericData::kBoolean, 0);	
	MPxNode::addAttribute(aIsFilled);

	// Add radius attribute
	aRadius = nAttr.create("radius", "ra", MFnNumericData::kDouble, 1.0);
	MPxNode::addAttribute(aRadius);

	// add 2D attributes
	aDraw2D = nAttr.create("draw2D", "d2", MFnNumericData::kBoolean, 0);
	MPxNode::addAttribute(aDraw2D);

	aPosition = nAttr.create("position", "pos", MFnNumericData::k3Double);
	nAttr.setDefault(0.0, 0.0, 0.001);
	MPxNode::addAttribute(aPosition);
	
	// Add text attributes.
	MFnStringData stringFn;
	MObject defaultText = stringFn.create("uiDrawManager-Text");
	aText = typedAttr.create("text", "t", MFnData::kString, defaultText);
	MPxNode::addAttribute(aText);	

	aTextFontSize = nAttr.create("textFontSize", "tfs", MFnNumericData::kInt, MUIDrawManager::kDefaultFontSize);
	nAttr.setMin(-1);
	nAttr.setMax(99);	
	MPxNode::addAttribute(aTextFontSize);

	unsigned int nFont = MUIDrawManager::getFontList(uiDrawManagerData::fFontList);
	if (nFont == 0)
	{
		perror("No font available!");
	}
	aFontFaceName = eAttr.create("fontFaceName", "ffn", 0);
	for (unsigned int i = 0; i < nFont; i++)
	{
		MString str = uiDrawManagerData::fFontList[i];
		eAttr.addField(str, (short)i);
	}
	MPxNode::addAttribute(aFontFaceName);

	aTextAlignment = eAttr.create("textAlignment", "ta", MUIDrawManager::kLeft);
	eAttr.addField("left", MUIDrawManager::kLeft);
	eAttr.addField("center", MUIDrawManager::kCenter);
	eAttr.addField("right", MUIDrawManager::kRight);
	MPxNode::addAttribute(aTextAlignment);	

	aTextBoxSize = nAttr.create("textBoxSize", "tbs", MFnNumericData::k2Int);
	nAttr.setDefault(0, 0);
	MPxNode::addAttribute(aTextBoxSize);

	aTextBoxColor = nAttr.create("textBoxColor", "tbc", MFnNumericData::k3Float);
	nAttr.setDefault(0.0f, 1.0f, 1.0f);
	nAttr.setUsedAsColor(true);
	MPxNode::addAttribute(aTextBoxColor);

	aTextBoxTransparency = nAttr.create("textBoxTransparency", "tbt", MFnNumericData::kFloat, 0.0);
	nAttr.setSoftMin(0.0);
	nAttr.setSoftMax(1.0);	
	MPxNode::addAttribute(aTextBoxTransparency);
	
	// add point attributes
	aPointSize = nAttr.create("pointSize", "ps", MFnNumericData::kFloat, 2.0);
	MPxNode::addAttribute(aPointSize);

	// add line attributes
	aLineStartPoint = nAttr.create("lineStartPoint", "lsp", MFnNumericData::k3Double);
	nAttr.setDefault(0.0, 0.0, 0.0);
	MPxNode::addAttribute(aLineStartPoint);

	aLineEndPoint = nAttr.create("lineEndPoint", "lep", MFnNumericData::k3Double);
	nAttr.setDefault(1.0, 1.0, 1.0);
	MPxNode::addAttribute(aLineEndPoint);
	
	// add rect attributes
	aRectUp = nAttr.create("rectUp", "ru", MFnNumericData::k3Double);
	nAttr.setDefault(0.0, 1.0, 0.0);
	MPxNode::addAttribute(aRectUp);

	aRectNormal = nAttr.create("rectNormal", "rn", MFnNumericData::k3Double);
	nAttr.setDefault(0.0, 0.0, 1.0);
	MPxNode::addAttribute(aRectNormal);

	aRectScale = nAttr.create("rectScale", "rs", MFnNumericData::k2Double);
	nAttr.setDefault(1.0, 1.0);
	MPxNode::addAttribute(aRectScale);

	// add quad attributes
	double defaultPosition[4][3] = 
	{
		{0.0, 0.0, 0.0},
		{1.0, 0.0, 0.0},
		{1.0, 1.0, 0.0},
		{0.0, 1.0, 0.0}
	};
	for (int i = 0; i < 4;  ++i)
	{
		MString fullName = "quadVertex";
		MString shortName = "qv";
		aQuadVertex[i] = nAttr.create(fullName + i, shortName + i, MFnNumericData::k3Double);
		nAttr.setDefault(defaultPosition[i][0], defaultPosition[i][1], defaultPosition[i][2]);
		MPxNode::addAttribute(aQuadVertex[i]);
	}
	
	// add circle attributes
	aCircleNormal = nAttr.create("circleNormal", "cn", MFnNumericData::k3Double);
	nAttr.setDefault(0.0, 0.0, 1.0);
	MPxNode::addAttribute(aCircleNormal);

	// add arc attributes
	aArcStart = nAttr.create("arcStartVector", "asv", MFnNumericData::k3Double);
	nAttr.setDefault(1.0, 0.0, 0.0);
	MPxNode::addAttribute(aArcStart);

	aArcEnd = nAttr.create("arcEndVector", "aev", MFnNumericData::k3Double);
	nAttr.setDefault(0.0, 1.0, 0.0);
	MPxNode::addAttribute(aArcEnd);

	aArcNormal = nAttr.create("arcNormal", "an", MFnNumericData::k3Double);
	nAttr.setDefault(0.0, 0.0, 1.0);
	MPxNode::addAttribute(aArcNormal);

	return MS::kSuccess;
}

MStatus initializePlugin( MObject obj )
{
	MStatus   status;
	MFnPlugin plugin( obj, PLUGIN_COMPANY, "3.0", "Any");

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

	status = MHWRender::MDrawRegistry::registerDrawOverrideCreator(
		uiDrawManager::drawDbClassification,
		uiDrawManager::drawRegistrantId,
		uiDrawManagerDrawOverride::Creator);
	if (!status) {
		status.perror("registerDrawOverrideCreator");
		return status;
	}

	return status;
}

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

	status = MDrawRegistry::deregisterGeometryOverrideCreator(
		uiDrawManager::drawDbClassification,
		uiDrawManager::drawRegistrantId);
	if (!status) {
		status.perror("deregisterGeometryOverrideCreator");
		return status;
	}

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

	return status;
}