- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Examples

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

    //
    // DESCRIPTION:
    //      This is an example of using the built in texture cache for drawing.
    //

    #ifdef WIN32
    #pragma warning( disable : 4786 )       // Disable STL warnings.
    #endif

    #include <maya/MIOStream.h>
    #include <maya/MString.h>
    #include <maya/MPlug.h>
    #include <maya/MFnPlugin.h>
    #include <maya/MPxHwShaderNode.h>
    #include <maya/MFnMesh.h>

    #if MAYA_API_VERSION >= 800
        #include <maya/MHwTextureManager.h>
        #include <maya/MImageFileInfo.h>
    #endif

    #if defined(OSMac_MachO_)
    #include <OpenGL/gl.h>
    #include <OpenGL/glu.h>
    #else
    #include <GL/gl.h>
    #include <GL/glu.h>
    #endif

    class hwManagedTextureShader : public MPxHwShaderNode
    {
        public:
                        hwManagedTextureShader();
        virtual         ~hwManagedTextureShader();

        virtual void    postConstructor();

        virtual MStatus glBind(const MDagPath& shapePath);
        virtual MStatus glUnbind(const MDagPath& shapePath);
        virtual MStatus glGeometry( const MDagPath&,
                                  int prim,
                                  unsigned int writable,
                                  int indexCount,
                                  const unsigned int * indexArray,
                                  int vertexCount,
                                  const int * vertexIDs,
                                  const float * vertexArray,
                                  int normalCount,
                                  const float ** normalArrays,
                                  int colorCount,
                                  const float ** colorArrays,
                                  int texCoordCount,
                                  const float ** texCoordArrays);

        virtual int     texCoordsPerVertex();
        virtual int     normalsPerVertex();
        virtual bool    supportsBatching() const;

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

        GLboolean lightingOn;
        bool boundTexture;

        static  MTypeId id;
    };

    // This ID provided by Maya. Do not change.
    MTypeId hwManagedTextureShader::id( 0x81033 );

    void hwManagedTextureShader::postConstructor( )
    {
        setMPSafe(false);
    }

    hwManagedTextureShader::hwManagedTextureShader()
    {
    }

    hwManagedTextureShader::~hwManagedTextureShader()
    {
    }

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

    MStatus hwManagedTextureShader::initialize()
    {
        return MS::kSuccess;
    }

    /* virtual */
    MStatus
    hwManagedTextureShader::glBind(const MDagPath& path)
    {
        // ONLY push and pop required attributes performance reasons...
        //
        glPushAttrib(GL_LIGHTING_BIT);

        lightingOn = glIsEnabled(GL_LIGHTING);

        if (lightingOn)
        {
            glEnable(GL_COLOR_MATERIAL);
            glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
        }

        // Base colour is always white
        glColor4f(1.0f, 1.0f, 1.0f, 1.0f);

        // Bind texture
    #if MAYA_API_VERSION >= 800
        MObject object = path.node();
        MFnMesh mesh(object);
        MString uvSetName("map1");
        MObjectArray textures;

        boundTexture = false;
        MStatus status = mesh.getAssociatedUVSetTextures(uvSetName, textures);
        if (status == MS::kSuccess && textures.length())
        {
            MImageFileInfo::MHwTextureType hwType;
            if (MS::kSuccess == MHwTextureManager::glBind( textures[0], hwType ))
            {
                boundTexture = true;
            }
        }

        if( !boundTexture)
        {
            glDisable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, 0);
        }
    #else
        // To get this code branch to compile, replace <change file name here>
        // with an appropriate file name
        static GLuint id = 0;
        if (id == 0)
        {
            MImage fileImage;
            MStatus status = fileImage.readFromFile("<change file name here>");
            glGenTextures(1, &id);
            glEnable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, id);
            GLuint width, height;
            fileImage.getSize( width, height);
            glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, fileImage.pixels());
        }
        else
        {
            glEnable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, id);
        }
        boundTexture = true;

    #endif
        if( boundTexture)
        {
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        }
        glEnableClientState(GL_VERTEX_ARRAY);

        return MS::kSuccess;
    }

    /* virtual */
    MStatus
    hwManagedTextureShader::glUnbind(const MDagPath& shapePath)
    {
        // Cleanup GL state, without using pushing and popping attributes
        //
        glDisableClientState(GL_VERTEX_ARRAY);
        if (lightingOn)
        {
            glDisable(GL_COLOR_MATERIAL);
            glDisableClientState(GL_NORMAL_ARRAY);
        }
        if (boundTexture)
        {
            glDisableClientState( GL_TEXTURE_COORD_ARRAY );
            glDisable(GL_TEXTURE_2D);
            glBindTexture(GL_TEXTURE_2D, 0);
        }

        // ONLY push and pop required attributes performance reasons...
        //
        glPopAttrib();
        return MS::kSuccess;
    }

    bool
    hwManagedTextureShader::supportsBatching() const
    {
        return true;
    }

    /* virtual */
    MStatus hwManagedTextureShader::glGeometry( const MDagPath& path,
                                    int prim,
                                    unsigned int writable,
                                    int indexCount,
                                    const unsigned int * indexArray,
                                    int vertexCount,
                                    const int * vertexIDs,
                                    const float * vertexArray,
                                    int normalCount,
                                    const float ** normalArrays,
                                    int colorCount,
                                    const float ** colorArrays,
                                    int texCoordCount,
                                    const float ** texCoordArrays)
    {
        glVertexPointer ( 3, GL_FLOAT, 0, &vertexArray[0] );

        if (boundTexture && texCoordCount && texCoordArrays[0] != NULL)
        {
            glEnableClientState( GL_TEXTURE_COORD_ARRAY );
            glTexCoordPointer( 2, GL_FLOAT, 0, &texCoordArrays[0][0] );
        }
        else
        {
            glDisableClientState( GL_TEXTURE_COORD_ARRAY );
        }

        if (lightingOn && normalCount && normalArrays[0][0])
        {
            // Don't route normals if we don't need them
            glEnableClientState(GL_NORMAL_ARRAY);
            glNormalPointer ( GL_FLOAT, 0, &normalArrays[0][0] );
        }
        else
        {
            glDisableClientState( GL_NORMAL_ARRAY );
        }

        glDrawElements ( prim, indexCount, GL_UNSIGNED_INT, indexArray );

        return MS::kSuccess;
    }

    // virtual
    int hwManagedTextureShader::texCoordsPerVertex()
    {
        return 1;
    }

    // virtual
    int hwManagedTextureShader::normalsPerVertex()
    {
        return 1;
    }

    MStatus initializePlugin( MObject obj )
    {
        MStatus   status;

        const MString UserClassify( "shader/surface/utility/" );

        MFnPlugin plugin( obj, PLUGIN_COMPANY, "8.0", "Any");

        status = plugin.registerNode("hwManagedTextureShader",
                                     hwManagedTextureShader::id,
                                     hwManagedTextureShader::creator,
                                     hwManagedTextureShader::initialize,
                                     MPxNode::kHwShaderNode, &UserClassify );
        CHECK_MSTATUS(status);

        return status;
    }

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

        status = plugin.deregisterNode( hwManagedTextureShader::id );
        CHECK_MSTATUS(status);

        return status;
    }