footPrintNode/footPrintNode.cpp

//-
// ==========================================================================
// 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.
// ==========================================================================
//+
#if _MSC_VER >= 1700
#pragma warning( disable: 4005 )
#endif

#include <maya/MPxLocatorNode.h>
#include <maya/MString.h>
#include <maya/MDagPath.h>
#include <maya/MTypeId.h>
#include <maya/MPlug.h>
#include <maya/MVector.h>
#include <maya/MDataBlock.h>
#include <maya/MDataHandle.h>
#include <maya/MColor.h>
#include <maya/M3dView.h>
#include <maya/MFnPlugin.h>
#include <maya/MDistance.h>
#include <maya/MMatrix.h>
#include <maya/MFnUnitAttribute.h>

// Viewport 2.0 includes
#include <maya/MDrawRegistry.h>
#include <maya/MPxDrawOverride.h>
#include <maya/MUserData.h>
#include <maya/MDrawContext.h>
#include <maya/MGlobal.h>
#include <maya/MSelectionList.h>
#include <maya/MViewport2Renderer.h>
#include <maya/MHWGeometryUtilities.h>
#include <maya/MStateManager.h>
#include <maya/MShaderManager.h>
#include <maya/MRenderTargetManager.h>
#include <maya/MAnimControl.h>

#include <assert.h>

// DX stuff
#ifdef _WIN32

#define WIN32_LEAN_AND_MEAN
#include <d3d11.h>

#if _MSC_VER < 1700
    #include <d3dx11.h>
    #include <xnamath.h>
#else
    #include <dxgi.h>
    #include <DirectXMath.h>
    
    using namespace DirectX;
#endif

#include <d3dcompiler.h>


#ifndef D3DCOMPILE_ENABLE_STRICTNESS
    #define D3DCOMPILE_ENABLE_STRICTNESS D3D10_SHADER_ENABLE_STRICTNESS
    #define D3DCOMPILE_DEBUG D3D10_SHADER_DEBUG
#endif

#endif //_WIN32

// Foot Data
//
static float sole[][3] = { {  0.00f, 0.0f, -0.70f },
                           {  0.04f, 0.0f, -0.69f },
                           {  0.09f, 0.0f, -0.65f },
                           {  0.13f, 0.0f, -0.61f },
                           {  0.16f, 0.0f, -0.54f },
                           {  0.17f, 0.0f, -0.46f },
                           {  0.17f, 0.0f, -0.35f },
                           {  0.16f, 0.0f, -0.25f },
                           {  0.15f, 0.0f, -0.14f },
                           {  0.13f, 0.0f,  0.00f },
                           {  0.00f, 0.0f,  0.00f },
                           { -0.13f, 0.0f,  0.00f },
                           { -0.15f, 0.0f, -0.14f },
                           { -0.16f, 0.0f, -0.25f },
                           { -0.17f, 0.0f, -0.35f },
                           { -0.17f, 0.0f, -0.46f },
                           { -0.16f, 0.0f, -0.54f },
                           { -0.13f, 0.0f, -0.61f },
                           { -0.09f, 0.0f, -0.65f },
                           { -0.04f, 0.0f, -0.69f },
                           { -0.00f, 0.0f, -0.70f } };
static float heel[][3] = { {  0.00f, 0.0f,  0.06f },
                           {  0.13f, 0.0f,  0.06f },
                           {  0.14f, 0.0f,  0.15f },
                           {  0.14f, 0.0f,  0.21f },
                           {  0.13f, 0.0f,  0.25f },
                           {  0.11f, 0.0f,  0.28f },
                           {  0.09f, 0.0f,  0.29f },
                           {  0.04f, 0.0f,  0.30f },
                           {  0.00f, 0.0f,  0.30f },
                           { -0.04f, 0.0f,  0.30f },
                           { -0.09f, 0.0f,  0.29f },
                           { -0.11f, 0.0f,  0.28f },
                           { -0.13f, 0.0f,  0.25f },
                           { -0.14f, 0.0f,  0.21f },
                           { -0.14f, 0.0f,  0.15f },
                           { -0.13f, 0.0f,  0.06f },
                           { -0.00f, 0.0f,  0.06f } };
static int soleCount = 21;
static int heelCount = 17;

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Node implementation with standard viewport draw
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

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

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

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

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

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

    static  MObject         size;         // The size of the foot

public:
    static  MTypeId     id;
    static  MString     drawDbClassification;
    static  MString     drawRegistrantId;
};

MObject footPrint::size;
MTypeId footPrint::id( 0x80007 );
MString footPrint::drawDbClassification("drawdb/geometry/footPrint");
MString footPrint::drawRegistrantId("FootprintNodePlugin");

footPrint::footPrint() {}
footPrint::~footPrint() {}

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

void footPrint::draw( M3dView & view, const MDagPath & /*path*/,
                             M3dView::DisplayStyle style,
                             M3dView::DisplayStatus status )
{
    // Get the size
    //
    MObject thisNode = thisMObject();
    MPlug plug( thisNode, size );
    MDistance sizeVal;
    plug.getValue( sizeVal );

    float multiplier = (float) sizeVal.asCentimeters();

    view.beginGL();


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

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

        glBegin( GL_TRIANGLE_FAN );
            int i;
            int last = soleCount - 1;
            for ( i = 0; i < last; ++i ) {
                glVertex3f( sole[i][0] * multiplier,
                            sole[i][1] * multiplier,
                            sole[i][2] * multiplier );
            }
        glEnd();
        glBegin( GL_TRIANGLE_FAN );
            last = heelCount - 1;
            for ( i = 0; i < last; ++i ) {
                glVertex3f( heel[i][0] * multiplier,
                            heel[i][1] * multiplier,
                            heel[i][2] * multiplier );
            }
        glEnd();

        glPopAttrib();
    }

    // Draw the outline of the foot
    //
    glBegin( GL_LINES );
        int i;
        int last = soleCount - 1;
        for ( i = 0; i < last; ++i ) {
            glVertex3f( sole[i][0] * multiplier,
                        sole[i][1] * multiplier,
                        sole[i][2] * multiplier );
            glVertex3f( sole[i+1][0] * multiplier,
                        sole[i+1][1] * multiplier,
                        sole[i+1][2] * multiplier );
        }
        last = heelCount - 1;
        for ( i = 0; i < last; ++i ) {
            glVertex3f( heel[i][0] * multiplier,
                        heel[i][1] * multiplier,
                        heel[i][2] * multiplier );
            glVertex3f( heel[i+1][0] * multiplier,
                        heel[i+1][1] * multiplier,
                        heel[i+1][2] * multiplier );
        }
    glEnd();


    view.endGL();

    // Draw the name of the footPrint
    view.setDrawColor( MColor( 0.1f, 0.8f, 0.8f, 1.0f ) );
    view.drawText( MString("Footprint"), MPoint( 0.0, 0.0, 0.0 ), M3dView::kCenter );
}

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

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

    double multiplier = sizeVal.asCentimeters();

    MPoint corner1( -0.17, 0.0, -0.7 );
    MPoint corner2( 0.17, 0.0, 0.3 );

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

    return MBoundingBox( corner1, corner2 );
}

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

