cgFx/cgfxVector.cpp

//
// Copyright (C) 2002 NVIDIA 
// 
// File: cgfxVector.cpp
//
// Dependency Graph Node: cgfxVector
//
// Description:
//  The cgfxVector node is used to convert a vector in the scene to
//  world coordinates.  The inputs are a vector in local coordinates,
//  a flag indicating whether the vector is a position or a direction,
//  and a matrix that will transoform the vector to world coordinates.
//  This matrix is generally the worldInverseMatrix of the vector.
//
// Author: Jim Atkinson
//
//-
// ==========================================================================
// 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.
// ==========================================================================
//+
#include "cgfxShaderCommon.h"

#include "cgfxVector.h"

#include <maya/MMatrix.h>
#include <maya/MFnMatrixAttribute.h>
#include <maya/MFnMatrixData.h>
#include <maya/MFnNumericAttribute.h>
#include <maya/MPlug.h>

// The typeid is a unique 32bit indentifier that describes this node.
// It is used to save and retrieve nodes of this type from the binary
// file format.  If it is not unique, it will cause file IO problems.
//
#ifdef _WIN32
MTypeId cgfxVector::sId( 4084862001 );
#else
MTypeId cgfxVector::sId( 0xF37A0C31 );
#endif

// There needs to be a MObject handle declared for each attribute that
// the node will have.  These handles are needed for getting and setting
// the values later.
//
// Input vector attribute
//
MObject cgfxVector::sVector;

MObject cgfxVector::sVectorX;
MObject cgfxVector::sVectorY;
MObject cgfxVector::sVectorZ;

// Input position/direction flag.  If isDirection is set then
// the vector represents a direction and the W coordinate is
// 0.0.  If it is not set then W is 1.0.
//
MObject cgfxVector::sIsDirection;

// Input matrix attribute
//
MObject cgfxVector::sMatrix;

// Output world coordinate vector attribute
//
MObject cgfxVector::sWorldVector;
MObject cgfxVector::sWorldVectorX;
MObject cgfxVector::sWorldVectorY;
MObject cgfxVector::sWorldVectorZ;
MObject cgfxVector::sWorldVectorW;

cgfxVector::cgfxVector()
{
    // Nothing to construct
}

/* virtual */
cgfxVector::~cgfxVector()
{
    // Nothing to destruct
}

/* virtual */
MStatus cgfxVector::compute( const MPlug& plug, MDataBlock& data )
{
    MStatus status;

    if( plug == sWorldVector ||
        plug == sWorldVectorX ||
        plug == sWorldVectorY ||
        plug == sWorldVectorZ ||
        plug == sWorldVectorW)
    {
        // We do isDirection first simply because if there is an
        // error, the isDirection error is more legible than the
        // vector or matrix error.
        //
        MDataHandle dhIsDirection = data.inputValue(sIsDirection, &status);
        if (!status)
        {
            status.perror("cgfxVector: isDirection handle");
            return status;
        }

        MDataHandle dhVector = data.inputValue(sVector, &status);
        if (!status)
        {
            status.perror("cgfxVector: vector handle");
            return status;
        }

        MMatrix matrix;

        MPlug matrixPlug(thisMObject(), sMatrix);
        if (matrixPlug.isNull())
        {
            OutputDebugString("matrixPlug is NULL!\n");
        }

        // TODO: Fix this kludge.
        //
        // We should not have to do this but for some reason, 
        // using data.inputValue() fails for the sMatrix attribute.
        // Instead, we get a plug to the attribute and then get
        // the value directly.
        //
        MObject oMatrix;

        matrixPlug.getValue(oMatrix);

        MFnMatrixData fndMatrix(oMatrix, &status);
        if (!status)
        {
            status.perror("cgfxVector: matrix data");
        }

        matrix= fndMatrix.matrix(&status);
        if (!status)
        {
            status.perror("cgfxVector: get matrix");
        }

#if 0
        // TODO: This is how we are supposed to do it.  (I think).
        //
        MDataHandle dhMatrix = data.inputValue(sMatrix, &status);
        if (!status)
        {
            status.perror("cgfxVector: matrix handle");
        }

        oMatrix         = dhMatrix.data();
        MFnMatrixData fnMatrix(oMatrix, &status);
        if (!status)
        {
            status.perror("cgfxVector: matrix function set");
        }

        matrix = fnMatrix.matrix();
#endif /* 0 */

        bool     isDirection    = dhIsDirection.asBool();
        double3& vector         = dhVector.asDouble3();

        double mat[4][4];
        matrix.get(mat);

        double ix, iy, iz, iw;  // Input vector
        float  ox, oy, oz, ow;  // Output vector

        ix = vector[0];
        iy = vector[1];
        iz = vector[2];
        iw = isDirection ? 0.0 : 1.0;

        ox = (float)(mat[0][0] * ix +
                     mat[1][0] * iy +
                     mat[2][0] * iz +
                     mat[3][0] * iw);

        oy = (float)(mat[0][1] * ix +
                     mat[1][1] * iy +
                     mat[2][1] * iz +
                     mat[3][1] * iw);

        oz = (float)(mat[0][2] * ix +
                     mat[1][2] * iy +
                     mat[2][2] * iz +
                     mat[3][2] * iw);

        ow = (float)(mat[0][3] * ix +
                     mat[1][3] * iy +
                     mat[2][3] * iz +
                     mat[3][3] * iw);

        MDataHandle dhWVector = data.outputValue(sWorldVector, &status);
        if (!status)
        {
            status.perror("cgfxVector: worldVector handle");
            return status;
        }

        MDataHandle dhWVectorW = data.outputValue(sWorldVectorW, &status);
        if (!status)
        {
            status.perror("cgfxVector: worldVectorW handle");
            return status;
        }

        dhWVector.set(ox, oy, oz);
        dhWVectorW.set(ow);
        data.setClean(sWorldVector);
        data.setClean(sWorldVectorW);
    }
    else
    {
        return MS::kUnknownParameter;
    }

    return MS::kSuccess;
}

