OBJ/OBJ_SubNet.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.
 *
 * Produced by:
 *      Rob Bairos
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        OBJ_SubNet.h (Custom Library, C++)
 *
 * COMMENTS:    An object to describe a motion capture handle
 *
 */

#ifndef __OBJ_SubNet__
#define __OBJ_SubNet__

#include "OBJ_API.h"
#include <UT/UT_DMatrix4.h>
#include "OBJ_Node.h"
#include "OBJ_Shared.h"

class OP_Bundle;

enum OBJ_SubNetIndex
{
    I_LABEL1 = I_N_BASE_INDICES,
    I_LABEL2,
    I_LABEL3,
    I_LABEL4,

    I_OUTPUTOBJ,
    I_VISIBLEOBJECTS,

    I_N_SUBNET_INDICES
};

class OBJ_API OBJ_SubNet : public OBJ_Node
{
public:
                                 OBJ_SubNet(OP_Network *net,
                                           const char *name,
                                           OP_Operator *op);
    virtual                     ~OBJ_SubNet();

    virtual const char          *getChildType() const;
    virtual OBJ_OBJECT_TYPE      getObjectType() const;

    virtual OP_OpTypeId          getChildTypeID() const;

    virtual OP_Node             *getDisplayNodePtr();
    virtual OP_Node             *getRenderNodePtr();
    virtual int                  isObjectRenderable() const;
    OP_Bundle                   *getVisibleObjectBundle(float t);
    int                          isVisibleObject(const OBJ_Node *node,
                                                 float t) const;

    virtual void                 opChanged(OP_EventType reason, void *data=0);
    virtual void                 propagateParmChange(OP_Node *node,
                                                     OP_PropagateData &prop_data,
                                                     bool &data_change);

    virtual OP_ERROR             setInput(unsigned idx, OP_Node *op,
                                          unsigned outputIdx = 0);
    virtual OP_ERROR             setInputReference(unsigned idx,
                                                   const char *label,
                                                   int keeppos,
                                                   unsigned outputIdx = 0);
    virtual OP_ERROR             setIndirectInput(unsigned idx,
                                                  OP_InputIndirect *in);

    const UT_DMatrix4 &          getSubnetTransform(OP_Context &context);

    void                         LABEL(UT_String &str, int idx);

    void                         OUTPUTOBJ(UT_String &str)
                                 {
                                    evalString(str, "outputobj",
                                               &getIndirect()[I_OUTPUTOBJ],
                                               0, 0.0f);
                                 }
    void                         VISIBLEOBJECTS(UT_String &str, float t)
                                 {
                                    evalString(str, "visibleobjects",
                                               &getIndirect()[I_VISIBLEOBJECTS],
                                               0, t);
                                 }
    void                         setVISIBLEOBJECTS(const UT_String &str,
                                            CH_StringMeaning meaning, float t)
                                 {
                                    setString(str, meaning, "visibleobjects",
                                              getIndirect()[I_VISIBLEOBJECTS],
                                              0, t);
                                 }

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

    static PRM_Template         *getTemplateList(OBJ_ParmsStyle style);

    ///Absolute width
    virtual fpreal               getW() const;
    ///Absolute height
    virtual fpreal               getH() const;

    virtual OBJ_SubNet          *castToOBJSubNet() { return this; }
    
protected:
    // Used to get pointer to indirection indices for each object type
    virtual int                 *getIndirect() const
                                 { return subnetIndirect; }

    virtual OP_ERROR             cookMyObj(OP_Context &context);
    virtual void                 childFlagChange(OP_Node *);
    virtual const char          *inputLabel(unsigned idx) const;

    virtual void                 buildParmDependency( int parm_index );

    virtual bool                 getTimeOverride();

private:
    bool                         internalDisplayDisabled(float t);
    void                         propagateDisplayChangeToDescendents(
                                    bool visible_children_changed);
    void                         checkInternalExtraInputTimeDependency(
                                                        float t);
    void                         updateInternalTimeDependency();

    bool                         myResetInternalTimeDependent;
    bool                         myInternalTimeDependent;
    bool                         myInternalExtraInputTimeDependent;
    int                          myLastDisplayDisabled;

    UT_DMatrix4                  mySubnetXform;

    static int                  *subnetIndirect;
    static int                   myLastInternalParmIndex;
};

#endif

---