MOT_GeometryChannelsManager.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        MOT_GeometryChannelsManager (C++)
 *
 * COMMENTS:    This class is responsible for scoping geometry channels
 *              from existing sop nodes or geometries into the CH_Manager.
 *
 */

#ifndef __MOT_GeometryChannelsManager_h__
#define __MOT_GeometryChannelsManager_h__

#include "MOT_API.h"

#include <CH/CH_EventManager.h>
#include <GA/GA_Types.h>
#include <OP/OP_Value.h>
#include <UT/UT_StringArray.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_Map.h>

class GU_DetailHandle;
class GU_ConstDetailHandle;
class OP_Node;
class SOP_Node;

class MOT_API MOT_GeometryChannelsManager
{
public:
    MOT_GeometryChannelsManager();

    /// Extracts geometry channels (channel primitives) from
    /// the provided sop node, scoping them into the CH_Manager.
    /// Adds listeners to the node to rescope channels
    /// when they are modified.
    /// @node SOP_Node to extract the channel primitives from.
    /// @param pattern Optional primitive group pattern to extract only
    ///                certain primitives from the node's geometry.
    /// @return name of the collection
    UT_StringHolder scopeGeometryChannels(
            SOP_Node *node,
            const UT_StringHolder &pattern = "");

    /// Extracts geometry channels (channel primitives) from
    /// the provided geometry handle, scoping them into the CH_Manager.
    /// @param detail Geometry from which to extract the channel primitives
    /// @param collection_name Optional name for the collection, used to refer
    ///        to it for later fetching or updating its channels. If not
    ///        provided, a unique name will be created. If a collection with
    ///        the same name already exists, it will be updated instead
    ///        of a new one being created. In this case, dataid's will
    ///        be checked to ensure only modified channels are updated.
    ///        if the name attrib dataid of the detail was changed, the
    ///        existing collection will be destroyed and a new one created from
    ///        scratch.
    /// @param pattern Optional primitive group pattern to extract only
    ///                certain primitives from the geometry.
    /// @return name of the collection
    /// Also see setGeometryChannels for updating an existing collection.
    UT_StringHolder scopeGeometryChannels(
            const GU_ConstDetailHandle &detail,
            const UT_StringHolder &collection_name = "",
            const UT_StringHolder &pattern = "");

    /// Unscope geometry channels with the given collection name.
    void unscopeGeometryChannels(const UT_StringHolder &collection_name);
    /// Unscope geometry channels from the given node
    void unscopeGeometryChannels(SOP_Node *node);

    /// Returns a unique name for a new geometry collection, based on the
    /// myNextGeometryChannelsId property.
    /// This is used both internally when scoping new collections, and
    /// when adding geometry collections to the HOM ChannelList. In this second
    /// case, the collections are not actually scoped until later setting the
    /// channel list, but the name should be reserved ahead of time to prevent
    /// possible conflicts.
    UT_StringHolder reserveNewGeometryCollectionName();
    UT_StringArray getChannelNames(
            const GU_ConstDetailHandle &gdh,
            UT_StringHolder pattern = "");

    int getCollectionNodeId(const UT_StringHolder &collection_name) const;
    UT_StringHolder getCollectionPattern(
            const UT_StringHolder &collection_name) const;

    /// Write the geometry channels with the given names into the
    /// provided geometry
    /// @param gdp The geometry to fill with the geometry channels
    /// @param collection_name Name of the collection to get the channels from
    /// @param names Names of the channels to fetch.
    void getGeometryChannels(
            GU_DetailHandle &gdh,
            const UT_StringHolder &collection_name,
            const UT_StringArray &names) const;

    /// Write all geometry channels in the collection into the provided geometry
    /// @param gdp The geometry to fill with the geometry channels
    /// @param collection_name Name of the collection to get the channels from
    void getGeometryChannels(
            GU_DetailHandle &gdh,
            const UT_StringHolder &collection_name) const;

    /// Perform a partial update of a given collection, overwriting
    /// channels which match the pattern with the ones in the provided detail.
    /// @param gdh The geometry used to update the collection's channels.
    /// @param pattern The primitive group pattern to determine which channel
    /// primitives should be updated. Note that this does not overwrite the
    /// original pattern used to originally construct the collection in
    /// scopeGeometryChannels
    /// @param collection name Name of the collection to update.
    ///
    /// Note that this method ignores name dataid checks, as the detail used to
    /// set geometry channels may be different from the one the channels were
    /// originally loaded from.
    /// If the given collection does not exist, this method instead creates a
    /// new one, using scopeGeometryChannels.
    void setGeometryChannels(
            const GU_DetailHandle &gdh,
            const UT_StringHolder &pattern = "",
            const UT_StringHolder &collection_name = "");

    void clear();

protected:

private:
    static void geometryChannelsModified(OP_Node *caller, void *callee,
                                         OP_EventType type, void *data);

    static void changeEvent(void *data, CH_CHANGE_TYPE how, int parm_index);

    // Creates a new collection. Called by scopeGeometryChannels
    UT_StringHolder createCollection(
            const GU_ConstDetailHandle &detail,
            UT_StringHolder collection_name,
            const UT_StringHolder &pattern,
            int node_id);

    // Populates the channels of a collection. Called by createCollection and
    // setGeometryChannels.
    // If update_only is true, skips the name attrib dataid checks and avoids
    // recreating the collection from scratch, or erasing existing channels,
    // only updating/adding new ones.
    void updateCollection(
            const UT_StringHolder &collection_name,
            const GU_ConstDetailHandle &detail,
            const UT_StringHolder &pattern,
            bool update_only = false);

    void reloadGeometryChannels(SOP_Node *node);
    void handleNodeDeleted(SOP_Node *node);

    struct ScopedGeometry
    {
        ScopedGeometry()
            : myId(-1)
            , myNodeId(-1)
            , myPattern("")
            , myNameDataId(GA_INVALID_DATAID)
        {
        }
        ScopedGeometry(int id, const UT_StringHolder &pattern, int node_id)
            : myId(id)
            , myPattern(pattern)
            , myNodeId(node_id)
            , myNameDataId(GA_INVALID_DATAID)
        {
        }

        int myId;
        UT_StringHolder myPattern;
        int myNodeId;
        GA_DataId myNameDataId;
        // Mapping of channel name to the primitive offset it was created from
        UT_StringMap<int64> myGeometryChannelDataIds;
    };

    /// Mapping of collection name to scoped data
    UT_StringMap<ScopedGeometry> myScopedGeometries;

    // Id to assign to geometry channels. When a name is not specified for a new
    // collection, this is appended to the default name to ensure uniqueness
    int myNextGeometryChannelsId;
};

#endif