HOM_GeometryViewport.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.
 *
 * COMMENTS:
 */

#ifndef __HOM_GeometryViewport_h__
#define __HOM_GeometryViewport_h__

#include "HOM_API.h"
#include "HOM_Defines.h"
#include "HOM_ElemPtr.h"
#include "HOM_Errors.h"
#include "HOM_Module.h"
#include "HOM_ObjNode.h"
#include "HOM_EnumValue.h"
#include <UT/UT_Tuple.h>

class HOM_Drawable;
class HOM_GeometryViewportCamera;
class HOM_GeometryViewportSettings;
class HOM_Selection;
class HOM_Vector2;

SWIGOUT(%rename(GeometryViewport) HOM_GeometryViewport;)

class HOM_API HOM_GeometryViewport
{
public:
    HOM_GeometryViewport()
    { HOM_CONSTRUCT_OBJECT(this) }
    HOM_GeometryViewport(const HOM_GeometryViewport &)
    { HOM_CONSTRUCT_OBJECT(this) }
    virtual ~HOM_GeometryViewport()
    { HOM_DESTRUCT_OBJECT(this) }

    virtual std::string __repr__() = 0;

    SWIGOUT(%warnfilter(321) type;)
    virtual HOM_EnumValue& type() = 0;
    virtual void changeType(HOM_EnumValue &type) = 0;

    SWIGOUT(%newobject settings;)
    virtual HOM_GeometryViewportSettings *settings() = 0;

    virtual std::string name() = 0;
    virtual void changeName(std::string &name) = 0;

    virtual void home() = 0;

    virtual void homeAll() = 0;
    virtual void homeSelected() = 0;
    virtual void homeGrid() = 0;
    virtual void homeNonTemplated() = 0;
    virtual void homeBoundingBox(HOM_BoundingBox *bbox, bool center_to_origin = false) = 0;

    virtual void frameAll() = 0;
    virtual void frameBoundingBox(HOM_BoundingBox *bbox = NULL) = 0;
    virtual void frameSelected() = 0;
    virtual void frameGrid() = 0;
    virtual void frameNonTemplated() = 0;

    virtual void draw() = 0;

    SWIGOUT(%newobject viewTransform;)
    virtual HOM_Matrix4 *viewTransform() = 0;

    SWIGOUT(%newobject modelToGeometryTransform;)
    virtual HOM_Matrix4 *modelToGeometryTransform() = 0;
    SWIGOUT(%newobject cameraToModelTransform;)
    virtual HOM_Matrix4 *cameraToModelTransform() = 0;
    SWIGOUT(%newobject ndcToCameraTransform;)
    virtual HOM_Matrix4 *ndcToCameraTransform() = 0;
    SWIGOUT(%newobject viewportToNDCTransform;)
    virtual HOM_Matrix4 *viewportToNDCTransform() = 0;
    SWIGOUT(%newobject windowToViewportTransform;)
    virtual HOM_Matrix4 *windowToViewportTransform() = 0;

    SWIGOUT(%newobject viewPivot;)
    virtual HOM_Vector3 *viewPivot() = 0;

    virtual std::vector<int> resolutionInPixels() = 0;

    SWIGOUT(%newobject camera;)
    virtual HOM_ObjNode *camera() = 0;
    virtual std::string cameraPath() = 0;
    virtual void setCamera(HOM_ObjNode &camera_node) = 0;
    virtual void setCamera(const char *camera_path) = 0;
    virtual void saveViewToCamera(HOM_ObjNode &camera_node) = 0;

    SWIGOUT(%newobject defaultCamera;)
    virtual HOM_GeometryViewportCamera *defaultCamera() =0;
    virtual void setDefaultCamera(HOM_GeometryViewportCamera *cam_settings) =0;
    virtual void useDefaultCamera() =0;

    virtual bool isCameraLockedToView() = 0;
    virtual void lockCameraToView(bool) = 0;

    virtual bool isViewExportedToCameraContinuously() = 0;
    virtual void exportViewToCameraContinuously(bool) = 0;

    virtual bool isActive2D() = 0;
    virtual bool isActive3D() = 0;

    virtual bool         usesConstructionPlane() = 0;

    SWIGOUT(%newobject queryNodeAtPixel;)
    virtual HOM_Node    *queryNodeAtPixel(int x, int y, bool pick_templates=false) = 0;
    SWIGOUT(%newobject queryPrimAtPixel;)
    virtual HOM_Prim    *queryPrimAtPixel(HOM_Node *node, int x, int y) = 0;

    virtual std::vector<HOM_ElemPtr<HOM_Node>> _queryNodesInBox(int x, int y, int w, int h, bool pick_templates=false) = 0;

    virtual std::pair<int, int> _queryPrimOnDrawables(
            const std::vector<HOM_Drawable *> &drawables,
            int x, int y,
            bool enable_occlusion,
            bool handle_pick_radius = false) = 0;

    virtual std::vector<std::pair<int, HOM_ElemPtr<HOM_Selection> > >
        _queryComponentsOnDrawables(
            const std::vector<HOM_Drawable *> &drawables,
            HOM_Vector2 &start, HOM_Vector2 *end_inclusive = nullptr,
            bool enable_occlusion = false,
            bool contained = false) = 0;

    SWIGOUT(%newobject queryInspectedGeometry;)
    virtual HOM_Geometry        *queryInspectedGeometry() = 0;
    SWIGOUT(%newobject queryInspectedPrim;)
    virtual HOM_Prim            *queryInspectedPrim() = 0;

    virtual std::pair<HOM_ElemPtr<HOM_Vector3>, HOM_ElemPtr<HOM_Vector3> >
        mapToWorld(double x, double y) = 0;

    virtual HOM_Vector2 *mapToScreen(const HOM_Vector3 &pos) = 0;

    virtual std::pair<int, int> mapFromMouseChop(double x, double y) = 0;

    virtual UT_Tuple<HOM_ElemPtr<HOM_Vector3>, HOM_ElemPtr<HOM_Vector3>, bool >
        queryWorldPositionAndNormal(int x, int y,
                                    const HOM_EnumValue selection_restriction =
                                        HOM_snapSelectionMode::SnapToAll)=0;

    virtual std::vector<int> size() = 0;
    virtual std::vector<int> geometry() = 0;

    SWIGOUT(%ignore addOpaqueEventCallback;)
    virtual void addOpaqueEventCallback(void *callback) = 0;
    SWIGOUT(%ignore removeOpaqueEventCallback;)
    virtual void removeOpaqueEventCallback(void *callback) = 0;
    SWIGOUT(%ignore opaqueEventCallbacks;)
    virtual std::vector<void *> opaqueEventCallbacks() = 0;
    SWIGOUT(%ignore clearOpaqueEventCallbacks;)
    virtual void clearOpaqueEventCallbacks() = 0;

#ifdef SWIG
// expose the handling of the viewport callbacks to HOM
%extend
{
        void addEventCallback(InterpreterObject callback)
    {
        self->addOpaqueEventCallback(callback);
    }

    void removeEventCallback(InterpreterObject callback)
    {
        self->removeOpaqueEventCallback(callback);
    }

    void clearEventCallbacks()
    {
        self->clearOpaqueEventCallbacks();
    }

    std::vector<InterpreterObject> eventCallbacks()
    {
        std::vector<void *> opaque_callbacks(self->opaqueEventCallbacks());

        std::vector<InterpreterObject> callbacks;
        for (int i = 0; i< opaque_callbacks.size(); ++i)
            callbacks.push_back((InterpreterObject)opaque_callbacks[i]);
        return callbacks;
    }
}
#endif

};

#endif