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

///////////////////////////////////////////////////////////////////////////////
//
// apiMeshShapeUI.cpp
//
////////////////////////////////////////////////////////////////////////////////

#include <maya/MIOStream.h>

#include <apiMeshShapeUI.h>

#include <maya/MMaterial.h>
#include <maya/MColor.h>
#include <maya/MDrawData.h>
#include <maya/MMatrix.h>
#include <maya/MFnSingleIndexedComponent.h>
#include <maya/MObjectArray.h>
#include <maya/MDagPath.h>
// for user interaction performance example code. (search on 
// "userChangingViewContext")
#include <maya/MGlobal.h>

#include <maya/MTextureEditorDrawInfo.h> 

// Object and component color defines
//
#define LEAD_COLOR				18	// green
#define ACTIVE_COLOR			15	// white
#define ACTIVE_AFFECTED_COLOR	8	// purple
#define DORMANT_COLOR			4	// blue
#define HILITE_COLOR			17	// pale blue
#define DORMANT_VERTEX_COLOR	8	// purple
#define ACTIVE_VERTEX_COLOR		16	// yellow

// Vertex point size
//
#define POINT_SIZE				2.0	
#define UV_POINT_SIZE			4.0

////////////////////////////////////////////////////////////////////////////////
//
// UI implementation
//
////////////////////////////////////////////////////////////////////////////////

apiMeshUI::apiMeshUI() {}
apiMeshUI::~apiMeshUI() {}

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

///////////////////////////////////////////////////////////////////////////////
//
// Overrides
//
///////////////////////////////////////////////////////////////////////////////

/* override */
void apiMeshUI::getDrawRequests( const MDrawInfo & info,
							 bool objectAndActiveOnly,
							 MDrawRequestQueue & queue )
//
// Description:
//
//     Add draw requests to the draw queue
//
// Arguments:
//
//     info                 - current drawing state
//     objectsAndActiveOnly - no components if true
//     queue                - queue of draw requests to add to
//
{
	// Get the data necessary to draw the shape
	//
	MDrawData data;
	apiMesh* meshNode = (apiMesh*)surfaceShape();
	apiMeshGeom * geom = meshNode->meshGeom();
	if ( (NULL == geom) || (0 == geom->faceCount) ) {
		//cerr << "NO DrawRequest for apiMesh\n";
		return;
	}

	// This call creates a prototype draw request that we can fill
	// in and then add to the draw queue.
	//
	MDrawRequest request = info.getPrototype( *this );
	getDrawData( geom, data );
	request.setDrawData( data );

	// Decode the draw info and determine what needs to be drawn
	//

	M3dView::DisplayStyle  appearance    = info.displayStyle();
	M3dView::DisplayStatus displayStatus = info.displayStatus();
	
	// Are we displaying meshes?
	if ( ! info.objectDisplayStatus( M3dView::kDisplayMeshes ) )
		return;

	switch ( appearance )
	{
		case M3dView::kWireFrame :
		{
			request.setToken( kDrawWireframe );

			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;
				default:	
					break;
			}

			queue.add( request );

			break;
		}

		case M3dView::kGouraudShaded :
		{
			// Create the smooth shaded draw request
			//
			request.setToken( kDrawSmoothShaded );

			// 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 );

			// If the user currently has the default material enabled on the 
			// view then use the default material for shading. 
			// 
			if ( view.usingDefaultMaterial() ) { 
				material = MMaterial::defaultMaterial(); 
			}
			
			// Evaluate the material and if necessary, the texture.
			//
			if ( ! material.evaluateMaterial( view, path ) ) {
				cerr << "Couldnt evaluate\n";
			}
			
			bool drawTexture = true;
			if ( drawTexture && material.materialIsTextured() ) {
				material.evaluateTexture( data );
			}
			
			request.setMaterial( material );
			
			// request.setDisplayStyle( appearance );
			
			bool materialTransparent = false;
			material.getHasTransparency( materialTransparent );
			if ( materialTransparent ) {
				request.setIsTransparent( true );
			}

			queue.add( request );

			// 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 );
				wireRequest.setToken( kDrawWireframeOnShaded );
				wireRequest.setDisplayStyle( M3dView::kWireFrame );

				M3dView::ColorTable activeColorTable = M3dView::kActiveColors;

				switch ( displayStatus )
				{
					case M3dView::kLead :
						wireRequest.setColor( LEAD_COLOR, activeColorTable );
						break;
					case M3dView::kActive :
						wireRequest.setColor( ACTIVE_COLOR, activeColorTable );
						break;
					case M3dView::kHilite :
						wireRequest.setColor( HILITE_COLOR, activeColorTable );
						break;
					default:	
						break;

				}

				queue.add( wireRequest );
			}

			break;
		}

		case M3dView::kFlatShaded :
			request.setToken( kDrawFlatShaded );
			queue.add( request );
			break;
		case M3dView::kBoundingBox :
			request.setToken( kDrawBoundingBox );
			queue.add( request );
			break;
		default:	
			break;
	}

	// Add draw requests for components
	//
	if ( !objectAndActiveOnly ) {

		// Inactive components
		//
		if ( (appearance == M3dView::kPoints) ||
			 (displayStatus == M3dView::kHilite) )
		{
			MDrawRequest vertexRequest = info.getPrototype( *this ); 
			vertexRequest.setDrawData( data );
			vertexRequest.setToken( kDrawVertices );
			vertexRequest.setColor( DORMANT_VERTEX_COLOR,
									M3dView::kActiveColors );

			queue.add( vertexRequest );
		}

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

			MDrawRequest activeVertexRequest = info.getPrototype( *this ); 
			activeVertexRequest.setDrawData( data );
		    activeVertexRequest.setToken( kDrawVertices );
		    activeVertexRequest.setColor( ACTIVE_VERTEX_COLOR,
										  M3dView::kActiveColors );

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

			queue.add( activeVertexRequest );
		}
	}
}