//---------------------------------------------------------------------------
//---------------------------------------------------------------------------
// Viewport 2.0 override implementation
//---------------------------------------------------------------------------
//---------------------------------------------------------------------------

class FootPrintData : public MUserData
{
public:
    FootPrintData() : MUserData(false) {} // don't delete after draw
    virtual ~FootPrintData() {}

    float fMultiplier;
    float fColor[3];
    bool  fCustomBoxDraw;
    MBoundingBox fCurrentBoundingBox;
    MDAGDrawOverrideInfo fDrawOV;
};

// Helper class declaration for the object drawing
class FootPrintDrawAgent
{
public:
    FootPrintDrawAgent(){}
    virtual ~FootPrintDrawAgent(){}

    virtual void drawShaded( float multiplier ) = 0;
    virtual void drawBoundingBox( const MPoint&, const MPoint&) = 0;
    virtual void drawWireframe( float multiplier ) = 0;
    virtual void beginDraw() = 0;
    virtual void endDraw() = 0;

    void setMatrix( const MMatrix& wvMatrix, const MMatrix& projMatrix ){
        mWorldViewMatrix = wvMatrix;
        mProjectionMatrix = projMatrix;
    }

    void setColor( const MColor& color){
        mColor = color;
    }

protected:
    MMatrix mWorldViewMatrix;
    MMatrix mProjectionMatrix;
    MColor  mColor;
};

// GL draw agent declaration
class FootPrintDrawAgentGL : public FootPrintDrawAgent
{
public:
    static FootPrintDrawAgentGL& getDrawAgent(){
        static FootPrintDrawAgentGL obj;
        return obj;
    }

    virtual void drawShaded( float multiplier );
    virtual void drawBoundingBox( const MPoint& min, const MPoint& max );
    virtual void drawWireframe( float multiplier );
    virtual void beginDraw();
    virtual void endDraw();
private:
    FootPrintDrawAgentGL(){}
    ~FootPrintDrawAgentGL(){}
    FootPrintDrawAgentGL( const FootPrintDrawAgentGL& v ){}
    FootPrintDrawAgentGL operator = (const FootPrintDrawAgentGL& v){ return *this; }
};

// DX stuff
#ifdef _WIN32

// DX draw agent declaration
class FootPrintDrawAgentDX : public FootPrintDrawAgent
{
public:
    static FootPrintDrawAgentDX& getDrawAgent(){
        static FootPrintDrawAgentDX obj;
        return obj;
    }

    virtual void drawShaded( float multiplier );
    virtual void drawBoundingBox( const MPoint& min, const MPoint& max );
    virtual void drawWireframe( float multiplier );
    virtual void beginDraw();
    virtual void endDraw();

    bool releaseDXResources();
private:
    ID3D11Device* mDevicePtr;
    ID3D11DeviceContext* mDeviceContextPtr;

    ID3D11Buffer* mBoundingboxVertexBufferPtr;
    ID3D11Buffer* mBoundingboxIndexBufferPtr;
    ID3D11Buffer* mSoleVertexBufferPtr;
    ID3D11Buffer* mHeelVertexBufferPtr;
    ID3D11Buffer* mSoleWireIndexBufferPtr;
    ID3D11Buffer* mSoleShadedIndexBufferPtr;
    ID3D11Buffer* mHeelWireIndexBufferPtr;
    ID3D11Buffer* mHeelShadedIndexBufferPtr;
    ID3D11Buffer* mConstantBufferPtr;
    ID3D11VertexShader* mVertexShaderPtr;
    ID3D11PixelShader* mPixelShaderPtr;
    ID3D11InputLayout* mVertexLayoutPtr;

    unsigned int mStride;
    unsigned int mOffset;
    struct ConstantBufferDef
    {
        XMMATRIX fWVP;
        XMFLOAT4 fMatColor;
    };
    bool initShadersDX();
    bool initBuffersDX();
    void setupConstantBuffer( const XMMATRIX& scale );
private:
    FootPrintDrawAgentDX():
        mDevicePtr(NULL), mDeviceContextPtr(NULL), mStride(sizeof(float)*3), mOffset(0),
        mBoundingboxVertexBufferPtr(NULL),
        mBoundingboxIndexBufferPtr(NULL),
        mSoleVertexBufferPtr(NULL),
        mHeelVertexBufferPtr(NULL),
        mSoleWireIndexBufferPtr(NULL),
        mSoleShadedIndexBufferPtr(NULL),
        mHeelWireIndexBufferPtr(NULL),
        mHeelShadedIndexBufferPtr(NULL),
        mConstantBufferPtr(NULL),
        mVertexShaderPtr(NULL),
        mPixelShaderPtr(NULL),
        mVertexLayoutPtr(NULL)
        {}
    ~FootPrintDrawAgentDX(){}
    FootPrintDrawAgentDX( const FootPrintDrawAgentDX& v ){}
    FootPrintDrawAgentDX operator = (const FootPrintDrawAgentDX& v){ return *this; }
};

#endif // _WIN32

// GL draw agent definition
//
void FootPrintDrawAgentGL::beginDraw()
{
    // set world view matrix
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadMatrixd(mWorldViewMatrix.matrix[0]);
    // set projection matrix
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadMatrixd(mProjectionMatrix.matrix[0]);
    glPushAttrib( GL_CURRENT_BIT );
}

