#include <windows.h>
#include <GL/glu.h>

#include <math.h>

#include <radmath/radmath.hpp>
 
#include "nodes/treelineshapenode.h"
#include "utility/mext.h"
#include "utility/mui.h"
#include "main/shapeconstants.h"
#include "main/constants.h"
#include "main/trackeditor.h"

namespace TETreeLine
{

#define DORMANT_VERTEX_COLOR	8	// purple
#define ACTIVE_VERTEX_COLOR		16	// yellow

// Vertex point size
//
#define POINT_SIZE				2.0	

void SetQuadricDrawStyle (GLUquadricObj* qobj, int token)
{
    if ((token==SMOOTH_SHADED)||(token==FLAT_SHADED))
    {
        gluQuadricNormals( qobj, GLU_SMOOTH );
        gluQuadricTexture( qobj, true );
        gluQuadricDrawStyle( qobj, GLU_FILL );
    }
    else
    {
        gluQuadricDrawStyle( qobj, GLU_LINE );
    }
}

void p3dBaseShapeUI::getDrawRequestsWireframe( MDrawRequest& request, const MDrawInfo& info )
{
    request.setToken( WIREFRAME );

    M3dView::DisplayStatus displayStatus = info.displayStatus();
    M3dView::ColorTable activeColorTable = M3dView::kActiveColors;
    M3dView::ColorTable dormantColorTable = M3dView::kDormantColors;
    switch ( displayStatus )
    {
        case M3dView::kLead :
            request.setColor( lead_color, activeColorTable );
            break;
        case M3dView::kActive :
            request.setColor( active_color, activeColorTable );
            break;
        case M3dView::kActiveAffected :
            request.setColor( active_affected_color, activeColorTable );
            break;
        case M3dView::kDormant :
            request.setColor( dormant_color, dormantColorTable );
            break;
        case M3dView::kHilite :
            request.setColor( hilite_color, activeColorTable );
            break;
    }
}

void p3dBaseShapeUI::getDrawRequestsShaded( MDrawRequest& request, const MDrawInfo& info,
                                                          MDrawRequestQueue& queue, MDrawData& data )
{
    // Need to get the material info
    //
    MDagPath path = info.multiPath();   // path to your dag object 
    M3dView view = info.view();;     // view to draw to
    MMaterial material = MPxSurfaceShapeUI::material( path );
    M3dView::DisplayStatus displayStatus = info.displayStatus();

    // Evaluate the material and if necessary, the texture.
    //
    if ( ! material.evaluateMaterial( view, path ) ) 
    {
        MExt::DisplayError( "Could not evaluate\n" );
    }

    if ( material.materialIsTextured() ) 
    {
        material.evaluateTexture( data );
    }

    request.setMaterial( material );

    bool materialTransparent = false;
    material.getHasTransparency( materialTransparent );
    if ( materialTransparent ) 
    {
        request.setIsTransparent( true );
    }
    
    // create a draw request for wireframe on shaded if
    // necessary.
    //
    if ( (displayStatus == M3dView::kActive) ||
         (displayStatus == M3dView::kLead) ||
         (displayStatus == M3dView::kHilite) )
    {
        MDrawRequest wireRequest = info.getPrototype( *this );
        wireRequest.setDrawData( data );
        getDrawRequestsWireframe( wireRequest, info );
        wireRequest.setToken( WIREFRAME_SHADED );
        wireRequest.setDisplayStyle( M3dView::kWireFrame );
        queue.add( wireRequest );
    }
}

/////////////////////////////////////////////////////////////////////
// SHAPE NODE IMPLEMENTATION
/////////////////////////////////////////////////////////////////////
MTypeId TreelineShapeNode::id(TEConstants::NodeIDs::TreeLine);
const char* TreelineShapeNode::stringId = "TreelineShapeNode";

const char* TreelineShapeNode::SHADER_NAME_LONG = "material";
const char* TreelineShapeNode::SHADER_NAME_SHORT = "mt";
MObject TreelineShapeNode::sShader;

const char* TreelineShapeNode::USCALE_NAME_LONG = "uscale";
const char* TreelineShapeNode::USCALE_NAME_SHORT = "us";
MObject TreelineShapeNode::sUScale;

const char* TreelineShapeNode::COLOUR_NAME_LONG = "colour";
const char* TreelineShapeNode::COLOUR_NAME_SHORT = "clr";
MObject TreelineShapeNode::sColour;

const char* TreelineShapeNode::RED_NAME_LONG = "red";
const char* TreelineShapeNode::RED_NAME_SHORT = "r";
MObject TreelineShapeNode::sRed;

const char* TreelineShapeNode::GREEN_NAME_LONG = "green";
const char* TreelineShapeNode::GREEN_NAME_SHORT = "g";
MObject TreelineShapeNode::sGreen;

const char* TreelineShapeNode::BLUE_NAME_LONG = "blue";
const char* TreelineShapeNode::BLUE_NAME_SHORT = "b";
MObject TreelineShapeNode::sBlue;

const char* TreelineShapeNode::ALPHA_NAME_LONG = "alpha";
const char* TreelineShapeNode::ALPHA_NAME_SHORT = "a";
MObject TreelineShapeNode::sAlpha;

const char* TreelineShapeNode::HEIGHT_NAME_LONG = "height";
const char* TreelineShapeNode::HEIGHT_NAME_SHORT = "h";
MObject TreelineShapeNode::sHeight;

TreelineShapeNode::TreelineShapeNode()
{
}

TreelineShapeNode::~TreelineShapeNode()
{
}

//********************************************************************************************
// Description
// 
//    When instances of this node are created internally, the MObject associated
//    with the instance is not created until after the constructor of this class
//    is called. This means that no member functions of MPxSurfaceShape can
//    be called in the constructor.
//    The postConstructor solves this problem. Maya will call this function
//    after the internal object has been created.
//    As a general rule do all of your initialization in the postConstructor.
//********************************************************************************************
void TreelineShapeNode::postConstructor()
{ 
    // This call allows the shape to have shading groups assigned
    setRenderable( true );
}

//********************************************************************************************
// Compute attribute values of the node
//********************************************************************************************
MStatus TreelineShapeNode::compute( const MPlug& plug, MDataBlock& datablock )
{
    return MS::kSuccess;
}

//********************************************************************************************
// Capture when connections are made to this shape
//********************************************************************************************
MStatus TreelineShapeNode::connectionMade ( const MPlug &plug, const MPlug &otherPlug, bool asSrc ) 
{
    MObject shaderObj = otherPlug.node();
    if ( asSrc && shaderObj.hasFn(MFn::kShadingEngine) )
    {
        MFnDependencyNode parentFn( plug.node() );
        MFnDependencyNode shaderFn( shaderObj );

        // connect this material with the chosen object
 
        MStatus status;
        MPlug parentMaterialPlug = parentFn.findPlug( SHADER_NAME_LONG, &status );

        if ( !status )
        {
            MExt::DisplayError( "Could not assign %s to %s", shaderFn.name(), parentFn.name() );
        }
        else
        {
            parentMaterialPlug.setLocked( false );
            parentMaterialPlug.setValue( shaderFn.name() );
            parentMaterialPlug.setLocked( true );
        }
    }

    // let Maya process the connection too
    return MS::kUnknownParameter;
}

//********************************************************************************************
// Create instance of shape
//********************************************************************************************
void* TreelineShapeNode::creator()
{
    return new TreelineShapeNode();
}

//********************************************************************************************
// Create and initialize all attributes in maya
//********************************************************************************************
MStatus TreelineShapeNode::initialize()
{ 
    MStatus              status;
    MFnTypedAttribute    strAttr;
    MFnNumericAttribute  numAttr;
    MFnCompoundAttribute compAttr;

    sShader = strAttr.create( SHADER_NAME_LONG, SHADER_NAME_SHORT, MFnData::kString, &status );
    RETURN_STATUS_ON_FAILURE( status );
    RETURN_STATUS_ON_FAILURE( strAttr.setInternal( false ) );
    RETURN_STATUS_ON_FAILURE( strAttr.setHidden( false ) );
    RETURN_STATUS_ON_FAILURE( strAttr.setKeyable( false ) );
    status = addAttribute( sShader );
    RETURN_STATUS_ON_FAILURE( status );

    sUScale = numAttr.create( USCALE_NAME_LONG, USCALE_NAME_SHORT, MFnNumericData::kDouble, 1.0, &status );
    RETURN_STATUS_ON_FAILURE( status );
    RETURN_STATUS_ON_FAILURE( numAttr.setMin(0.01) );
    RETURN_STATUS_ON_FAILURE( numAttr.setMax(100.0) );
    RETURN_STATUS_ON_FAILURE( strAttr.setInternal( false ) );
    RETURN_STATUS_ON_FAILURE( strAttr.setHidden( false ) );
    RETURN_STATUS_ON_FAILURE( strAttr.setKeyable( true ) );
    status = addAttribute( sUScale );
    RETURN_STATUS_ON_FAILURE( status );

    // Compound colour attribute
    sRed = numAttr.create ( RED_NAME_LONG, RED_NAME_SHORT, MFnNumericData::kFloat, 1.0, &status );
    RETURN_STATUS_ON_FAILURE( status );
    RETURN_STATUS_ON_FAILURE( numAttr.setMin(0.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setMax(1.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setHidden( false ) );
    RETURN_STATUS_ON_FAILURE( numAttr.setKeyable( true ) );
    
    sGreen = numAttr.create ( GREEN_NAME_LONG, GREEN_NAME_SHORT, MFnNumericData::kFloat, 1.0, &status );
    RETURN_STATUS_ON_FAILURE( status );
    RETURN_STATUS_ON_FAILURE( numAttr.setMin(0.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setMax(1.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setHidden( false ) );
    RETURN_STATUS_ON_FAILURE( numAttr.setKeyable( true ) );

    sBlue = numAttr.create ( BLUE_NAME_LONG, BLUE_NAME_SHORT, MFnNumericData::kFloat, 1.0, &status );
    RETURN_STATUS_ON_FAILURE( status );
    RETURN_STATUS_ON_FAILURE( numAttr.setMin(0.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setMax(1.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setHidden( false ) );
    RETURN_STATUS_ON_FAILURE( numAttr.setKeyable( true ) );

    sColour = numAttr.create( COLOUR_NAME_LONG, COLOUR_NAME_SHORT, sRed, sGreen, sBlue, &status );
    RETURN_STATUS_ON_FAILURE( status );
    RETURN_STATUS_ON_FAILURE( numAttr.setKeyable( true ) );
    RETURN_STATUS_ON_FAILURE( numAttr.setUsedAsColor(true) );
    status = addAttribute( sColour );
    RETURN_STATUS_ON_FAILURE( status );

    sAlpha = numAttr.create ( ALPHA_NAME_LONG, ALPHA_NAME_SHORT, MFnNumericData::kFloat, 1.0, &status );
    RETURN_STATUS_ON_FAILURE( status );
    RETURN_STATUS_ON_FAILURE( numAttr.setMin(0.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setMax(1.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setInternal( false ) );
    RETURN_STATUS_ON_FAILURE( numAttr.setHidden( false ) );
    RETURN_STATUS_ON_FAILURE( numAttr.setKeyable( true ) );
    status = addAttribute( sAlpha );
    RETURN_STATUS_ON_FAILURE( status );


    sHeight = numAttr.create( HEIGHT_NAME_LONG, HEIGHT_NAME_SHORT, MFnNumericData::kFloat, 10.0, &status );
    RETURN_STATUS_ON_FAILURE( status );
    RETURN_STATUS_ON_FAILURE( numAttr.setMin(0.1) );
    RETURN_STATUS_ON_FAILURE( numAttr.setMax(100.0) );
    RETURN_STATUS_ON_FAILURE( numAttr.setInternal( false ) );
    RETURN_STATUS_ON_FAILURE( numAttr.setHidden( false ) );
    RETURN_STATUS_ON_FAILURE( numAttr.setKeyable( true ) );
    status = addAttribute( sHeight );

    return MS::kSuccess;
}

//********************************************************************************************
// Returns the bounding box for the shape.
// In this case just use the radius and height attributes
// to determine the bounding box.
//********************************************************************************************
MBoundingBox TreelineShapeNode::boundingBox() const
{
    MBoundingBox  result; 

    MStatus status;
    MObject obj = thisMObject();

    float height = 1.0f;
        
    MFnDagNode dagNodeFn(obj);
    MPlug plug;

    plug = dagNodeFn.findPlug( sHeight, &status );
    plug.getValue( height );

    MPlug vertices = dagNodeFn.findPlug( mControlPoints, &status );
    assert( status );

    unsigned int i;
    for ( i = 0; i < vertices.numElements(); ++i )
    {
        MPoint point;
        MPlug vertex1 = vertices.elementByLogicalIndex( i, &status );
        assert( status );

        MPlug x1 = vertex1.child( mControlValueX, &status );
        assert( status );
        x1.getValue( point.x );

        MPlug y1 = vertex1.child( mControlValueY, &status );
        assert( status );
        y1.getValue( point.y );

        MPlug z1 = vertex1.child( mControlValueZ, &status );
        assert( status );
        z1.getValue( point.z );

        result.expand( point );

        point.y = point.y + ( height * TEConstants::Scale );

        result.expand( point );
    }

    return result;
} 

//=============================================================================
// TreelineShapeNode::componentToPlugs
//=============================================================================
// Description: Comment
//
// Parameters:  ( MObject& component, MSelectionList& selectionList )
//
// Return:      void 
//
//=============================================================================
void TreelineShapeNode::componentToPlugs( MObject& component, 
                                          MSelectionList& selectionList ) const
{
    if ( component.hasFn(MFn::kMeshVertComponent) ) 
    {
        MFnSingleIndexedComponent fnVtxComp( component );
        MObject thisNode = thisMObject();
        MPlug plug( thisNode, mControlPoints );
        int len = fnVtxComp.elementCount();
        for ( int i = 0; i < len; i++ ) 
        {
            MPlug vtxPlug = plug.elementByLogicalIndex( fnVtxComp.element(i) );
            selectionList.add( vtxPlug );
        }
    }
}

//=============================================================================
// TreelineShapeNode::matchComponent
//=============================================================================
// Description: Comment
//
// Parameters:  ( const MSelectionList& item, const MAttributeSpecArray& spec, MSelectionList& list )
//
// Return:      MPxSurfaceShape
//
//=============================================================================
MPxSurfaceShape::MatchResult 
TreelineShapeNode::matchComponent( const MSelectionList& item, 
                                   const MAttributeSpecArray& spec, 
                                   MSelectionList& list )
//
// Description:
//
//    Component/attribute matching method.
//    This method validates component names and indices which are
//    specified as a string and adds the corresponding component
//    to the passed in selection list.
//
//    For instance, select commands such as "select shape1.vtx[0:7]"
//    are validated with this method and the corresponding component
//    is added to the selection list.
//
// Arguments
//
//    item - DAG selection item for the object being matched
//    spec - attribute specification object
//    list - list to add components to
//
// Returns
//
//    the result of the match
//
{
    MPxSurfaceShape::MatchResult result = MPxSurfaceShape::kMatchOk;
	MAttributeSpec attrSpec = spec[0];
	int dim = attrSpec.dimensions();

	// Look for attributes specifications of the form :
	//     vtx[ index ]
	//     vtx[ lower:upper ]
	//
	if ( (1 == spec.length()) && 
         (dim > 0) && 
         (attrSpec.name() == "controlPoints" ) ) 
    {
        MObject node;
        item.getDependNode( 0, node );
        MFnDependencyNode fnDepNode( node );
		int numVertices = fnDepNode.findPlug( mControlPoints ).numElements();
		MAttributeIndex attrIndex = attrSpec[0];

		int upper = 0;
		int lower = 0;
		if ( attrIndex.hasLowerBound() ) {
			attrIndex.getLower( lower );
		}
		if ( attrIndex.hasUpperBound() ) {
			attrIndex.getUpper( upper );
		}

		// Check the attribute index range is valid
		//
		if ( (lower > upper) || (upper >= numVertices) ) {
			result = MPxSurfaceShape::kMatchInvalidAttributeRange;	
		}
		else {
			MDagPath path;
			item.getDagPath( 0, path );
			MFnSingleIndexedComponent fnVtxComp;
			MObject vtxComp = fnVtxComp.create( MFn::kMeshVertComponent );

			for ( int i=lower; i<=upper; i++ )
			{
				fnVtxComp.addElement( i );
			}
			list.add( path, vtxComp );
		}
	}
	else {
		// Pass this to the parent class
		return MPxSurfaceShape::matchComponent( item, spec, list );
	}

	return result;
}

//=============================================================================
// TreelineShapeNode::match
//=============================================================================
// Description: Comment
//
// Parameters:  ( const MSelectionMask & mask, const MObjectArray& componentList )
//
// Return:      bool 
//
//=============================================================================
bool TreelineShapeNode::match( const MSelectionMask & mask, const MObjectArray& componentList ) const
//
// Description:
//
//		Check for matches between selection type / component list, and
//		the type of this shape / or it's components
//
//      This is used by sets and deformers to make sure that the selected
//      components fall into the "vertex only" category.
//
// Arguments
//
//		mask          - selection type mask
//		componentList - possible component list
//
// Returns
//		true if matched any
//
{
	bool result = false;

	if( componentList.length() == 0 ) {
		result = mask.intersects( MSelectionMask::kSelectMeshes );
	}
	else 
    {
		for ( int i=0; i<(int)componentList.length(); i++ ) 
        {
			if ( (componentList[i].apiType() == MFn::kMeshVertComponent) &&
				 (mask.intersects(MSelectionMask::kSelectMeshVerts))
			) 
            {
				result = true;
				break;
			}
		}
	}
    
	return result;
}

//=============================================================================
// TreelineShapeNode::transformUsing
//=============================================================================
// Description: Comment
//
// Parameters:  ( const MMatrix & mat, const MObjectArray & componentList )
//
// Return:      void 
//
//=============================================================================
void TreelineShapeNode::transformUsing( const MMatrix & mat, 
                                        const MObjectArray & componentList )
//
// Description
//
//    Transforms the given components. This method is used by
//    the move, rotate, and scale tools in component mode.
//    Bounding box has to be updated here, so do the normals and
//    any other attributes that depend on vertex positions.
//
// Arguments
//
//    mat           - matrix to tranform the components by
//    componentList - list of components to be transformed
//
{
    MStatus stat;

    MFnDependencyNode fnDepNode( thisMObject() );
    MPlug vertices = fnDepNode.findPlug( mControlPoints );

    int len = componentList.length();
	int i;
	for ( i=0; i<len; i++ )
	{
		MObject comp = componentList[i];
		MFnSingleIndexedComponent fnComp( comp );
		int elemCount = fnComp.elementCount();
		for ( int idx=0; idx<elemCount; idx++ )
		{
			int elemIndex = fnComp.element( idx );
            MPlug vertex = vertices.elementByLogicalIndex( elemIndex );

            MPoint point;
            vertex.child(0).getValue( point.x );
            vertex.child(1).getValue( point.y );
            vertex.child(2).getValue( point.z );

            point *= mat;

            vertex.child(0).setValue( point.x );
            vertex.child(1).setValue( point.y );
            vertex.child(2).setValue( point.z );
		}
    }

	// Moving vertices will likely change the bounding box.
	//

	// Tell maya the bounding box for this object has changed
	// and thus "boundingBox()" needs to be called.
	//
	childChanged( MPxSurfaceShape::kBoundingBoxChanged );
}

//=============================================================================
// TreelineShapeNode::closestPoint 
//=============================================================================
// Description: Comment
//
// Parameters:  ( const MPoint & toThisPoint, MPoint & theClosestPoint, double tolerance )
//
// Return:      void 
//
//=============================================================================
void TreelineShapeNode::closestPoint ( const MPoint& toThisPoint, 
                                       MPoint& theClosestPoint, 
                                       double tolerance )
{
    MStatus stat;

    MFnDependencyNode fnDepNode( thisMObject() );
    MPlug vertices = fnDepNode.findPlug( mControlPoints );

    bool found = false;
    double dist = 10000000.0;

    unsigned int i;
    for ( i = 0; i < vertices.numElements(); ++i )
    {
        MPlug vertex = vertices.elementByLogicalIndex( i );
        MPoint point;
        
        vertex.child( 0 ).getValue( point.x );
        vertex.child( 1 ).getValue( point.y );
        vertex.child( 2 ).getValue( point.z );

        if ( point.distanceTo( toThisPoint ) < dist )
        {
            dist = point.distanceTo( toThisPoint );
            theClosestPoint = point;
        }        
    }    
}

//=============================================================================
// TreelineShapeNode::SnapTreeline
//=============================================================================
// Description: Comment
//
// Parameters:  ( MObject& treeline )
//
// Return:      void 
//
//=============================================================================
void TreelineShapeNode::SnapTreeline( MObject& treeline )
{
    MFnDependencyNode fnDepNode( treeline );

    MPlug vertices = fnDepNode.findPlug( mControlPoints );

    unsigned int i;
    
    for ( i = 0; i < vertices.numElements(); ++i )
    {
        MPlug vertex = vertices.elementByLogicalIndex( i );

        MPoint point;

        vertex.child( 0 ).getValue( point.x );
        vertex.child( 1 ).getValue( point.y );
        vertex.child( 2 ).getValue( point.z );

        MPoint intersectPoint;
        //Look down...
        if ( MExt::MeshIntersectAlongVector( point, MPoint(0, -100000.0, 0 ), intersectPoint ) )
        {
            vertex.child( 0 ).setValue( intersectPoint.x );
            vertex.child( 1 ).setValue( intersectPoint.y );
            vertex.child( 2 ).setValue( intersectPoint.z );
        }
        else
        {
            //Try looking up...
            if ( MExt::MeshIntersectAlongVector( point, MPoint(0, 100000.0, 0 ), intersectPoint ) )
            {
                vertex.child( 0 ).setValue( intersectPoint.x );
                vertex.child( 1 ).setValue( intersectPoint.y );
                vertex.child( 2 ).setValue( intersectPoint.z );
            }
        }
    }
}

void TreelineShapeNode::ConvertToGeometry( MObject& obj )
{
    MFnMesh newMesh;
    MObject newMeshObj;

    MFnDependencyNode fnDepNode( obj );
    MPlug vertices = fnDepNode.findPlug( mControlPoints );
    
    if ( vertices.numElements() >= 2 )
    {
        double height;
        fnDepNode.findPlug( sHeight ).getValue( height );

        double uScale;
        fnDepNode.findPlug( sUScale).getValue( uScale );

        MFloatArray uArray, vArray;
        MIntArray uvCounts, uvIds;

        unsigned int i = 0; 
        unsigned int j = 0;
        do
        {
            //Create the new mesh...
            MPointArray points;
            MPoint point1, point2, point3, point4;

            MPlug vertex1 = vertices.elementByLogicalIndex( i );
            vertex1.child(0).getValue( point1.x );
            vertex1.child(1).getValue( point1.y );
            vertex1.child(2).getValue( point1.z );

            point2 = point1;
            point1.y += height * TEConstants::Scale;

            points.append( point1 );
            points.append( point2 );

            MPlug vertex2 = vertices.elementByLogicalIndex( i + 1 );
            vertex2.child(0).getValue( point3.x );
            vertex2.child(1).getValue( point3.y );
            vertex2.child(2).getValue( point3.z );

            point4 = point3;
            point4.y += height * TEConstants::Scale;

            points.append( point3 );
            points.append( point4 );

            newMeshObj = newMesh.addPolygon( points );            

            double dist =  point2.distanceTo( point3 );
            
            float U = ceil( dist / (uScale * TEConstants::Scale ) );

            uArray.append( 0 );
            uArray.append( 0 );
            uArray.append( U );
            uArray.append( U );

            vArray.append( 1 );
            vArray.append( 0 );
            vArray.append( 0 );
            vArray.append( 1 );

            uvCounts.append( 4 );

            uvIds.append( 0 + j );
            uvIds.append( 1 + j );
            uvIds.append( 2 + j );
            uvIds.append( 3 + j );

            ++i;
            j += 4;
        } 
        while ( i < vertices.numElements() - 1 );

        MString material;
        fnDepNode.findPlug( sShader ).getValue( material );

        if ( material.length() > 0 )
        {
            //Set the material to the new object.

            newMesh.setUVs( uArray, vArray );
            newMesh.assignUVs( uvCounts, uvIds );

            //MEL command for assigning the texture.
            //sets -e -forceElement pure3dSimpleShader1SG polySurface1;
            MString meshName = newMesh.name();

            MString cmd;

            cmd += MString("sets -e -forceElement ") + material + MString(" ") + meshName;

            MStatus status;
            MGlobal::executeCommand( cmd, status );
        }
     }
    else
    {
        assert(false);
        MExt::DisplayError( "Treeline: %s is invalid for converting to geometry!", fnDepNode.name().asChar() );
    }

    if ( TrackEditor::GetDeleteTreelines() )
    {
        MExt::DeleteNode( obj, true );
    }
}


/////////////////////////////////////////////////////////////////////
// UI IMPLEMENTATION
/////////////////////////////////////////////////////////////////////

TreelineShapeNodeUI::TreelineShapeNodeUI()
{ 
}

TreelineShapeNodeUI::~TreelineShapeNodeUI()
{
}

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

//********************************************************************************************
// The draw data is used to pass geometry through the 
// draw queue. The data should hold all the information
// needed to draw the shape.
//********************************************************************************************
void TreelineShapeNodeUI::getDrawRequests( const MDrawInfo & info, bool objectAndActiveOnly, MDrawRequestQueue & queue )
{
    MDrawData data;
    MDrawRequest request = info.getPrototype( *this );
    TreelineShapeNode* shapeNode = (TreelineShapeNode*)surfaceShape();
    getDrawData( NULL, data );
    request.setDrawData( data );

    // Use display status to determine what color to draw the object
    switch ( info.displayStyle() )
    {      
        case M3dView::kGouraudShaded :
            request.setToken( SMOOTH_SHADED );
            getDrawRequestsShaded( request, info, queue, data );
            queue.add( request );
            break;
        
        case M3dView::kFlatShaded :
            request.setToken( FLAT_SHADED );
            getDrawRequestsShaded( request, info, queue, data );
            queue.add( request );
            break;

        default :
            request.setToken(WIREFRAME);
            getDrawRequestsWireframe( request, info );
            queue.add( request );
            break;
        
    }

    // Add draw requests for components
	//
	if ( !objectAndActiveOnly ) 
    {
		// Inactive components
		//
		if ( (info.displayStyle() == M3dView::kPoints) ||
			 (info.displayStatus() == M3dView::kHilite) )
		{
			MDrawRequest vertexRequest = info.getPrototype( *this ); 
			vertexRequest.setDrawData( data );
			vertexRequest.setToken( VERTICES );
			vertexRequest.setColor( DORMANT_VERTEX_COLOR,  //TODO: PICK COLOURS
									M3dView::kActiveColors );

			queue.add( vertexRequest );
		}

		// Active components
		//
		if ( surfaceShape()->hasActiveComponents() ) {

			MDrawRequest activeVertexRequest = info.getPrototype( *this ); 
			activeVertexRequest.setDrawData( data );
		    activeVertexRequest.setToken( VERTICES );
		    activeVertexRequest.setColor( ACTIVE_VERTEX_COLOR,  //TODO: PICK COLOURS
										  M3dView::kActiveColors );

		    MObjectArray clist = surfaceShape()->activeComponents();
		    MObject vertexComponent = clist[0]; // Should filter list
		    activeVertexRequest.setComponent( vertexComponent );

			queue.add( activeVertexRequest );
		}
	}

}

//********************************************************************************************
// Actual draw call 
//********************************************************************************************
void TreelineShapeNodeUI::drawQuad(int drawMode) const
{
    glPushAttrib( GL_CURRENT_BIT | GL_LINE_BIT | GL_POLYGON_BIT );
    TreelineShapeNode* shapeNode = (TreelineShapeNode*)surfaceShape();
    MFnDagNode dagNodeFn(shapeNode->thisMObject());
    MPlug plug;

    MStatus status;
    float height;
    MPlug heightPlug = dagNodeFn.findPlug( TETreeLine::TreelineShapeNode::sHeight, &status );
    assert( status );

    heightPlug.getValue( height );

    MPlug vertices = dagNodeFn.findPlug( TETreeLine::TreelineShapeNode::mControlPoints, &status );
    assert( status );

    if ( vertices.numElements() >= 2 )
    {
        double uScale;
        MPlug uScalePlug = dagNodeFn.findPlug( TETreeLine::TreelineShapeNode::sUScale, &status );
        assert( status );
        uScalePlug.getValue( uScale );

        int primType;
        if ((drawMode==SMOOTH_SHADED)||(drawMode==FLAT_SHADED))
        {
            glPolygonMode ( GL_FRONT_AND_BACK, GL_FILL);
            primType = GL_POLYGON;
        }
        else 
        {
            glPolygonMode ( GL_FRONT_AND_BACK, GL_LINE);
            primType = GL_LINE_LOOP;
        }

        glPushMatrix();

        unsigned int i = 0; 

        do
        {
            MPoint point1, point2;
            MPlug vertex1 = vertices.elementByLogicalIndex( i, &status );
            assert( status );

            MPlug vertex2 = vertices.elementByLogicalIndex( i + 1, &status );
            assert( status );
    
            MPlug x1 = vertex1.child( TETreeLine::TreelineShapeNode::mControlValueX, &status );
            assert( status );
            x1.getValue( point1.x );

            MPlug y1 = vertex1.child( TETreeLine::TreelineShapeNode::mControlValueY, &status );
            assert( status );
            y1.getValue( point1.y );

            MPlug z1 = vertex1.child( TETreeLine::TreelineShapeNode::mControlValueZ, &status );
            assert( status );
            z1.getValue( point1.z );

            MPlug x2 = vertex2.child( TETreeLine::TreelineShapeNode::mControlValueX, &status );
            assert( status );
            x2.getValue( point2.x );

            MPlug y2 = vertex2.child( TETreeLine::TreelineShapeNode::mControlValueY, &status );
            assert( status );
            y2.getValue( point2.y );

            MPlug z2 = vertex2.child( TETreeLine::TreelineShapeNode::mControlValueZ, &status );
            assert( status );
            z2.getValue( point2.z );

            MPoint normal, vect;
            rmt::Vector normalVec;
            rmt::Vector v;

            double dist =  point1.distanceTo( point2 );

            double U = ceil( dist / (uScale * TEConstants::Scale ) );

            vect = point2 - point1;
            v.Set( vect.x, vect.y, vect.z );
            normalVec.CrossProduct( v, rmt::Vector( 0.0f, 1.0f, 0.0f ) );

            glBegin(primType);
                glNormal3f( normalVec.x, normalVec.y, normalVec.z ); //TODO: CALCULATE THIS!
                glTexCoord2f ( 0, 1 );
                glVertex3f( point1.x, 
                    (point1.y) + (height * TEConstants::Scale), 
                            point1.z );
                glTexCoord2f ( 0, 0 );
                glVertex3f( point1.x, 
                            point1.y, 
                            point1.z );
                glTexCoord2f ( U, 0 );
                glVertex3f( point2.x, 
                            point2.y, 
                            point2.z );
                glTexCoord2f ( U, 1 );
                glVertex3f( point2.x, 
                            (point2.y) + (height * TEConstants::Scale), 
                            point2.z );
            glEnd();

            ++i;
        } 
        while ( i < vertices.numElements() - 1 );
        
        glPopMatrix();

        glPolygonMode ( GL_FRONT_AND_BACK, GL_FILL);
    }
    glPopAttrib();
}

//********************************************************************************************
// From the given draw request, get the draw data and display the quad
//********************************************************************************************
void TreelineShapeNodeUI::draw( const MDrawRequest & request, M3dView & view ) const
{  
    glPushAttrib( GL_CURRENT_BIT | GL_LINE_BIT | GL_POLYGON_BIT );
    MDagPath dagPath = request.multiPath();
    MDrawData data = request.drawData();
    short token = request.token();
    bool drawTexture = false;

    view.beginGL(); 

    if ( (token == SMOOTH_SHADED) || (token == FLAT_SHADED) )
    {
        glEnable( GL_POLYGON_OFFSET_FILL );
        // Set up the material
        //
        MMaterial material = request.material();
        material.setMaterial(dagPath,false);

        // Enable texturing
        //
        drawTexture = material.materialIsTextured();
        if ( drawTexture ) glEnable(GL_TEXTURE_2D);

        // Apply the texture to the current view
        //
        if ( drawTexture ) 
        {
            material.applyTexture( view, data );
        }
    }
 
    if ( token == VERTICES )
    {
        drawVertices( request, view );
    }
    else
    {
        drawQuad(token);
    }

    // Turn off texture mode
    //
    if ( drawTexture ) glDisable(GL_TEXTURE_2D);

    view.endGL(); 
    glPopAttrib();
}

//********************************************************************************************
// Select function. Gets called when the bbox for the object is selected.
// This function just selects the object without doing any intersection tests.
//********************************************************************************************
bool TreelineShapeNodeUI::select( MSelectInfo &selectInfo, MSelectionList &selectionList, MPointArray &worldSpaceSelectPts ) const
{
    bool selected = false;

	if ( selectInfo.displayStatus() == M3dView::kHilite ) {
		selected = selectVertices( selectInfo, selectionList,worldSpaceSelectPts );
	}

    if ( !selected )
    {
	    M3dView view = selectInfo.view();

        //
	    // Re-Draw the object and see if they lie withing the selection area
	    // Sets OpenGL's render mode to select and stores
	    // selected items in a pick buffer
	    //
        view.beginSelect();

        switch ( selectInfo.displayStyle() )
        {      
            case M3dView::kGouraudShaded :
                drawQuad(SMOOTH_SHADED);
                break;
        
            case M3dView::kFlatShaded :
                drawQuad(FLAT_SHADED);
                break;

            default :
                drawQuad(WIREFRAME);
                break;      
        }

        if( view.endSelect() > 0 )	
	    {
            MSelectionMask priorityMask( MSelectionMask::kSelectObjectsMask );
            MSelectionList item;
            item.add( selectInfo.selectPath() );
            MPoint xformedPt;
            selectInfo.addSelection( item, xformedPt, selectionList, worldSpaceSelectPts, priorityMask, false );
            return true;
        }
    }
    
    return selected;
}

//=============================================================================
// TreelineShapeNodeUI::drawVertices
//=============================================================================
// Description: Comment
//
// Parameters:  ( const MDrawRequest & request, M3dView & view )
//
// Return:      void 
//
//=============================================================================
void TreelineShapeNodeUI::drawVertices( const MDrawRequest & request, M3dView & view ) const
//
// Description:
//
//     Component (vertex) drawing routine
//
// Arguments:
//
//     request - request to be drawn
//     view    - view to draw into
//
{
    glPushAttrib( GL_CURRENT_BIT | GL_LINE_BIT | GL_POLYGON_BIT );
	MDrawData data = request.drawData();
    TreelineShapeNode* shapeNode = (TreelineShapeNode*)surfaceShape();
    MFnDagNode dagNodeFn(shapeNode->thisMObject());

	view.beginGL(); 

	// Query current state so it can be restored
	//
	bool lightingWasOn = glIsEnabled( GL_LIGHTING ) ? true : false;
	if ( lightingWasOn ) {
		glDisable( GL_LIGHTING );
	}
	float lastPointSize;
	glGetFloatv( GL_POINT_SIZE, &lastPointSize );

	// Set the point size of the vertices
	//
	glPointSize( POINT_SIZE );

	// If there is a component specified by the draw request
	// then loop over comp (using an MFnComponent class) and draw the
	// active vertices, otherwise draw all vertices.
	//
	MObject comp = request.component();
	if ( ! comp.isNull() ) 
    {
        MPlug vertices = dagNodeFn.findPlug( TETreeLine::TreelineShapeNode::mControlPoints );
        
		MFnSingleIndexedComponent fnComponent( comp );
		for ( int i=0; i<fnComponent.elementCount(); i++ )
		{
			int index = fnComponent.element( i );
			glBegin( GL_POINTS );
            MPlug vertexPlug = vertices.elementByLogicalIndex( index );

			MPoint vertex;
            vertexPlug.child( 0 ).getValue( vertex.x );
            vertexPlug.child( 1 ).getValue( vertex.y );
            vertexPlug.child( 2 ).getValue( vertex.z );

            glVertex3f( (float)vertex[0], 
						(float)vertex[1], 
						(float)vertex[2] );
			glEnd();

			char annotation[32];
			sprintf( annotation, "%d", index );
			view.drawText( annotation, vertex );
		}
	}
    else
    {
        MPlug vertices = dagNodeFn.findPlug( TETreeLine::TreelineShapeNode::mControlPoints );
        
		for ( int i=0; i<vertices.numElements(); i++ )
		{
			glBegin( GL_POINTS );
            MPlug vertexPlug = vertices.elementByLogicalIndex( i );

			MPoint vertex;
            vertexPlug.child( 0 ).getValue( vertex.x );
            vertexPlug.child( 1 ).getValue( vertex.y );
            vertexPlug.child( 2 ).getValue( vertex.z );

            glVertex3f( (float)vertex[0], 
						(float)vertex[1], 
						(float)vertex[2] );
		    glEnd();
        }
    }
	// Restore the state
	//
	if ( lightingWasOn ) {
		glEnable( GL_LIGHTING );
	}
	glPointSize( lastPointSize );

	view.endGL(); 
    glPopAttrib();
}

//=============================================================================
// TreelineShapeNodeUI::selectVertices
//=============================================================================
// Description: Comment
//
// Parameters:  ( MSelectInfo &selectInfo, MSelectionList &selectionList, MPointArray &worldSpaceSelectPts )
//
// Return:      bool 
//
//=============================================================================
bool TreelineShapeNodeUI::selectVertices( MSelectInfo &selectInfo, 
                                          MSelectionList &selectionList, 
                                          MPointArray &worldSpaceSelectPts ) const
//
// Description:
//
//     Vertex selection.
//
// Arguments:
//
//     selectInfo           - the selection state information
//     selectionList        - the list of selected items to add to
//     worldSpaceSelectPts  -
//
{
	bool selected = false;
	M3dView view = selectInfo.view();

	MPoint 		xformedPoint;
	MPoint 		currentPoint;
	MPoint 		selectionPoint;
	double		z,previousZ = 0.0;
 	int			closestPointVertexIndex = -1;

	const MDagPath & path = selectInfo.multiPath();

	// Create a component that will store the selected vertices
	//
	MFnSingleIndexedComponent fnComponent;
	MObject surfaceComponent = fnComponent.create( MFn::kMeshVertComponent );
	int vertexIndex;

	// if the user did a single mouse click and we find > 1 selection
	// we will use the alignmentMatrix to find out which is the closest
	//
	MMatrix	alignmentMatrix;
	MPoint singlePoint; 
	bool singleSelection = selectInfo.singleSelection();
	if( singleSelection ) {
		alignmentMatrix = selectInfo.getAlignmentMatrix();
	}

	// Get the geometry information
	//
    TreelineShapeNode* shapeNode = (TreelineShapeNode*)surfaceShape();
    MFnDagNode dagNodeFn(shapeNode->thisMObject());

	// Loop through all vertices of the mesh and
	// see if they lie withing the selection area
	//
    MPlug vertices = dagNodeFn.findPlug( TETreeLine::TreelineShapeNode::mControlPoints );

	int numVertices = vertices.numElements();

	for ( vertexIndex=0; vertexIndex<numVertices; vertexIndex++ )
	{
        MPlug vertexPlug = vertices.elementByLogicalIndex( vertexIndex );

		MPoint currentPoint;
        vertexPlug.child( 0 ).getValue( currentPoint.x );
        vertexPlug.child( 1 ).getValue( currentPoint.y );
        vertexPlug.child( 2 ).getValue( currentPoint.z );

		// Sets OpenGL's render mode to select and stores
		// selected items in a pick buffer
		//
		view.beginSelect();
      
		glBegin( GL_POINTS );

        glVertex3f( (float)currentPoint[0], 
					(float)currentPoint[1], 
					(float)currentPoint[2] );
		glEnd();

		if ( view.endSelect() > 0 )	// Hit count > 0
		{
			selected = true;

			if ( singleSelection ) {
				xformedPoint = currentPoint;
				xformedPoint.homogenize();
				xformedPoint*= alignmentMatrix;
				z = xformedPoint.z;
				if ( closestPointVertexIndex < 0 || z > previousZ ) {
					closestPointVertexIndex = vertexIndex;
					singlePoint = currentPoint;
					previousZ = z;
				}
			} else {
				// multiple selection, store all elements
				//
				fnComponent.addElement( vertexIndex );
			}
		}
	}

	// If single selection, insert the closest point into the array
	//
	if ( selected && selectInfo.singleSelection() ) {
		fnComponent.addElement(closestPointVertexIndex);

		// need to get world space position for this vertex
		//
		selectionPoint = singlePoint;
		selectionPoint *= path.inclusiveMatrix();
	}

	// Add the selected component to the selection list
	//
	if ( selected ) {
		MSelectionList selectionItem;
		selectionItem.add( path, surfaceComponent );

		MSelectionMask mask( MSelectionMask::kSelectComponentsMask );
		selectInfo.addSelection(
			selectionItem, selectionPoint,
			selectionList, worldSpaceSelectPts,
			mask, true );
	}

	return selected;
}

}  //namespace TETreeLine