OBJ_Fetch.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:        OBJ_Fetch.h (Custom Library, C++)
 *
 * COMMENTS:    An object to fetch it's transform from another object.
 *
 */

#ifndef __OBJ_Fetch__
#define __OBJ_Fetch__

#include "OBJ_API.h"
#include "OBJ_Geometry.h"

enum OBJ_FetchIndex
{
    I_FETCHOBJPATH = I_N_GEO_INDICES,
    I_FETCH_USE_INPUT_OF_THIS,
    I_FETCH_USE_INPUT_OF_FETCHED,
    I_FETCHSUBNET,
    I_FETCHINVERT,              // invert fetched matrix

    I_N_FETCH_INDICES
};


class OBJ_API OBJ_Fetch : public OBJ_Geometry
{
public:
                                 OBJ_Fetch(OP_Network *net,
                                           const char *name,
                                           OP_Operator *op);
                                ~OBJ_Fetch() override;

    OBJ_OBJECT_TYPE              getObjectType() const override;

    void                         FETCHOBJPATH(UT_String &str)
                                 {
                                    evalString(str, "fetchobjpath",
                                                &getIndirect()[I_FETCHOBJPATH],
                                                0, 0.0f);
                                 }
    void                         setFETCHOBJPATH(const UT_String &str,
                                                 CH_StringMeaning meaning)
                                 {
                                    setString(str, meaning, "fetchobjpath",
                                              getIndirect()[I_FETCHOBJPATH],
                                              0, 0.0f);
                                 }
    int                          USEINPUTOFTHIS()
                                 {
                                     return evalInt("useinputofthis",
                                    &getIndirect()[I_FETCH_USE_INPUT_OF_THIS],
                                                0, 0.0f);
                                 }
    void                         setUSEINPUTOFTHIS( bool flag )
                                 {
                                     setInt("useinputofthis",
                                       getIndirect()[I_FETCH_USE_INPUT_OF_THIS],
                                            0, 0.0f, flag);
                                 }
    int                          USEINPUTOFFETCHED()
                                 {
                                     return evalInt("useinputoffetched",
                                   &getIndirect()[I_FETCH_USE_INPUT_OF_FETCHED],
                                                0, 0.0f);
                                 }
    void                         setUSEINPUTOFFETCHED( bool flag )
                                 {
                                     setInt("useinputoffetched",
                                    getIndirect()[I_FETCH_USE_INPUT_OF_FETCHED],
                                            0, 0.0f, flag);
                                 }
    int                          FETCHSUBNET()
                                 {
                                     return evalInt("fetchsubnet",
                                                &getIndirect()[I_FETCHSUBNET],
                                                0, 0.0f);
                                 }
    void                         setFETCHSUBNET( int fetch_subnet )
                                 {
                                     setInt("fetchsubnet",
                                            getIndirect()[I_FETCHSUBNET],
                                            0, 0.0f, fetch_subnet );
                                 }
    bool                         FETCHINVERT()
                                 {
                                     return (bool) evalInt("invertfetched",
                                                &getIndirect()[I_FETCHINVERT],
                                                0, 0.0f);
                                 }

    void                         resolveObsoleteParms(
                                        PRM_ParmList *obsolete_parms) override;

    static OP_Node              *myConstructor(OP_Network *net,
                                               const char *name,
                                               OP_Operator *entry);

    static PRM_Template         *getTemplateList();
    static PRM_Template         *getObsolete();

    OBJ_Fetch                   *castToOBJFetch() override { return this; }

    void                         getNodeSpecificInfoText(
                                        OP_Context &context,
                                        OP_NodeInfoParms &iparms) override;
    void                         fillInfoTreeNodeSpecific(
                                        UT_InfoTree &tree, 
                                        const OP_NodeInfoTreeParms &parms
                                        ) override;

protected:
    bool                         updateParmsFlags() override;
    
    // Used to get pointer to indirection indices for each object type
    int                         *getIndirect() const override
                                 { return fetchIndirect; }

    OP_ERROR                     cookMyObj(OP_Context &context) override;

private:
    static int                  *fetchIndirect;
};

#endif