void FootPrintDrawAgentGL::endDraw()
{
    glPopAttrib();
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
}

void FootPrintDrawAgentGL::drawShaded( float multiplier )
{
    // set color
    glColor4fv( &(mColor.r) );

    glBegin( GL_TRIANGLE_FAN );
    int i;
    int last = soleCount - 1;
    for ( i = 0; i < last; ++i ) {
        glVertex3f( sole[i][0] * multiplier,
            sole[i][1] * multiplier,
            sole[i][2] * multiplier );
    }
    glEnd();
    glBegin( GL_TRIANGLE_FAN );
    last = heelCount - 1;
    for ( i = 0; i < last; ++i ) {
        glVertex3f( heel[i][0] * multiplier,
            heel[i][1] * multiplier,
            heel[i][2] * multiplier );
    }
    glEnd();
}

void FootPrintDrawAgentGL::drawBoundingBox( const MPoint& min, const MPoint& max )
{
    // set color
    glColor4fv( &(mColor.r) );

    float bottomLeftFront[3] = { (float)min[0], (float)min[1], (float)min[2] };
    float topLeftFront[3] = { (float)min[0], (float)max[1], (float)min[2] }; //1
    float bottomRightFront[3] = { (float)max[0], (float)min[1], (float)min[2] }; //2
    float topRightFront[3] = { (float)max[0], (float)max[1], (float)min[2] }; //3
    float bottomLeftBack[3] = { (float)min[0], (float)min[1], (float)max[2] }; //4
    float topLeftBack[3] = { (float)min[0], (float)max[1], (float)max[2] }; //5
    float bottomRightBack[3] = { (float)max[0], (float)min[1], (float)max[2] }; //6
    float topRightBack[3] = { (float)max[0], (float)max[1], (float)max[2] }; //7

    glBegin( GL_LINES );

    // 4 Bottom lines
    //
    glVertex3fv( bottomLeftFront );
    glVertex3fv( bottomRightFront );
    glVertex3fv( bottomRightFront );
    glVertex3fv( bottomRightBack );
    glVertex3fv( bottomRightBack );
    glVertex3fv( bottomLeftBack );
    glVertex3fv( bottomLeftBack );
    glVertex3fv( bottomLeftFront );

    // 4 Top lines
    //
    glVertex3fv( topLeftFront );
    glVertex3fv( topRightFront );
    glVertex3fv( topRightFront );
    glVertex3fv( topRightBack );
    glVertex3fv( topRightBack );
    glVertex3fv( topLeftBack );
    glVertex3fv( topLeftBack );
    glVertex3fv( topLeftFront );

    // 4 Side lines
    //
    glVertex3fv( bottomLeftFront );
    glVertex3fv( topLeftFront );
    glVertex3fv( bottomRightFront );
    glVertex3fv( topRightFront );
    glVertex3fv( bottomRightBack );
    glVertex3fv( topRightBack );
    glVertex3fv( bottomLeftBack );
    glVertex3fv( topLeftBack );

    glEnd();
}

void FootPrintDrawAgentGL::drawWireframe( float multiplier )
{
    // set color
    glColor4fv( &(mColor.r) );

    // draw wire
    glBegin( GL_LINES );
    int i;
    int last = soleCount - 1;
    for ( i = 0; i < last; ++i ) {
        glVertex3f( sole[i][0] * multiplier,
            sole[i][1] * multiplier,
            sole[i][2] * multiplier );
        glVertex3f( sole[i+1][0] * multiplier,
            sole[i+1][1] * multiplier,
            sole[i+1][2] * multiplier );
    }
    last = heelCount - 1;
    for ( i = 0; i < last; ++i ) {
        glVertex3f( heel[i][0] * multiplier,
            heel[i][1] * multiplier,
            heel[i][2] * multiplier );
        glVertex3f( heel[i+1][0] * multiplier,
            heel[i+1][1] * multiplier,
            heel[i+1][2] * multiplier );
    }
    glEnd();
}

// DX stuff
#ifdef _WIN32
// DX draw agent definition
//
void FootPrintDrawAgentDX::beginDraw()
{
    // Initial device
    if( !mDevicePtr || !mDeviceContextPtr ){
        // get renderer
        MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
        if ( theRenderer ){
            mDevicePtr = (ID3D11Device*)theRenderer->GPUDeviceHandle();
            if ( mDevicePtr ){
                mDevicePtr->GetImmediateContext( &mDeviceContextPtr );
            }
        }
    }
    assert( mDevicePtr );
    assert( mDeviceContextPtr );

    if ( mDevicePtr && mDeviceContextPtr ){

        // Init shaders
        if ( initShadersDX() ){
            // Set up shader
            mDeviceContextPtr->VSSetShader(mVertexShaderPtr, NULL, 0);
            mDeviceContextPtr->IASetInputLayout(mVertexLayoutPtr);
            mDeviceContextPtr->PSSetShader(mPixelShaderPtr, NULL, 0);
        }

        // Init buffers
        initBuffersDX();
    }
}

void FootPrintDrawAgentDX::endDraw()
{}