/* override */
void apiMeshUI::draw( const MDrawRequest & request, M3dView & view ) const
//
// Description:
//
//     Main (OpenGL) draw routine
//
// Arguments:
//
//     request - request to be drawn
//     view    - view to draw into
//
{ 
	// Get the token from the draw request.
	// The token specifies what needs to be drawn.
	//
	int token = request.token();

	switch( token )
	{
		case kDrawWireframe :
		case kDrawWireframeOnShaded :
			drawWireframe( request, view );
			break;

		case kDrawSmoothShaded :
			drawShaded( request, view );
			break;

		case kDrawFlatShaded : // Not implemented
			break;

		case kDrawVertices :
			drawVertices( request, view );
			break;
			
		case kDrawBoundingBox:
			drawBoundingBox( request, view );
			break;
		// for userChangingViewContext example code 
		//
		case kDrawRedPointAtCenter:
			drawRedPointAtCenter( request, view );
			break;
	}
}

/* override */
bool apiMeshUI::select( MSelectInfo &selectInfo, MSelectionList &selectionList,
					MPointArray &worldSpaceSelectPts ) const
//
// Description:
//
//     Main selection routine
//
// Arguments:
//
//     selectInfo           - the selection state information
//     selectionList        - the list of selected items to add to
//     worldSpaceSelectPts  -
//
{
	bool selected = false;
	bool componentSelected = false;
	bool hilited = false;

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

	if ( !selected ) {

		apiMesh* meshNode = (apiMesh*)surfaceShape();

		// NOTE: If the geometry has an intersect routine it should
		// be called here with the selection ray to determine if the
		// the object was selected.

		selected = true;
		MSelectionMask priorityMask( MSelectionMask::kSelectNurbsSurfaces );
		MSelectionList item;
		item.add( selectInfo.selectPath() );
		MPoint xformedPt;
		if ( selectInfo.singleSelection() ) {
			MPoint center = meshNode->boundingBox().center();
			xformedPt = center;
			xformedPt *= selectInfo.selectPath().inclusiveMatrix();
		}

		selectInfo.addSelection( item, xformedPt, selectionList,
								 worldSpaceSelectPts, priorityMask, false );
	}

	return selected;
}

///////////////////////////////////////////////////////////////////////////////
//
// Helper routines
//
///////////////////////////////////////////////////////////////////////////////

void apiMeshUI::drawWireframe( const MDrawRequest & request,
							   M3dView & view ) const
//
// Description:
//
//     Wireframe drawing routine
//
// Arguments:
//
//     request - request to be drawn
//     view    - view to draw into
//
{
	MDrawData data = request.drawData();
	apiMeshGeom * geom = (apiMeshGeom*)data.geometry();

	int token = request.token();

	bool wireFrameOnShaded = false;
	if ( kDrawWireframeOnShaded == token ) {
		wireFrameOnShaded = true;
	}

	view.beginGL(); 

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

	if ( wireFrameOnShaded ) {
		glDepthMask( false );
	}

	// Draw the wireframe mesh
	//
	int vid = 0;			
	for ( int i=0; i<geom->faceCount; i++ )
	{
		glBegin( GL_LINE_LOOP );
		for ( int v=0; v<geom->face_counts[i]; v++ )
		{
			MPoint vertex = geom->vertices[ geom->face_connects[vid++] ];
			glVertex3f( (float)vertex[0], (float)vertex[1], (float)vertex[2] );
		}
		glEnd();
	}

	// Restore the state
	//
	if ( lightingWasOn ) {
		glEnable( GL_LIGHTING );
	}
	if ( wireFrameOnShaded ) {
		glDepthMask( true );
	}

	view.endGL(); 
}

