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.
 *
 * 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);
                                ~OBJ_SubNet() override;

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

    OP_OpTypeId                  getChildTypeID() const override;

    bool                         getBoundingBox(UT_BoundingBox &box,
                                        OP_Context &ctx) override;

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

    void                         opChanged(OP_EventType reason,
                                           void *data=0) override;
    void                         referencedParmChanged(int parm_index) override;

    OP_ERROR                     setInput(OP_InputIdx idx, OP_Node *op,
                                          OP_OutputIdx outputIdx = 0) override;
    OP_ERROR                     setInputReference(
                                        OP_InputIdx idx,
                                        const char *label,
                                        int keeppos,
                                        OP_OutputIdx outputIdx = 0) override;
    OP_ERROR                     setIndirectInput(
                                        OP_InputIdx idx,
                                        OP_IndirectInput *in) override;
    OP_ERROR                     setNamedInput(
                                        const OP_ConnectorId& input_name,
                                        OP_Node *op,
                                        const OP_ConnectorId* output_name=NULL
                                        ) override;
    OP_ERROR                     setNamedInputReference(
                                        const OP_ConnectorId& input_name, 
                                        const char *label,
                                        int,
                                        const OP_ConnectorId *output_name=NULL
                                        ) override;
    OP_ERROR                     setNamedIndirectInput(
                                        const OP_ConnectorId& input_name,
                                        OP_IndirectInput *input) override;

    bool                         getSubnetTransform(OP_Context &context,
                                                    UT_DMatrix4 &mat);

    void                         LABEL(UT_String &str, int idx);

    void                         OUTPUTOBJ(UT_String &str) const
                                 {
                                    evalString(str, "outputobj",
                                               &getIndirect()[I_OUTPUTOBJ],
                                               0, 0.0f);
                                 }
    int                          parmIndexOUTPUTOBJ() const
                                 {
                                     return getCachedParmIndex(
                                             "outputobj", I_OUTPUTOBJ);
                                 }

    void                         VISIBLEOBJECTS(UT_String &str, fpreal t)
                                 {
                                    evalString(str, "visibleobjects",
                                               &getIndirect()[I_VISIBLEOBJECTS],
                                               0, t);
                                 }
    void                         setVISIBLEOBJECTS(const UT_String &str,
                                            CH_StringMeaning meaning, fpreal t)
                                 {
                                    setString(str, meaning, "visibleobjects",
                                              getIndirect()[I_VISIBLEOBJECTS],
                                              0, t);
                                 }
    int                          parmIndexVISIBLEOBJECTS() const
                                 {
                                     return getCachedParmIndex(
                                         "visibleobjects", I_VISIBLEOBJECTS);
                                 }

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

    static const char           *theChildTableName;

    static PRM_Template         *getTemplateList(OBJ_ParmsStyle style);

    OBJ_SubNet                  *castToOBJSubNet() override { return this; }
    
    void                         getParallelInputs(
                                        OP_Context &context,
                                        OP_NodeList &nodes) const override;
    
    int                          doDrawLit() const override { return 1; }

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

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

    void                         buildParmDependency( int parm_index ) override;

    bool                         getTimeOverride() override;

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

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

    static int                  *subnetIndirect;
    static int                   myLastInternalParmIndex;
};

#endif