void FootPrintDrawAgentDX::setupConstantBuffer( const XMMATRIX& scale )
{
    assert( mDeviceContextPtr );
    if ( !mDeviceContextPtr )
        return;

    // Compute matrix
    XMMATRIX dxTransform = XMMATRIX(
        (float)mWorldViewMatrix.matrix[0][0], (float)mWorldViewMatrix.matrix[0][1], (float)mWorldViewMatrix.matrix[0][2], (float)mWorldViewMatrix.matrix[0][3],
        (float)mWorldViewMatrix.matrix[1][0], (float)mWorldViewMatrix.matrix[1][1], (float)mWorldViewMatrix.matrix[1][2], (float)mWorldViewMatrix.matrix[1][3],
        (float)mWorldViewMatrix.matrix[2][0], (float)mWorldViewMatrix.matrix[2][1], (float)mWorldViewMatrix.matrix[2][2], (float)mWorldViewMatrix.matrix[2][3],
        (float)mWorldViewMatrix.matrix[3][0], (float)mWorldViewMatrix.matrix[3][1], (float)mWorldViewMatrix.matrix[3][2], (float)mWorldViewMatrix.matrix[3][3]);
    XMMATRIX dxProjection = XMMATRIX(
        (float)mProjectionMatrix.matrix[0][0], (float)mProjectionMatrix.matrix[0][1], (float)mProjectionMatrix.matrix[0][2], (float)mProjectionMatrix.matrix[0][3],
        (float)mProjectionMatrix.matrix[1][0], (float)mProjectionMatrix.matrix[1][1], (float)mProjectionMatrix.matrix[1][2], (float)mProjectionMatrix.matrix[1][3],
        (float)mProjectionMatrix.matrix[2][0], (float)mProjectionMatrix.matrix[2][1], (float)mProjectionMatrix.matrix[2][2], (float)mProjectionMatrix.matrix[2][3],
        (float)mProjectionMatrix.matrix[3][0], (float)mProjectionMatrix.matrix[3][1], (float)mProjectionMatrix.matrix[3][2], (float)mProjectionMatrix.matrix[3][3]);

    // Set constant buffer
    ConstantBufferDef cb;
    cb.fWVP = XMMatrixTranspose(scale * dxTransform * dxProjection);
    cb.fMatColor = XMFLOAT4( mColor.r, mColor.g, mColor.b, mColor.a);
    mDeviceContextPtr->UpdateSubresource(mConstantBufferPtr, 0, NULL, &cb, 0, 0);
    mDeviceContextPtr->VSSetConstantBuffers(0, 1, &mConstantBufferPtr);
    mDeviceContextPtr->PSSetConstantBuffers(0, 1, &mConstantBufferPtr);
}

void FootPrintDrawAgentDX::drawShaded( float multiplier )
{
    assert( mDeviceContextPtr );
    if ( !mDeviceContextPtr )
        return;

    // Set constant buffer
    XMMATRIX scale(
        multiplier, 0.0f, 0.0f, 0.0f,
        0.0f, multiplier, 0.0f, 0.0f,
        0.0f, 0.0f, multiplier, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f );
    setupConstantBuffer( scale );

    // Draw the sole
    mDeviceContextPtr->IASetVertexBuffers(0, 1, &mSoleVertexBufferPtr, &mStride, &mOffset);
    mDeviceContextPtr->IASetIndexBuffer(mSoleShadedIndexBufferPtr, DXGI_FORMAT_R16_UINT, 0);
    mDeviceContextPtr->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    mDeviceContextPtr->DrawIndexed(3 * (soleCount-2), 0, 0);
    // Draw the heel
    mDeviceContextPtr->IASetVertexBuffers(0, 1, &mHeelVertexBufferPtr, &mStride, &mOffset);
    mDeviceContextPtr->IASetIndexBuffer(mHeelShadedIndexBufferPtr, DXGI_FORMAT_R16_UINT, 0);
    mDeviceContextPtr->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
    mDeviceContextPtr->DrawIndexed(3 * (heelCount-2), 0, 0);
}

void FootPrintDrawAgentDX::drawBoundingBox( const MPoint& min, const MPoint& max )
{
    assert( mDeviceContextPtr );
    if ( !mDeviceContextPtr )
        return;

    // Set constant buffer
    XMMATRIX scale(
        static_cast<float>(max[0]- min[0]), 0.0f, 0.0f, 0.0f,
        0.0f, static_cast<float>(max[1]-min[1]), 0.0f, 0.0f,
        0.0f, 0.0f, static_cast<float>(max[2]-min[2]), 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f );
    setupConstantBuffer( scale );

    mDeviceContextPtr->IASetVertexBuffers(0, 1, &mBoundingboxVertexBufferPtr, &mStride, &mOffset);
    mDeviceContextPtr->IASetIndexBuffer(mBoundingboxIndexBufferPtr, DXGI_FORMAT_R16_UINT, 0);
    mDeviceContextPtr->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
    mDeviceContextPtr->DrawIndexed(2 * 12, 0, 0);
}

void FootPrintDrawAgentDX::drawWireframe( float multiplier )
{
    assert( mDeviceContextPtr );
    if ( !mDeviceContextPtr )
        return;

    // Set constant buffer
    XMMATRIX scale(
        multiplier, 0.0f, 0.0f, 0.0f,
        0.0f, multiplier, 0.0f, 0.0f,
        0.0f, 0.0f, multiplier, 0.0f,
        0.0f, 0.0f, 0.0f, 1.0f );
    setupConstantBuffer( scale );

    // Draw the sole
    mDeviceContextPtr->IASetVertexBuffers(0, 1, &mSoleVertexBufferPtr, &mStride, &mOffset);
    mDeviceContextPtr->IASetIndexBuffer(mSoleWireIndexBufferPtr, DXGI_FORMAT_R16_UINT, 0);
    mDeviceContextPtr->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
    mDeviceContextPtr->DrawIndexed(2 * (soleCount-1), 0, 0);
    // Draw the heel
    mDeviceContextPtr->IASetVertexBuffers(0, 1, &mHeelVertexBufferPtr, &mStride, &mOffset);
    mDeviceContextPtr->IASetIndexBuffer(mHeelWireIndexBufferPtr, DXGI_FORMAT_R16_UINT, 0);
    mDeviceContextPtr->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
    mDeviceContextPtr->DrawIndexed(2 * (heelCount-1), 0, 0);
}

#endif // _WIN32


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

    virtual ~FootPrintDrawOverride();

    virtual MHWRender::DrawAPI supportedDrawAPIs() const;

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

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

    virtual bool disableInternalBoundingBoxDraw() const;

    virtual MUserData* prepareForDraw(
        const MDagPath& objPath,
        const MDagPath& cameraPath,
        const MHWRender::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:
    MBoundingBox mCurrentBoundingBox;
    bool         mCustomBoxDraw;
private:
    FootPrintDrawOverride(const MObject& obj);
    float getMultiplier(const MDagPath& objPath) const;
};

FootPrintDrawOverride::FootPrintDrawOverride(const MObject& obj)
: MHWRender::MPxDrawOverride(obj, FootPrintDrawOverride::draw)
// We want to perform custom bounding box drawing
// so return true so that the internal rendering code
// will not draw it for us.
, mCustomBoxDraw(true)
{
}

FootPrintDrawOverride::~FootPrintDrawOverride()
{
}

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