void apiMeshUI::drawShaded( const MDrawRequest & request,
							M3dView & view ) const
//
// Description:
//
//     Shaded drawing routine
//
// Arguments:
//
//     request - request to be drawn
//     view    - view to draw into
//
{
	MDrawData data = request.drawData();
	apiMeshGeom * geom = (apiMeshGeom*)data.geometry();

	view.beginGL(); 

#if		defined(SGI) || defined(MESA)
	glEnable( GL_POLYGON_OFFSET_EXT );
#else
	glEnable( GL_POLYGON_OFFSET_FILL );
#endif

	// Set up the material
	//
	MMaterial material = request.material();
	material.setMaterial( request.multiPath(), request.isTransparent() );

	// Enable texturing ... 
	// 
	// Note, Maya does not enable texturing if useDefaultMaterial is enabled. 
	// However, you can choose to ignore this in your draw routine.  
	//
	bool drawTexture = 
		material.materialIsTextured() && 
		!view.usingDefaultMaterial(); 

	if ( drawTexture ) glEnable(GL_TEXTURE_2D);

	// Apply the texture to the current view
	//
	if ( drawTexture ) {
		material.applyTexture( view, data );
	}

	// Draw the polygons
	//
	int vid = 0;
	int uv_len = geom->uvcoords.uvcount();
	for ( int i=0; i<geom->faceCount; i++ )
	{
		glBegin( GL_POLYGON );
		for ( int v=0; v<geom->face_counts[i]; v++ )
		{
			MPoint vertex = geom->vertices[ geom->face_connects[vid] ];
			MVector normal = geom->normals[ geom->face_connects[vid] ];
			if (uv_len > 0)
			{

				// If we are drawing the texture, make sure the  coord 
				// arrays are in bounds.
				if ( drawTexture ) {
					float u, v; 
					int uvId1 = geom->uvcoords.uvId(vid); 
					if ( uvId1 < uv_len ) { 
						geom->uvcoords.getUV( uvId1, u, v ); 
						glTexCoord2f( (GLfloat)u, (GLfloat)v ); 
					}
				}
			}	

			glNormal3f( (float)normal[0], (float)normal[1], (float)normal[2] );
			glVertex3f( (float)vertex[0], (float)vertex[1], (float)vertex[2] );
			vid++;
		}
		glEnd();
	} 

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

	view.endGL(); 
}

void apiMeshUI::drawVertices( const MDrawRequest & request,
							  M3dView & view ) const
//
// Description:
//
//     Component (vertex) drawing routine
//
// Arguments:
//
//     request - request to be drawn
//     view    - view to draw into
//
{
	MDrawData data = request.drawData();
	apiMeshGeom * geom = (apiMeshGeom*)data.geometry();

	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 );


	// 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() ) {
		// Set the point size of the vertices
		//
		glPointSize( POINT_SIZE*2 );

		MFnSingleIndexedComponent fnComponent( comp );
		for ( int i=0; i<fnComponent.elementCount(); i++ )
		{
			int index = fnComponent.element( i );
			glBegin( GL_POINTS );
			MPoint vertex = geom->vertices[ index  ];
			glVertex3f( (float)vertex[0], 
						(float)vertex[1], 
						(float)vertex[2] );
			glEnd();
		}
	}
	else {
		// Set the point size of the vertices
		//
		glPointSize( POINT_SIZE );

		int vid = 0;
		for ( int i=0; i<geom->faceCount; i++ )
		{
			glBegin( GL_POINTS );
			for ( int v=0; v<geom->face_counts[i]; v++ )
			{
				MPoint vertex =
					geom->vertices[ geom->face_connects[vid++] ];
				glVertex3f( (float)vertex[0], 
							(float)vertex[1], 
							(float)vertex[2] );
			}
			glEnd();
		}
	}

	// Restore the state
	//
	if ( lightingWasOn ) {
		glEnable( GL_LIGHTING );
	}
	glPointSize( lastPointSize );

	view.endGL(); 
}

void apiMeshUI::drawBoundingBox( const MDrawRequest & request,
							  M3dView & view ) const
