DOP_FullPathData.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:        DOP_FullPathData.h ( SOP Library, C++)
 *
 * COMMENTS:
 */

#ifndef __DOP_FullPathData_h__
#define __DOP_FullPathData_h__

#include "DOP_API.h"
#include <UT/UT_Array.h>
#include <UT/UT_String.h>
#include <OP/OP_Node.h>
#include <GU/GU_DetailHandle.h>
#include <SIM/SIM_FullPathData.h>
#include "DOP_Engine.h"

class UT_WorkBuffer;
class UT_StringArray;
class GU_ConstDetailHandle;
class SIM_Data;
class SIM_Object;
class SIM_ConstObjectArray;
class SIM_SDF;
class OP_Context;
class OP_GlobContext;
class DOP_Parent;
class DOP_SimulationChangeSink;

class DOP_API DOP_FullPathData
{
public:
                         DOP_FullPathData()
                         {
                             myDataName.setAlwaysDeep(true);
                         }

                         explicit DOP_FullPathData(const SIM_FullPathData &src)
                         {
                             myRootData = src.myRootData;
                             myData = src.myData;
                             myDataName = src.myDataName;
                             myDataName.setAlwaysDeep(true);
                         }

    static const SIM_Position *getBestPosition(const SIM_RootData *rootdata,
                                        const SIM_Data *data,
                                        const char *dataname)
    {
        return SIMgetBestPosition(rootdata, data, dataname);
    }

    const SIM_Position  *getBestPosition() const
    {
        return getBestPosition(myRootData, myData, myDataName);
    }

    static GU_ConstDetailHandle getBestGeometry(UT_DMatrix4 &xform,
                                        const SIM_RootData *rootdata,
                                        const SIM_Data *data,
                                        const char *dataname,
                                        fpreal simtime,
                                        const bool doceflush = true);

    GU_ConstDetailHandle getBestGeometry(UT_DMatrix4 &xform) const;

    bool                 operator==(const DOP_FullPathData &cmp) const
                         {
                             return ((myNode == cmp.myNode) &&
                                     (myParent == cmp.myParent) &&
                                     (myRootData == cmp.myRootData) &&
                                     (myData == cmp.myData) &&
                                     (myDataName == cmp.myDataName));
                         }

    void                 clear()
                         {
                             myNode = 0;
                             myParent = 0;
                             myRootData = 0;
                             myData = 0;
                             myDataName = "";
                             myGlobalTime = 0;
                         }

    OP_Node             *myNode = nullptr;
    DOP_Parent          *myParent = nullptr;
    const SIM_RootData  *myRootData = nullptr;
    const SIM_Data      *myData = nullptr;
    UT_String            myDataName;

    // Not simulation time.
    fpreal               myGlobalTime = 0;
};

class DOP_API DOP_FullPathDataArray : public UT_Array<DOP_FullPathData>
{
public:
                         DOP_FullPathDataArray();
    virtual             ~DOP_FullPathDataArray();

    void                 buildFromPaths(const UT_StringArray &paths);
    void                 getObjectArray(SIM_ConstObjectArray &objects) const;
    void                 getObjectString(UT_WorkBuffer &buffer) const;
};

DOP_API bool     DOPfindDataFromPath(const char *path,
                                DOP_FullPathData &fulldata,
                                fpreal time, OP_Node *relativetonode = 0,
                                bool dopparentisenough = false);
/// Version of DOPfindDataFromPath() that uses the provided SIM_Engine instead
/// of searching for a DOP node at the beginning of the path.
SYS_DEPRECATED_REPLACE(20.0, SIMfindDataFromPath)
DOP_API bool     DOPfindDataFromPath(const char *path,
                                DOP_FullPathData &fulldata,
                                const SIM_Engine &engine,
                                const SIM_Time &sim_time,
                                bool interpolate_data);
DOP_API bool     DOPfindAllDataFromPath(const char *path,
                                DOP_FullPathDataArray &fulldata,
                                fpreal time, OP_Node *relativetonode = 0,
                                bool dopparentisenough = false);
/// Version of DOPfindAllDataFromPath() that uses the provided SIM_Engine
/// instead of searching for a DOP node at the beginning of the path.
SYS_DEPRECATED_REPLACE(20.0, SIMfindAllDataFromPath)
DOP_API bool     DOPfindAllDataFromPath(const char *path,
                                DOP_FullPathDataArray &fulldata,
                                const SIM_Engine &engine,
                                const SIM_Time &sim_time,
                                bool interpolate_data);
DOP_API void     DOPglobPathAndFindAllData(const char *path,
                                DOP_FullPathDataArray &fulldata,
                                OP_NodeList &nodatadopnets,
                                fpreal time, OP_Node *relativetonode = 0,
                                OP_GlobContext *context = 0,
                                OP_Node *errorsink = 0);

/// If the dopparent is currently simulating it is not possible to
/// reset its time.  Similarly, if the desired time is within the last
/// timestep, we can't interpolate since the actual 'current' value
/// of the object is stored at the end time.
/// Returned from this is the new time to use for accesses.
/// In case of unsimulated networks, it is the same as
/// dopparent->setDOPTime(time); return time;
DOP_API SIM_Time DOPsetBestTime(DOP_Parent *dopparent, SIM_Time time);

/// The following functions are the only ones which are thread-safe for
/// accessing DOP data
// @{

/// Thread-safe method to find the owner node of a DOP data path
DOP_API OP_Node *   DOPgetNodeFromDataPath(
                                const char *path,
                                fpreal time, OP_Node *relativetonode = 0,
                                bool dopparentisenough = false);

/// Thread-safe method to world transform of the a DOP data path, optionally
/// returning the geometry if there is any (and gdh is non-NULL). If given
/// an interested_node, then we will add an extra input on it to the path.
DOP_API bool        DOPgetWorldTransformFromDataPath(
                                UT_DMatrix4 &xform,
                                GU_ConstDetailHandle *gdh,
                                bool &timedep,
                                const char *path,
                                OP_Context &context,
                                OP_Node *relativetonode = 0,
                                bool dopparentisenough = false,
                                OP_Node *interested_node = 0);

// @}

#endif