float FootPrintDrawOverride::getMultiplier(const MDagPath& objPath) const
{
    // Retrieve value of the size attribute from the node
    MStatus status;
    MObject footprintNode = objPath.node(&status);
    if (status)
    {
        MPlug plug(footprintNode, footPrint::size);
        if (!plug.isNull())
        {
            MDistance sizeVal;
            if (plug.getValue(sizeVal))
            {
                return (float)sizeVal.asCentimeters();
            }
        }
    }

    return 1.0f;
}

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

MBoundingBox FootPrintDrawOverride::boundingBox(
    const MDagPath& objPath,
    const MDagPath& cameraPath) const
{
    MPoint corner1( -0.17, 0.0, -0.7 );
    MPoint corner2( 0.17, 0.0, 0.3 );

    float multiplier = getMultiplier(objPath);
    corner1 = corner1 * multiplier;
    corner2 = corner2 * multiplier;

    FootPrintDrawOverride *nonConstThis = (FootPrintDrawOverride *)this;
    nonConstThis->mCurrentBoundingBox.clear();
    nonConstThis->mCurrentBoundingBox.expand( corner1 );
    nonConstThis->mCurrentBoundingBox.expand( corner2 );

    return mCurrentBoundingBox;
}

bool FootPrintDrawOverride::disableInternalBoundingBoxDraw() const
{
    return mCustomBoxDraw;
}

MUserData* FootPrintDrawOverride::prepareForDraw(
    const MDagPath& objPath,
    const MDagPath& cameraPath,
    const MHWRender::MFrameContext& frameContext,
    MUserData* oldData)
{
    // Retrieve data cache (create if does not exist)
    FootPrintData* data = dynamic_cast<FootPrintData*>(oldData);
    if (!data)
    {
        data = new FootPrintData();
    }

    // compute data and cache it
    data->fMultiplier = getMultiplier(objPath);
    MColor color = MHWRender::MGeometryUtilities::wireframeColor(objPath);
    data->fColor[0] = color.r;
    data->fColor[1] = color.g;
    data->fColor[2] = color.b;
    data->fCustomBoxDraw = mCustomBoxDraw;
    data->fCurrentBoundingBox = mCurrentBoundingBox;

    // Get the draw override information
    data->fDrawOV = objPath.getDrawOverrideInfo();

    return data;
}

void FootPrintDrawOverride::addUIDrawables(
        const MDagPath& objPath,
        MHWRender::MUIDrawManager& drawManager,
        const MHWRender::MFrameContext& frameContext,
        const MUserData* data)
{
    // Draw a text "Foot"
    MPoint pos( 0.0, 0.0, 0.0 ); // Position of the text
    MColor textColor( 0.1f, 0.8f, 0.8f, 1.0f ); // Text color

    drawManager.beginDrawable();

    drawManager.setColor( textColor );
    drawManager.setFontSize( MHWRender::MUIDrawManager::kSmallFontSize );
    drawManager.text( pos,  MString("Footprint"), MHWRender::MUIDrawManager::kCenter );

    drawManager.endDrawable();
}