//
// Description:
//
//     Bounding box drawing routine
//
// Arguments:
//
//     request - request to be drawn
//     view    - view to draw into
//
{
	// Get the surface shape
	MPxSurfaceShape *shape = surfaceShape();
	if ( !shape )
		return;
		
	// Get the bounding box	
	MBoundingBox box = shape->boundingBox();
	float w = (float) box.width();
	float h = (float) box.height();
	float d = (float) box.depth();
	view.beginGL(); 
	
	// Below we just two sides and then connect
	// the edges together

	MPoint minVertex = box.min();
	
	// Draw first side
	glBegin( GL_LINE_LOOP );
	MPoint vertex = minVertex;
	glVertex3f( (float)vertex[0],   (float)vertex[1],   (float)vertex[2] );
	glVertex3f( (float)vertex[0]+w, (float)vertex[1],   (float)vertex[2] );
	glVertex3f( (float)vertex[0]+w, (float)vertex[1]+h, (float)vertex[2] );
	glVertex3f( (float)vertex[0],   (float)vertex[1]+h, (float)vertex[2] );	
	glVertex3f( (float)vertex[0],   (float)vertex[1],   (float)vertex[2] );
	glEnd();

	// Draw second side
	MPoint sideFactor(0,0,d);
	MPoint vertex2 = minVertex + sideFactor;
	glBegin( GL_LINE_LOOP );
	glVertex3f( (float)vertex2[0],   (float)vertex2[1],   (float)vertex2[2] );	
	glVertex3f( (float)vertex2[0]+w, (float)vertex2[1],   (float)vertex2[2] );
	glVertex3f( (float)vertex2[0]+w, (float)vertex2[1]+h, (float)vertex2[2] );
	glVertex3f( (float)vertex2[0],   (float)vertex2[1]+h, (float)vertex2[2] );	
	glVertex3f( (float)vertex2[0],   (float)vertex2[1],   (float)vertex2[2] );	
	glEnd();

	// Connect the edges together
	glBegin( GL_LINES );
	glVertex3f( (float)vertex2[0],   (float)vertex2[1],   (float)vertex2[2] );	
	glVertex3f( (float)vertex[0],   (float)vertex[1],   (float)vertex[2] );

	glVertex3f( (float)vertex2[0]+w,   (float)vertex2[1],   (float)vertex2[2] );	
	glVertex3f( (float)vertex[0]+w,   (float)vertex[1],   (float)vertex[2] );

	glVertex3f( (float)vertex2[0]+w,   (float)vertex2[1]+h,   (float)vertex2[2] );	
	glVertex3f( (float)vertex[0]+w,   (float)vertex[1]+h,   (float)vertex[2] );

	glVertex3f( (float)vertex2[0],   (float)vertex2[1]+h,   (float)vertex2[2] );	
	glVertex3f( (float)vertex[0],   (float)vertex[1]+h,   (float)vertex[2] );
	glEnd();
	
	view.endGL(); 
}

// for userChangingViewContext example code 
//
void apiMeshUI::drawRedPointAtCenter( const MDrawRequest & request,
										M3dView & view ) const
//
// Description:
//
//     Simple very fast draw routine
//
// Arguments:
//
//     request - request to be drawn
//     view    - view to draw into
//
{
	// Draw point
	// 
	view.beginGL();
		
	// save state
	//
	glPushAttrib( GL_CURRENT_BIT | GL_POINT_BIT );
	glPointSize( 20.0f );
	glBegin( GL_POINTS );
	glColor3f( 1.0f, 0.0f, 0.0f );
	glVertex3f(0.0f, 0.0f, 0.0f );
	glEnd();
							
	// restore state
	//
	glPopAttrib();
	view.endGL();

}


bool apiMeshUI::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 		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
	//
	apiMesh* meshNode = (apiMesh*)surfaceShape();
	apiMeshGeom * geom = meshNode->meshGeom();

	// Loop through all vertices of the mesh and
	// see if they lie withing the selection area
	//
	int numVertices = geom->vertices.length();
	for ( vertexIndex=0; vertexIndex<numVertices; vertexIndex++ )
	{
		MPoint currentPoint = geom->vertices[ vertexIndex ];

		// 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;
}

bool apiMeshUI::canDrawUV() const
//
// Description: 
//  Tells Maya that this surface shape supports uv drawing. 
//
{
	apiMesh* meshNode = (apiMesh*)surfaceShape();
	apiMeshGeom * geom = meshNode->meshGeom();
	return geom->uvcoords.uvcount() > 0; 
}

