GUI_SceneCameras.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:        GUI_SceneCameras.h 
 *
 * COMMENTS:
 *      The list of generated cameras in the viewer from all sources.
 */
#ifndef GUI_SceneCameras_h
#define GUI_SceneCameras_h

#include "GUI_API.h"

#include <GA/GA_Types.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_Map.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>

class UT_CameraParms;
class OP_Node;

/// Collection class for all cameras in a scene, from all sources
class GUI_API GUI_SceneCameras
{
public:
    /// Where the camera is generated from
    enum SourceType { GEO_PRIM, OBJ_NODE, USD_PRIM, COP_NODE, DRAWABLE };

    enum LightType { LIGHT };
    enum TypeGT { DRAWABLE_CAMERA };

    /// The context the camera is being shown for (not its source context).
    /// This can affect how the camera name is displayed
    enum ContextType   { OBJ_SOP_CONTEXT, LOP_CONTEXT, COP_CONTEXT };

    /// The binding that drawable cameras are registered with.
    enum DrawableBinding { DRAWABLE_INDEX = -1 }; 

    class GUI_API CameraInfo
    {
    public:
        CameraInfo() : myType(OBJ_NODE), myOpId(-999), myAltOpId(-999) {}
        
        // Object based cameras
        CameraInfo(int op_id)
            : myType(OBJ_NODE), myOpId(op_id), myIsLight(false) {}
        // Object based lights
        CameraInfo(int op_id, LightType)
            : myType(OBJ_NODE), myOpId(op_id), myIsLight(true) {}
        // Drawable cameras
        CameraInfo(int look_id, const UT_StringHolder &name, TypeGT)
            : myType(DRAWABLE), myLookId(look_id), myName(name) {}
        // Sop based cameras
        CameraInfo(int op_id, GA_Index index, const UT_StringHolder &name)
            : myType(GEO_PRIM), myOpId(op_id), myIndex(index), myName(name),
              myIsLight(false) {}
        // COP or LOP light (name is layer or prim)
        CameraInfo(int op_id, const UT_StringHolder &name,
                   SourceType type, bool is_light, int alt_op = -999)
            : myType(type), myOpId(op_id), myName(name), myIsLight(is_light),
              myAltOpId(alt_op) {}

        bool operator==(const CameraInfo &cam) const
        {
            if(cam.isValid() != isValid() ||
               myType != cam.myType ||
               myOpId != cam.myOpId ||
               myLookId != cam.myLookId ||
               myIsLight != cam.myIsLight)
            {
                return false;
            }
            if(myType == GEO_PRIM && myIndex != cam.myIndex)
                return false;
            if((myType == COP_NODE || myType == USD_PRIM) && myName!=cam.myName)
                return false;

            return true;
        }

        bool    isValid() const;
            
        OP_Node                *node() const;
        OP_Node                *nodeAlternate() const;
        int                     opId() const { return myOpId; }
        int                     lookId() const { return myLookId; }
        GUI_SceneCameras::SourceType type() const { return myType; }
        const UT_StringHolder  &name() const { return myName; }
        GA_Index                primIndex()  const { return myIndex; }
        bool                    isLight() const { return myIsLight; }

    private:
        SourceType myType;
        int myOpId = -999;
        int myAltOpId = -999;
        int myLookId = 0;
        GA_Index myIndex = GA_Index(0);
        bool myIsLight = false;
        UT_StringHolder myName;
    };

    GUI_SceneCameras() {}
    
    /// Register a number of cameras created by the given look.
    void registerCameras(int look_id, const UT_StringMap<CameraInfo> &cameras);

    /// Remove cameras associated with a look
    void removeCameras(int look_id);

    bool hasCameras(int look_id) const { return myCameras.contains(look_id); }

    /// Return a list of camera names for a given context
    void getCameras(UT_Array<std::pair<UT_StringHolder,CameraInfo>> &cams,
                    ContextType menu_type);
    
    /// Return a list of light names to view through, for a given context
    void getLights(UT_Array<std::pair<UT_StringHolder,CameraInfo>> &lights,
                   ContextType menu_type);

    static UT_StringHolder getCameraName(ContextType for_context,
                                         const CameraInfo &camera);

    static UT_StringHolder getCameraName(const OP_Node *node_network,
                                         const CameraInfo &camera);

protected:
    /// Generate a name for a camera suitable for display
    static UT_StringHolder makeCameraName(
                                SourceType cam_source,
                                ContextType context,
                                int op_id,
                                UT_StringHolder cam_name = UT_StringHolder());
    
    UT_NON_COPYABLE(GUI_SceneCameras);

    UT_Map<int, UT_StringMap<CameraInfo> > myCameras;
};

/* -------------------------------

   Resolve names:
   OBJ  /path/to/obj/camera
   SOP  /path/to/sop:cameraname
        /path/to/sop:output:cameraname
   LOP  /path/to/lop:/path/to/prim
   COP  /path/to/cop:cameraname
        /path/to/cop:output:cameraname
*/
#endif