void FootPrintDrawOverride::draw(const MHWRender::MDrawContext& context, const MUserData* data)
{
    // Get user draw data
    const FootPrintData* footData = dynamic_cast<const FootPrintData*>(data);
    if (!footData)
        return;

    // Get DAG object draw override
    const MDAGDrawOverrideInfo& objectOverrideInfo = footData->fDrawOV;

    // Sample code to determine the rendering destination
    bool debugDestination = false;
    if (debugDestination)
    {
        MString destinationIdentifier;
        MHWRender::MFrameContext::RenderingDestination dest = context.renderingDestination(destinationIdentifier);
        MString destinationType = " 3d viewport";
        if (dest == MHWRender::MFrameContext::k2dViewport)
            destinationType = " 2d viewport";
        else if (dest == MHWRender::MFrameContext::kImage)
            destinationType = "n image";
        printf("footprint node render destination is a%s. Destination name=%s\n", destinationType.asChar(), destinationIdentifier.asChar());
    }

    // Just return and draw nothing, if it is overridden invisible
    if ( objectOverrideInfo.fOverrideEnabled && !objectOverrideInfo.fEnableVisible )
        return;

    // Get display status
    const unsigned int displayStyle = context.getDisplayStyle();
    bool drawAsBoundingbox =
        (displayStyle & MHWRender::MFrameContext::kBoundingBox) ||
        (footData->fDrawOV.fLOD == MDAGDrawOverrideInfo::kLODBoundingBox);
    // If we don't want to draw the bounds within this plugin
    // manually, then skip drawing altogether in bounding box mode
    // since the bounds draw is handled by the renderer and
    // doesn't need to be drawn here.
    //
    if ( drawAsBoundingbox && !footData->fCustomBoxDraw )
    {
        return;
    }

    bool animPlay = MAnimControl::isPlaying();
    bool animScrub = MAnimControl::isScrubbing();
    // If in playback but hidden in playback, skip drawing
    if (!objectOverrideInfo.fPlaybackVisible &&
        (animPlay || animScrub))
    {
        return;
    }   
    // For any viewport interactions switch to bounding box mode,
    // except when we are in playback.
    if (context.inUserInteraction() || context.userChangingViewContext())
    {
        if (!animPlay && !animScrub)
            drawAsBoundingbox = true;
    }

    // Now, something gonna draw...

    // Get renderer
    MHWRender::MRenderer* theRenderer = MHWRender::MRenderer::theRenderer();
    if (!theRenderer)
        return;

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

    // Check to see if we are drawing in a shadow pass.
    // If so then we keep the shading simple which in this
    // example means to disable any extra blending state changes
    //
    const MHWRender::MPassContext & passCtx = context.getPassContext();
    const MStringArray & passSem = passCtx.passSemantics();
    bool castingShadows = false;
    for (unsigned int i=0; i<passSem.length(); i++)
    {
        if (passSem[i] == MHWRender::MPassContext::kShadowPassSemantic)
            castingShadows = true;
    }
    bool debugPassInformation = false;
    if (debugPassInformation)
    {
        const MString & passId = passCtx.passIdentifier();
        printf("footprint node drawing in pass[%s], semantic[", passId.asChar());
        for (unsigned int i=0; i<passSem.length(); i++)
            printf(" %s", passSem[i].asChar());
        printf("\n");
    }

    // get cached data
    float multiplier = footData->fMultiplier;
    float color[4] = {
            footData->fColor[0],
            footData->fColor[1],
            footData->fColor[2],
            1.0f
    };

    bool requireBlending = false;

    // If we're not casting shadows then do extra work
    // for display styles
    if (!castingShadows)
    {

        // Use some monotone version of color to show "default material mode"
        //
        if (displayStyle & MHWRender::MFrameContext::kDefaultMaterial)
        {
            color[0] = color[1] = color[2] = (color[0] + color[1] + color[2]) / 3.0f;
        }
        // Do some alpha blending if in x-ray mode
        //
        else if (displayStyle & MHWRender::MFrameContext::kXray)
        {
            requireBlending = true;
            color[3] = 0.3f;
        }
    }

    // Set blend and raster state
    //
    MHWRender::MStateManager* stateMgr = context.getStateManager();
    const MHWRender::MBlendState* pOldBlendState = NULL;
    const MHWRender::MRasterizerState* pOldRasterState = NULL;
    bool rasterStateModified = false;

    if(stateMgr && (displayStyle & MHWRender::MFrameContext::kGouraudShaded))
    {
        // draw filled, and with blending if required
        if (stateMgr && requireBlending)
        {
            static const MHWRender::MBlendState* blendState = NULL;
            if (!blendState)
            {
                MHWRender::MBlendStateDesc desc;
                desc.targetBlends[0].blendEnable = true;
                desc.targetBlends[0].destinationBlend = MHWRender::MBlendState::kInvSourceAlpha;
                desc.targetBlends[0].alphaDestinationBlend = MHWRender::MBlendState::kInvSourceAlpha;
                blendState = stateMgr->acquireBlendState(desc);
            }

            if (blendState)
            {
                pOldBlendState = stateMgr->getBlendState();
                stateMgr->setBlendState(blendState);
            }
        }

        // Override culling mode since we always want double-sided
        //
        pOldRasterState = stateMgr ? stateMgr->getRasterizerState() : NULL;
        if (pOldRasterState)
        {
            MHWRender::MRasterizerStateDesc desc( pOldRasterState->desc() );
            // It's also possible to change this to kCullFront or kCullBack if we
            // wanted to set it to that.
            MHWRender::MRasterizerState::CullMode cullMode = MHWRender::MRasterizerState::kCullNone;
            if (desc.cullMode != cullMode)
            {
                static const MHWRender::MRasterizerState *rasterState = NULL;
                if (!rasterState)
                {
                    // Just override the cullmode
                    desc.cullMode = cullMode;
                    rasterState = stateMgr->acquireRasterizerState(desc);
                }
                if (rasterState)
                {
                    rasterStateModified = true;
                    stateMgr->setRasterizerState(rasterState);
                }
            }
        }
    }

    //========================
    // Start the draw work
    //========================

    // Prepare draw agent, default using OpenGL
    FootPrintDrawAgentGL& drawAgentRef = FootPrintDrawAgentGL::getDrawAgent();
    FootPrintDrawAgent* drawAgentPtr = &drawAgentRef;
#ifdef _WIN32
    // DX Draw
    if ( !theRenderer->drawAPIIsOpenGL() )
    {
        FootPrintDrawAgentDX& drawAgentRef = FootPrintDrawAgentDX::getDrawAgent();
        drawAgentPtr = &drawAgentRef;
    }
#endif
    assert( drawAgentPtr );

    if ( drawAgentPtr ){

        // Set color
        drawAgentPtr->setColor( MColor(color[0],color[1],color[2],color[3]) );
        // Set matrix
        drawAgentPtr->setMatrix( transform, projection );

        drawAgentPtr->beginDraw();

        if ( drawAsBoundingbox )
        {
            // If it is in bounding bode, draw only bounding box wireframe, nothing else
            MPoint min = footData->fCurrentBoundingBox.min();
            MPoint max = footData->fCurrentBoundingBox.max();

            drawAgentPtr->drawBoundingBox( min, max );
        } else {
            // Templated, only draw wirefame and it is not selectale
            const bool overideTemplated = objectOverrideInfo.fOverrideEnabled &&
                (objectOverrideInfo.fDisplayType == MDAGDrawOverrideInfo::kDisplayTypeTemplate);
            // Override no shaded, only show wireframe
            const bool overrideNoShaded = objectOverrideInfo.fOverrideEnabled && !objectOverrideInfo.fEnableShading;

            if ( overideTemplated || overrideNoShaded ){
                drawAgentPtr->drawWireframe( multiplier );
            } else {
                if( (displayStyle & MHWRender::MFrameContext::kGouraudShaded) ||
                    (displayStyle & MHWRender::MFrameContext::kTextured))
                {
                    drawAgentPtr->drawShaded( multiplier );
                }

                if(displayStyle & MHWRender::MFrameContext::kWireFrame)
                {
                    drawAgentPtr->drawWireframe( multiplier );
                }
            }
        }

        drawAgentPtr->endDraw();
    }

    //========================
    // End the draw work
    //========================

    // Restore old blend state and old raster state
    if(stateMgr && (displayStyle & MHWRender::MFrameContext::kGouraudShaded))
    {
        if (stateMgr && pOldBlendState)
        {
            stateMgr->setBlendState(pOldBlendState);
        }
        if (rasterStateModified && pOldRasterState)
        {
            stateMgr->setRasterizerState(pOldRasterState);
        }
    }
}

// DX stuff
#ifdef _WIN32

