apiSimpleShapeUI.cpp

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

//
// apiSimpleShapeUI.cpp
//

#include <maya/MIOStream.h> 

#include <apiSimpleShapeUI.h>

#include <maya/MMaterial.h>
#include <maya/MSelectionList.h>
#include <maya/MSelectionMask.h>
#include <maya/MDrawData.h>
#include <maya/MMatrix.h>
#include <maya/MFnSingleIndexedComponent.h>
#include <maya/MObjectArray.h>
#include <maya/MDagPath.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     

//
// UI implementation
//

apiSimpleShapeUI::apiSimpleShapeUI() {}
apiSimpleShapeUI::~apiSimpleShapeUI() {}

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

//
// Overrides
//

/* override */
void apiSimpleShapeUI::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;
        apiSimpleShape* shape = (apiSimpleShape*) surfaceShape();
        MVectorArray* geomPtr = shape->getControlPoints();

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

        // Stuff our data into the draw request, it'll be used when the drawing
        // actually happens
        getDrawData( geomPtr, 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();

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

                        // 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 );
                        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 apiSimpleShapeUI::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 :
                case kDrawVertices :
                        drawVertices( request, view );
                        break;

                case kDrawSmoothShaded :
                        break;                  // Not implemented, left as exercise

                case kDrawFlatShaded : // Not implemented, left as exercise
                        break;
        }
}

/* override */
bool apiSimpleShapeUI::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 ) 
        {
                // 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 = surfaceShape()->boundingBox().center();
                        xformedPt = center;
                        xformedPt *= selectInfo.selectPath().inclusiveMatrix();
                }

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

        return selected;
}

//
// Helper routines
//


void apiSimpleShapeUI::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();
        MVectorArray * geom = (MVectorArray*)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 );

        // 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() ) {
                MFnSingleIndexedComponent fnComponent( comp );
                for ( int i=0; i<fnComponent.elementCount(); i++ )
                {
                        int index = fnComponent.element( i );
                        glBegin( GL_POINTS );
                        MVector& point = (*geom)[index];
                        glVertex3f( (float)point[0], 
                                                (float)point[1], 
                                                (float)point[2] );
                        glEnd();

                        char annotation[32];
                        sprintf( annotation, "%d", index );
                        view.drawText( annotation, point );
                }
        }
        else {
                for ( unsigned int i=0; i<geom->length(); i++ )
                {
                        glBegin( GL_POINTS );
                        MVector point = (*geom)[ i ];
                        glVertex3f( (float)point[0], (float)point[1], (float)point[2] );
                        glEnd();
                }
        }

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

        view.endGL(); 
}

bool apiSimpleShapeUI::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
        //
        apiSimpleShape* shape = (apiSimpleShape*) surfaceShape();
        MVectorArray* geomPtr = shape->getControlPoints();
        MVectorArray& geom = *geomPtr;


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

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

                glBegin( GL_POINTS );
                glVertex3f( (float)point[0], 
                                        (float)point[1], 
                                        (float)point[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;
}