OutputGeometryObject.C

#include <maya/MFnIntArrayData.h>

#include "Asset.h"
#include "AssetNode.h"
#include "OutputGeometryObject.h"
#include "OutputGeometryPart.h"
#include "util.h"
#include "OutputGeometry.h"

#include <math.h>

OutputGeometryObject::OutputGeometryObject(
        HAPI_NodeId nodeId
        ) :
    OutputObject(nodeId)
{
}

OutputGeometryObject::~OutputGeometryObject()
{
    for(int i = 0; i < (int) myGeos.size(); i++)
    {
        delete myGeos[i];
    }
    myGeos.clear();
}

OutputObject::ObjectType
OutputGeometryObject::type()
{
    return OutputObject::OBJECT_TYPE_GEOMETRY;
}

MStatus
OutputGeometryObject::compute(
        const MTime &time,
        const MPlug &objectPlug,
        MDataBlock& data,
        MDataHandle& objectHandle,
        const MIntArray &instancedObjIds,
        const MStringArray &instancedObjNames,
        AssetNodeOptions::AccessorDataBlock &options,
        bool &needToSyncOutputs
        )
{
    MStatus stat = MS::kSuccess;

    update();

    // Meta data
    MDataHandle metaDataHandle = objectHandle.child(AssetNode::outputObjectMetaData);
    metaDataHandle.setInt(myNodeId);

    // outputVisibility
    MDataHandle visibilityHandle = objectHandle.child(AssetNode::outputVisibility);
    visibilityHandle.setBool(isVisible());

    // outputObjectName
    MDataHandle objectNameHandle = objectHandle.child(AssetNode::outputObjectName);
    MString objectName;
    if(myNodeInfo.nameSH != 0)
    {
        objectName = Util::HAPIString(myNodeInfo.nameSH);
    }
    objectNameHandle.setString(objectName);

    // outputIsInstanced
    MDataHandle isInstancedHandle = objectHandle.child(AssetNode::outputIsInstanced);
    bool isInstanced = false;
    {
        for(unsigned int i = 0; !isInstanced && i < instancedObjIds.length(); i++)
        {
            if(instancedObjIds[i] == myNodeInfo.id)
            {
                isInstanced = true;
            }
        }
        for(unsigned int i = 0; !isInstanced && i < instancedObjNames.length(); i++)
        {
            if(instancedObjNames[i] == objectName)
            {
                isInstanced = true;
            }
        }
    }
    isInstancedHandle.setBool(isInstanced);

    // compute geometry
    {
        MPlug geosPlug = objectPlug.child(AssetNode::outputGeos);
        MDataHandle geosHandle = objectHandle.child(AssetNode::outputGeos);
        MArrayDataHandle geoArrayHandle(geosHandle);
        if(geoArrayHandle.elementCount() != myGeos.size())
        {
            Util::resizeArrayDataHandle(geoArrayHandle, myGeos.size());
            needToSyncOutputs = true;
        }

        for(size_t i = 0; i < myGeos.size(); i++)
        {
            MPlug geoPlug = geosPlug.elementByLogicalIndex(i);
            CHECK_MSTATUS(geoArrayHandle.jumpToArrayElement(i));
            MDataHandle geoHandle = geoArrayHandle.outputValue();

            stat = myGeos[i]->compute(
                    time,
                    geoPlug,
                    data,
                    geoHandle,
                    options,
                    needToSyncOutputs
                    );
            CHECK_MSTATUS_AND_RETURN_IT(stat);
        }
    }

    // compute transform
    // always compute, even if the totalCookCount has not changed: 
    // When an asset is an OBJ subnet, calling HAPI_CookNode() on the asset
    // doesn't cause a cook on the OBJ nodes in the asset. So the
    // HAPI_NodeInfo.totalCookCount would never be incremented - Andrew W.
    {
        MDataHandle transformHandle = objectHandle.child(AssetNode::outputObjectTransform);
        updateTransform(transformHandle);

        myLastCookCount = myNodeInfo.totalCookCount;
    }

    return stat;
}

void OutputGeometryObject::update()
{
    HAPI_Result hapiResult;

    hapiResult = HAPI_GetNodeInfo(
            Util::theHAPISession.get(),
            myNodeId, &myNodeInfo
            );
    CHECK_HAPI(hapiResult);

    hapiResult = HAPI_GetObjectInfo(
            Util::theHAPISession.get(),
            myNodeId, &myObjectInfo
            );
    CHECK_HAPI(hapiResult);

    // Get the SOP nodes
    int geoCount;
    hapiResult = HAPI_ComposeChildNodeList(
            Util::theHAPISession.get(),
            myNodeId,
            HAPI_NODETYPE_SOP,
            HAPI_NODEFLAGS_DISPLAY,
            false,
            &geoCount
            );
    CHECK_HAPI(hapiResult);

    std::vector<HAPI_NodeId> geoNodeIds(geoCount);
    if(geoCount > 0)
    {
        hapiResult = HAPI_GetComposedChildNodeList(
                Util::theHAPISession.get(),
                myNodeId,
                &geoNodeIds.front(),
                geoCount
                );
        CHECK_HAPI(hapiResult);
    }

    // Delete old OutputGeometry
    for(int i = myGeos.size(); i-- > geoCount;)
    {
        delete myGeos[i];
        myGeos.pop_back();
    }

    // Add new OutputGeometry
    myGeos.reserve(geoCount);
    for(int i = myGeos.size(); i < geoCount; i++)
    {
        OutputGeometry * geo = new OutputGeometry(geoNodeIds[i]);
        myGeos.push_back(geo);
    }
}

void OutputGeometryObject::updateTransform(MDataHandle& handle)
{
    HAPI_Result hapiResult;

    MDataHandle translateHandle = handle.child(AssetNode::outputObjectTranslate);
    MDataHandle rotateHandle = handle.child(AssetNode::outputObjectRotate);
    MDataHandle scaleHandle = handle.child(AssetNode::outputObjectScale);

    HAPI_Transform trans;
    hapiResult = HAPI_GetObjectTransform(
            Util::theHAPISession.get(),
            myNodeId,
            -1,
            HAPI_SRT,
            &trans
            );
    CHECK_HAPI(hapiResult);

    MEulerRotation eulerRotation = MQuaternion(
            trans.rotationQuaternion[0],
            trans.rotationQuaternion[1],
            trans.rotationQuaternion[2],
            trans.rotationQuaternion[3]
            ).asEulerRotation();
#ifndef M_PI
#define M_PI 3.14
#endif
    translateHandle.set3Double(
            trans.position[0],
            trans.position[1],
            trans.position[2]);
    rotateHandle.set3Double(
            eulerRotation.x,
            eulerRotation.y,
            eulerRotation.z);
    scaleHandle.set3Double(
            trans.scale[0],
            trans.scale[1],
            trans.scale[2]);
}