bool FootPrintDrawAgentDX::initShadersDX()
{
    assert( mDevicePtr );
    if ( !mDevicePtr )
        return false;

    HRESULT hr;
    DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
    ID3DBlob* vsBlob = NULL;
    ID3DBlob* psBlob = NULL;
    ID3DBlob* pErrorBlob;
    MString effectLocation(
        MString(getenv("MAYA_LOCATION")) +
        MString("\\devkit\\plug-ins") +
        MString("\\footprint.hlsl"));

    // VS
    if (!mVertexShaderPtr)
    {
#if _MSC_VER < 1700
        hr = D3DX11CompileFromFile(
            effectLocation.asChar(),
            NULL,
            NULL,
            "mainVS",
            "vs_5_0",
            dwShaderFlags,
            0,
            NULL,
            &vsBlob,
            &pErrorBlob,
            NULL);
#else
        hr = D3DCompileFromFile(
            effectLocation.asWChar(),
            NULL,
            NULL,
            "mainVS",
            "vs_5_0",
            dwShaderFlags,
            0,
            &vsBlob,
            &pErrorBlob);
#endif
        if (FAILED(hr))
        {
            printf("Failed to compile vertex shader\n");
            if (pErrorBlob) pErrorBlob->Release();
            return false;
        }
        if (pErrorBlob) pErrorBlob->Release();
        hr = mDevicePtr->CreateVertexShader(
            vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), NULL, &mVertexShaderPtr);
        if (FAILED(hr))
        {
            printf("Failed to create vertex shader\n");
            vsBlob->Release();
            return false;
        }
    }

    // Layout
    if (!mVertexLayoutPtr)
    {
        D3D11_INPUT_ELEMENT_DESC layout[] =
        {
            { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
        };
        int numLayoutElements = sizeof layout/sizeof layout[0];
        hr = mDevicePtr->CreateInputLayout(
            layout, numLayoutElements, vsBlob->GetBufferPointer(), vsBlob->GetBufferSize(), &mVertexLayoutPtr);
        vsBlob->Release();
        if (FAILED(hr))
        {
            printf("Failed to create input layout\n");
            return false;
        }
    }

    // PS
    if (!mPixelShaderPtr)
    {
#if _MSC_VER < 1700
        hr = D3DX11CompileFromFile(
            effectLocation.asChar(),
            NULL,
            NULL,
            "mainPS",
            "ps_5_0",
            dwShaderFlags,
            0,
            NULL,
            &psBlob,
            &pErrorBlob,
            NULL);
#else
        hr = D3DCompileFromFile(
            effectLocation.asWChar(),
            NULL,
            NULL,
            "mainPS",
            "ps_5_0",
            dwShaderFlags,
            0,
            &psBlob,
            &pErrorBlob);
#endif
        if (FAILED(hr))
        {
            printf("Failed to compile vertex shader\n");
            mVertexShaderPtr->Release();
            mVertexLayoutPtr->Release();
            if (pErrorBlob) pErrorBlob->Release();
            return false;
        }
        if (pErrorBlob) pErrorBlob->Release();
        hr = mDevicePtr->CreatePixelShader(
            psBlob->GetBufferPointer(), psBlob->GetBufferSize(), NULL, &mPixelShaderPtr);
        psBlob->Release();
        if (FAILED(hr))
        {
            printf("Failed to create pixel shader\n");
            mVertexShaderPtr->Release();
            mVertexLayoutPtr->Release();
            return false;
        }
    }

    return true;
}

bool FootPrintDrawAgentDX::initBuffersDX()
{
    assert( mDevicePtr );
    if ( !mDevicePtr )
        return false;

    HRESULT hr;
    D3D11_BUFFER_DESC bd;
    ZeroMemory(&bd, sizeof(bd));
    D3D11_SUBRESOURCE_DATA InitData;
    ZeroMemory(&InitData, sizeof(InitData));


    if (!mBoundingboxVertexBufferPtr)
    {
        // 8 Vertices for drawing the bounding box in DX mode
        float bbData[][3] = {
            { -0.5, -0.5f, -0.5f},
            {  0.5, -0.5f, -0.5f},
            {  0.5, -0.5f,  0.5f},
            { -0.5, -0.5f,  0.5f},
            { -0.5,  0.5f, -0.5f},
            {  0.5,  0.5f, -0.5f},
            {  0.5,  0.5f,  0.5f},
            { -0.5,  0.5f,  0.5f}};

        bd.Usage = D3D11_USAGE_IMMUTABLE;
        bd.ByteWidth = sizeof(float) * 3 * 8;
        bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
        bd.CPUAccessFlags = 0;
        InitData.pSysMem = bbData;
        hr = mDevicePtr->CreateBuffer(&bd, &InitData, &mBoundingboxVertexBufferPtr);
        if (FAILED(hr)) return false;
    }
    if( !mBoundingboxIndexBufferPtr ){
        unsigned short bbWireIndices[] =
        {
            0,1,
            1,2,
            2,3,
            3,0,
            4,5,
            5,6,
            6,7,
            7,4,
            0,4,
            1,5,
            2,6,
            3,7
        };
        bd.Usage = D3D11_USAGE_IMMUTABLE;
        bd.ByteWidth = sizeof(unsigned short) * 2 * 12;
        bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
        bd.CPUAccessFlags = 0;
        InitData.pSysMem = bbWireIndices;
        hr = mDevicePtr->CreateBuffer(&bd, &InitData, &mBoundingboxIndexBufferPtr);
        if (FAILED(hr)) return false;
    }


    if (!mSoleVertexBufferPtr)
    {
        bd.Usage = D3D11_USAGE_IMMUTABLE;
        bd.ByteWidth = sizeof(float) * 3 * soleCount;
        bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
        bd.CPUAccessFlags = 0;
        InitData.pSysMem = sole;
        hr = mDevicePtr->CreateBuffer(&bd, &InitData, &mSoleVertexBufferPtr);
        if (FAILED(hr)) return false;
    }
    if (!mHeelVertexBufferPtr)
    {
        bd.Usage = D3D11_USAGE_IMMUTABLE;
        bd.ByteWidth = sizeof(float) * 3 * heelCount;
        bd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
        bd.CPUAccessFlags = 0;
        InitData.pSysMem = heel;
        hr = mDevicePtr->CreateBuffer(&bd, &InitData, &mHeelVertexBufferPtr);
        if (FAILED(hr)) return false;
    }
    if (!mSoleWireIndexBufferPtr)
    {
        unsigned short soleWireIndices[] =
        {
            0, 1,
            1, 2,
            2, 3,
            3, 4,
            4, 5,
            5, 6,
            6, 7,
            7, 8,
            8, 9,
            9, 10,
            10, 11,
            11, 12,
            12, 13,
            13, 14,
            14, 15,
            15, 16,
            16, 17,
            17, 18,
            18, 19,
            19, 20
        };
        bd.Usage = D3D11_USAGE_IMMUTABLE;
        bd.ByteWidth = sizeof(unsigned short) * 2 * (soleCount-1);
        bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
        bd.CPUAccessFlags = 0;
        InitData.pSysMem = soleWireIndices;
        hr = mDevicePtr->CreateBuffer(&bd, &InitData, &mSoleWireIndexBufferPtr);
        if (FAILED(hr)) return false;
    }
    if (!mHeelWireIndexBufferPtr)
    {
        unsigned short heelWireIndices[] =
        {
            0, 1,
            1, 2,
            2, 3,
            3, 4,
            4, 5,
            5, 6,
            6, 7,
            7, 8,
            8, 9,
            9, 10,
            10, 11,
            11, 12,
            12, 13,
            13, 14,
            14, 15,
            15, 16
        };
        bd.Usage = D3D11_USAGE_IMMUTABLE;
        bd.ByteWidth = sizeof(unsigned short) * 2 * (heelCount-1);
        bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
        bd.CPUAccessFlags = 0;
        InitData.pSysMem = heelWireIndices;
        hr = mDevicePtr->CreateBuffer(&bd, &InitData, &mHeelWireIndexBufferPtr);
        if (FAILED(hr)) return false;
    }
    if (!mSoleShadedIndexBufferPtr)
    {
        unsigned short soleShadedIndices[] =
        {
            0, 1, 2,
            0, 2, 3,
            0, 3, 4,
            0, 4, 5,
            0, 5, 6,
            0, 6, 7,
            0, 7, 8,
            0, 8, 9,
            0, 9, 10,
            0, 10, 11,
            0, 11, 12,
            0, 12, 13,
            0, 13, 14,
            0, 14, 15,
            0, 15, 16,
            0, 16, 17,
            0, 17, 18,
            0, 18, 19,
            0, 19, 20
        };
        bd.Usage = D3D11_USAGE_IMMUTABLE;
        bd.ByteWidth = sizeof(unsigned short) * 3 * (soleCount-2);
        bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
        bd.CPUAccessFlags = 0;
        InitData.pSysMem = soleShadedIndices;
        hr = mDevicePtr->CreateBuffer(&bd, &InitData, &mSoleShadedIndexBufferPtr);
        if (FAILED(hr)) return false;
    }
    if (!mHeelShadedIndexBufferPtr)
    {
        unsigned short heelShadedIndices[] =
        {
            0, 1, 2,
            0, 2, 3,
            0, 3, 4,
            0, 4, 5,
            0, 5, 6,
            0, 6, 7,
            0, 7, 8,
            0, 8, 9,
            0, 9, 10,
            0, 10, 11,
            0, 11, 12,
            0, 12, 13,
            0, 13, 14,
            0, 14, 15,
            0, 15, 16
        };
        bd.Usage = D3D11_USAGE_IMMUTABLE;
        bd.ByteWidth = sizeof(unsigned short) * 3 * (heelCount-2);
        bd.BindFlags = D3D11_BIND_INDEX_BUFFER;
        bd.CPUAccessFlags = 0;
        InitData.pSysMem = heelShadedIndices;
        hr = mDevicePtr->CreateBuffer(&bd, &InitData, &mHeelShadedIndexBufferPtr);
        if (FAILED(hr)) return false;
    }
    if (!mConstantBufferPtr)
    {
        bd.Usage = D3D11_USAGE_DEFAULT;
        bd.ByteWidth = sizeof(ConstantBufferDef);
        bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
        bd.CPUAccessFlags = 0;
        hr = mDevicePtr->CreateBuffer(&bd, NULL, &mConstantBufferPtr);
        if (FAILED(hr)) return false;
    }

    return true;
}