/* static */
void* cgfxVector::creator()
{
    return new cgfxVector;
}

/* static */
MStatus cgfxVector::initialize()
{
    MStatus status;

    MFnNumericAttribute nAttr;
    MFnMatrixAttribute  mAttr;

    sVectorX = nAttr.create("vectorX", "vx",
                            MFnNumericData::kDouble, 0.0, &status);
    if (!status)
    {
        status.perror("cgfxVector: create vectorX");
        return status;
    }
    nAttr.setKeyable(true);

    sVectorY = nAttr.create("vectorY", "vy",
                            MFnNumericData::kDouble, 0.0, &status);
    if (!status)
    {
        status.perror("cgfxVector: create vectorY");
        return status;
    }
    nAttr.setKeyable(true);

    sVectorZ = nAttr.create("vectorZ", "vz",
                            MFnNumericData::kDouble, 0.0, &status);
    if (!status)
    {
        status.perror("cgfxVector: create vectorZ");
        return status;
    }
    nAttr.setKeyable(true);

    sVector = nAttr.create("vector", "v",
                           sVectorX, sVectorY, sVectorZ, &status);
    if (!status)
    {
        status.perror("cgfxVector: create vector");
        return status;
    }
    nAttr.setKeyable(true);

    sIsDirection = nAttr.create("isDirection", "id",
                                MFnNumericData::kBoolean, 0.0, &status);
    if (!status)
    {
        status.perror("cgfxVector: create isDirection");
        return status;
    }
    nAttr.setKeyable(true);
    nAttr.setDefault(false);

    sMatrix = mAttr.create("matrix", "m",
                           MFnMatrixAttribute::kDouble, &status);
    if (!status)
    {
        status.perror("cgfxVector: create matrix");
        return status;
    }
    mAttr.setWritable(true);
    mAttr.setStorable(true);

    sWorldVectorX = nAttr.create("worldVectorX", "wvx",
                                 MFnNumericData::kFloat, 0.0, &status);
    if (!status)
    {
        status.perror("cgfxVector: create worldVectorX");
        return status;
    }
    nAttr.setWritable(false);
    nAttr.setStorable(false);

    sWorldVectorY = nAttr.create("worldVectorY", "wvy",
                                 MFnNumericData::kFloat, 0.0, &status);
    if (!status)
    {
        status.perror("cgfxVector: create worldVectorY");
        return status;
    }
    nAttr.setWritable(false);
    nAttr.setStorable(false);

    sWorldVectorZ = nAttr.create("worldVectorZ", "wvz",
                                 MFnNumericData::kFloat, 0.0, &status);
    if (!status)
    {
        status.perror("cgfxVector: create worldVectorZ");
        return status;
    }
    nAttr.setWritable(false);
    nAttr.setStorable(false);

    sWorldVectorW = nAttr.create("worldVectorW", "wvw",
                                 MFnNumericData::kFloat, 0.0, &status);
    if (!status)
    {
        status.perror("cgfxVector: create worldVectorW");
        return status;
    }
    nAttr.setWritable(false);
    nAttr.setStorable(false);

    sWorldVector = nAttr.create("worldVector", "wv",
                                sWorldVectorX, sWorldVectorY, sWorldVectorZ,
                                &status);
    if( !status )
    {
        status.perror("cgfxVector: create worldVector");
        return status;
    }
    nAttr.setWritable(false);
    nAttr.setStorable(false);

    status = addAttribute(sVector);
    if (!status)
    {
        status.perror("cgfxVector: addAttribute vector");
        return status;
    }

    status = addAttribute(sIsDirection);
    if (!status)
    {
        status.perror("cgfxVector: addAttribute isDirection");
        return status;
    }

    status = addAttribute(sMatrix);
    if (!status)
    {
        status.perror("cgfxVector: addAttribute matrix");
        return status;
    }

    status = addAttribute(sWorldVector);
    if (!status)
    {
        status.perror("cgfxVector: addAttribute worldVector");
        return status;
    }

    status = addAttribute(sWorldVectorW);
    if (!status)
    {
        status.perror("cgfxVector: addAttribute worldVectorW");
        return status;
    }

    status = attributeAffects(sVector, sWorldVector);
    if (!status)
    {
        status.perror("cgfxVector: attributeAffects vector -> worldVector");
        return status;
    }

    status = attributeAffects(sIsDirection, sWorldVector);
    if (!status)
    {
        status.perror("cgfxVector: attributeAffects isDirection -> worldVector");
        return status;
    }

    status = attributeAffects(sMatrix, sWorldVector);
    if (!status)
    {
        status.perror("cgfxVector: attributeAffects matrix -> worldVector");
        return status;
    }

    status = attributeAffects(sVector, sWorldVectorW);
    if (!status)
    {
        status.perror("cgfxVector: attributeAffects vector -> worldVectorW");
        return status;
    }

    status = attributeAffects(sIsDirection, sWorldVectorW);
    if (!status)
    {
        status.perror("cgfxVector: attributeAffects isDirection -> worldVectorW");
        return status;
    }

    status = attributeAffects(sMatrix, sWorldVectorW);
    if (!status)
    {
        status.perror("cgfxVector: attributeAffects matrix -> worldVectorW");
        return status;
    }

    return MS::kSuccess;
}