void apiMeshUI::drawUVWireframe( 
	apiMeshGeom *geom, 
	M3dView &view, 
	const MTextureEditorDrawInfo &info 
) const 
//
// Description: 
//  Draws the UV layout in wireframe mode. 
// 
{
	view.beginGL(); 
	
	// Draw the polygons
	//
	int vid = 0;
	int vid_start = vid;
	for ( int i=0; i<geom->faceCount; i++ )
	{
		glBegin( GL_LINES );
		int v;

		vid_start = vid; 
		for ( v=0; v<geom->face_counts[i]-1; v++ )
		{
			float du1, dv1, du2, dv2; 
			int uvId1 = geom->uvcoords.uvId(vid); 
			int uvId2 = geom->uvcoords.uvId(vid+1); 
			geom->uvcoords.getUV( uvId1, du1, dv1 ); 
			geom->uvcoords.getUV( uvId2, du2, dv2 );
			glVertex3f( (GLfloat)du1, (GLfloat)dv1, 0.0f ); 
			glVertex3f( (GLfloat)du2, (GLfloat)dv2, 0.0f ); 
			vid++;
		}
		
		float du1, dv1, du2, dv2; 
		int uvId1 = geom->uvcoords.uvId(vid); 
		int uvId2 = geom->uvcoords.uvId(vid_start); 
		geom->uvcoords.getUV( uvId1, du1, dv1 ); 
		geom->uvcoords.getUV( uvId2, du2, dv2 );
		glVertex3f( (GLfloat)du1, (GLfloat)dv1, 0.0f );
		glVertex3f( (GLfloat)du2, (GLfloat)dv2, 0.0f ); 
		vid ++ ; 
		glEnd();
	} 
	
	view.endGL();
	
}

void apiMeshUI::drawUVMapCoord( 
	M3dView &view, 
	int uv, 
	float u, float v, 
	bool drawNum
) const 
//
// Description: 
//  Draw the specified uv value into the port view. If drawNum is true 
//  It will also draw the UV id for the the UV.  
//
{
	if ( drawNum ) { 
		char s[32];
		sprintf( s, "%d", uv );
		view.drawText( s, MPoint( u, v, 0 ), M3dView::kCenter );
	}  
	glVertex3f( (GLfloat)u, (GLfloat)v, 0.0f ); 
}

void apiMeshUI::drawUVMapCoordNum( 
	apiMeshGeom *geom, 
	M3dView &view, 
	const MTextureEditorDrawInfo &info, 
	bool drawNumbers 
) const 
//
// Description: 
//  Draw the UV points for all uvs on this surface shape. 
//
{
	view.beginGL(); 

	GLfloat ptSize; 
	glGetFloatv( GL_POINT_SIZE, &ptSize ); 
	glPointSize( UV_POINT_SIZE );

	int uv; 
	int uv_len = geom->uvcoords.uvcount();
	for ( uv = 0; uv < uv_len; uv ++ ) { 
		float du, dv; 
		geom->uvcoords.getUV( uv, du, dv ); 
		drawUVMapCoord( view, uv, du, dv, drawNumbers );
	}

	glPointSize( ptSize ); 
	view.endGL(); 
}

void apiMeshUI::drawUV( M3dView &view, const MTextureEditorDrawInfo &info ) const
// 
// Description: 
//   Main entry point for UV drawing. This method is called by the UV 
//   texture editor when the shape is 'active'. 
// 
// Input: 
//   A 3dView. 
//
{
	apiMesh* meshNode = (apiMesh*)surfaceShape();
	apiMeshGeom * geom = meshNode->meshGeom();

	int uv_len = geom->uvcoords.uvcount(); 
	if (uv_len > 0)
	{
		view.setDrawColor( MColor( 1.0f, 0.0f, 0.0f ) ); 
	
		switch( info.drawingFunction() ) { 
		case MTextureEditorDrawInfo::kDrawWireframe: 
			drawUVWireframe( geom, view, info ); 
			break; 
		case MTextureEditorDrawInfo::kDrawEverything: 
		case MTextureEditorDrawInfo::kDrawUVForSelect: 
			drawUVWireframe( geom, view, info ); 
			drawUVMapCoordNum( geom, view, info, false ); 
			break; 
		case MTextureEditorDrawInfo::kDrawVertexForSelect: 
		case MTextureEditorDrawInfo::kDrawEdgeForSelect: 
		case MTextureEditorDrawInfo::kDrawFacetForSelect: 
		default: 
			drawUVWireframe( geom, view, info ); 
		};
	}
}