OBJ_Geometry.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 library (C++)
 *
 * COMMENTS:    Definition for geometry object
 *
 */

#ifndef __OBJ_Geometry_h__
#define __OBJ_Geometry_h__

#include "OBJ_API.h"
#include "OBJ_Node.h"
#include "OBJ_Shared.h"

#include <DEP/DEP_MicroNode.h>

class CHOP_Node;
class OP_Bundle;

typedef enum {
    OBJ_PHOTON_OFF      = 0,
    OBJ_PHOTON_CAST     = 1,
    OBJ_PHOTON_RECEIVE  = 2,
    OBJ_PHOTON_BOTH     = 3
} OBJ_PHOTON_MODE;

enum OBJ_GeoIndex
{
    I_SHOP_MATERIAL = I_N_BASE_INDICES,
    I_SHOP_MATERIALOPT,
    // Misc
    I_VPORT_SHADEOPEN,
    I_VPORT_DISPLAYASSUBDIV,
    I_VPORT_ONIONSKIN,
    I_N_GEO_INDICES     // should always be last in the list
};

#define INT_OBJ_PARM(name, idx) evalInt(name, &getIndirect()[idx], 0, 0.0)

class OBJ_API OBJ_Geometry : public OBJ_Node
{
public:
             OBJ_Geometry(OP_Network *, const char *, OP_Operator *);
            ~OBJ_Geometry() override;

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

    void                 resolveObsoleteParms(
                                PRM_ParmList *obsolete_parms) override;

    void                 getShaderSpace(OP_Context &context,
                                        UT_DMatrix4 &xform);
    void                 getDisplacementSpace(UT_DMatrix4 &xform, fpreal t);
    void                 getShaderSpace(OP_Context &context, UT_Matrix4 &xform);
    void                 getDisplacementSpace(UT_Matrix4 &xform, fpreal t);

    OP_Bundle           *getReflectBundle(fpreal t);

    // If you need to get the light mask bundle, check to make sure you don't
    // actually want to get the list of light mask objects.
    OP_Bundle           *getLightMaskBundle(fpreal t);

    // getLightMaskObjects differs from getLightMaskBundle method in that it
    // will expand light subnets and return the list of objects that will light
    // this geo.
    void                 getLightMaskObjects(OP_NodeList &lights, fpreal t);

    int                  isObjectLitBy(OBJ_Node *light,
                                       fpreal t) override;
    bool                 isLightInLightMask(const OBJ_Node *light,
                                            fpreal now) override;
    int                  isObjectLitBySubnet(OBJ_Node *subnet,
                                             fpreal t) override;

    void                         getActingLightSubset(
                                    const UT_ValArray<OBJ_Ambient *> &lights,
                                    UT_ValArray<OBJ_Ambient *> &active,
                                    fpreal t) override;

    /// Interface to manipulate object level parameters
    SOP_ObjectAppearancePtr      getObjectAppearance() override;
    
    int                          doDrawLit() const override { return 1; }

    OBJ_OBJECT_TYPE              getObjectType() const override;

    virtual CHOP_Node   *getSoundMaterial(fpreal t);
    static PRM_Template *getTemplateList(OBJ_ParmsStyle style);

    OBJ_Geometry        *castToOBJGeometry() override { return this; }

    int                  collectPropertiesFromChannels(
                                PI_EditScriptedParms &,
                                UT_BitArray &selection,
                                const CH_ChannelList &channels) override;
    int                  collectPropertiesFromParms(
                                PI_EditScriptedParms &,
                                UT_StringArray &names,
                                PRM_ParmNameMap &nmap) override;

    obj_OnionSkin        getOnionSkin() override;

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

    GU_DetailHandle     getBoundingBoxGeometryHandle(OP_Context &context);
    GU_DetailHandle     getBoundingSphereGeometryHandle(OP_Context &context);

    void                 buildParmDependency( int parm_index ) override;

    // Flags for Use Parent Parameter
public:
    int         SMOOTH(fpreal now);
    int         NOBACK(fpreal now);
    void        DETAIL(UT_String &str, fpreal t);
    void        DETAIL_FILE(UT_String &str, fpreal t);
    void        DETAIL_AUTOARCHIVE(UT_String &str, fpreal t);
    void        DETAIL_RIBPROC(UT_String &str, fpreal t);
    void        DETAIL_MANTRAPROC(UT_String &str, fpreal t);
    int         DETAIL_BLUR(fpreal t);
    void        DETAIL_MIN(fpreal *v, fpreal t);
    void        DETAIL_MAX(fpreal *v, fpreal t);
    int         AUTOREFLECT(fpreal t);
    void        REFLMAP(UT_String &str, fpreal t);
    int         REFLRES(fpreal t);
    void        LIGHTMASK(UT_String &str,fpreal t);
    void        REFLMASK(UT_String &str, fpreal t);
    void        RISHADER(UT_String &str, fpreal t);
    void        RIDISPLACE(UT_String &str, fpreal t);
    void        RIINTERIOR(UT_String &str, fpreal t);
    bool        INSTANCEGROUP(UT_String &str, fpreal now);
    OBJ_PHOTON_MODE     CAUSTICSMODE(fpreal t);
    OBJ_PHOTON_MODE     GLOBILLUMMODE(fpreal t);
    int         RI_COLOR(fpreal now);
    void        RI_CS(fpreal v[3], fpreal t);
    void        RI_OS(fpreal v[3], fpreal t);
    void        RI_PHOTON(UT_String &str, fpreal t);
    bool        SHADESPACE(UT_String &str, fpreal t);
    bool        DISPSPACE(UT_String &str, fpreal t);

    // This parameter in the Misc tab only exists for geometry objects.
    int         VPORT_SHADEOPEN() override
                {
                    fetchGeoDispOpts();
                    return myShadeOpenCurves;
                }
    int         VPORT_DISPLAYASSUBDIV() override
                {
                    fetchGeoDispOpts();
                    return myDisplaySubD;
                }

    // method for building a menu containing primitive groups
    void                 buildPrimitiveGroupMenu(PRM_Name *menu,
                                                 int size, 
                                                 const PRM_SpareData *spare, 
                                                 const PRM_Parm *parm) override;

private:

    void                 fetchGeoDispOpts()
    {
        if(myGeoDispOptMicroNode.requiresUpdate(0.0))
        {
            myShadeOpenCurves = INT_OBJ_PARM("vport_shadeopen",
                                             I_VPORT_SHADEOPEN);
            myDisplaySubD = INT_OBJ_PARM("vport_displayassubdiv",
                                         I_VPORT_DISPLAYASSUBDIV);
            auto i_shade = getIndirect()[I_VPORT_SHADEOPEN];
            if(i_shade >= 0)
                myGeoDispOptMicroNode.addExplicitInput(
                    parmMicroNode(i_shade, 0),false);
            
            auto i_style = getIndirect()[I_VPORT_DISPLAYASSUBDIV];
            if(i_style >= 0)
                myGeoDispOptMicroNode.addExplicitInput(
                    parmMicroNode(i_style, 0),false);
            myGeoDispOptMicroNode.update(0.0);
         }
    }
    
    GU_DetailHandle      myPopStandInGdpHandle;
    int                  myShaderHint;

    DEP_MicroNode        myOnionSkinDepNode;
    DEP_MicroNode        myGeoDispOptMicroNode;
    int                  myOnionSkinState;
    int                  myShadeOpenCurves;
    int                  myDisplaySubD;

    static int          *geoIndirect;
};

#undef INT_OBJ_PARM

#endif