bool FootPrintDrawAgentDX::releaseDXResources()
{
    if (mBoundingboxVertexBufferPtr)
    {
        mBoundingboxVertexBufferPtr->Release();
        mBoundingboxVertexBufferPtr = NULL;
    }
    if (mBoundingboxIndexBufferPtr)
    {
        mBoundingboxIndexBufferPtr->Release();
        mBoundingboxIndexBufferPtr = NULL;
    }

    if (mSoleVertexBufferPtr)
    {
        mSoleVertexBufferPtr->Release();
        mSoleVertexBufferPtr = NULL;
    }
    if (mHeelVertexBufferPtr)
    {
        mHeelVertexBufferPtr->Release();
        mHeelVertexBufferPtr = NULL;
    }
    if (mSoleWireIndexBufferPtr)
    {
        mSoleWireIndexBufferPtr->Release();
        mSoleWireIndexBufferPtr = NULL;
    }
    if (mSoleShadedIndexBufferPtr)
    {
        mSoleShadedIndexBufferPtr->Release();
        mSoleShadedIndexBufferPtr = NULL;
    }
    if (mHeelWireIndexBufferPtr)
    {
        mHeelWireIndexBufferPtr->Release();
        mHeelWireIndexBufferPtr = NULL;
    }
    if (mHeelShadedIndexBufferPtr)
    {
        mHeelShadedIndexBufferPtr->Release();
        mHeelShadedIndexBufferPtr = NULL;
    }
    if (mVertexShaderPtr)
    {
        mVertexShaderPtr->Release();
        mVertexShaderPtr = NULL;
    }
    if (mPixelShaderPtr)
    {
        mPixelShaderPtr->Release();
        mPixelShaderPtr = NULL;
    }
    if (mVertexLayoutPtr)
    {
        mVertexLayoutPtr->Release();
        mVertexLayoutPtr = NULL;
    }
    if (mConstantBufferPtr)
    {
        mConstantBufferPtr->Release();
        mConstantBufferPtr = NULL;
    }

    return true;
}

#endif // _WIN32

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

MStatus footPrint::initialize()
{
    MFnUnitAttribute unitFn;
    MStatus          stat;

    size = unitFn.create( "size", "sz", MFnUnitAttribute::kDistance );
    unitFn.setDefault( 1.0 );

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

    return MS::kSuccess;
}

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

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

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

    return status;
}

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

    status = MHWRender::MDrawRegistry::deregisterDrawOverrideCreator(
        footPrint::drawDbClassification,
        footPrint::drawRegistrantId);
    if (!status) {
        status.perror("deregisterDrawOverrideCreator");
        return status;
    }

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

    // Release DX resource
#ifdef _WIN32
    FootPrintDrawAgentDX& drawAgentRef = FootPrintDrawAgentDX::getDrawAgent();
    drawAgentRef.releaseDXResources();
#endif

    return status;
}