DM_SceneHook.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:        DM_SceneHook.h ( DM Library, C++)
 *
 * COMMENTS:
 *      Base class to hook into various parts of the scene rendering pipeline.
 */
#ifndef DM_SCENE_HOOK_H
#define DM_SCENE_HOOK_H

#include "DM_API.h"
#include "DM_ViewportType.h"

#include <UT/UT_Rect.h>
#include <UT/UT_String.h>
#include <RE/RE_RenderContext.h>
#include <GR/GR_Defines.h>
#include <GR/GR_PickRecord.h>

class DM_VPortAgent;
class GUI_DisplayOption;
class RE_Light;
class RE_Render;
class OP_Node;

#define DM_SCENE_HOOK_VERSION 3

/// The rendering task that the hook performs.
enum DM_SceneHookType
{
    DM_HOOK_BACKGROUND,
    DM_HOOK_PRE_RENDER,
    DM_HOOK_BEAUTY,
    DM_HOOK_BEAUTY_TRANSPARENT,
    DM_HOOK_UNLIT,
    DM_HOOK_XRAY,
    DM_HOOK_POST_RENDER,
    DM_HOOK_FOREGROUND,

    // Replace-only hooks
    DM_HOOK_SHADOW,
    DM_HOOK_HQ_LIGHT_PASS,

    // Pick renders
    DM_HOOK_FRAMEBUFFER_PICK,
    DM_HOOK_FRUSTUM_PICK,
    
    DM_HOOK_FULL_SCENE
};

/// How the hook augments or replaces the native Houdini rendering task.
enum DM_SceneHookPolicy
{
    DM_HOOK_REPLACE_NATIVE = 0,
    DM_HOOK_BEFORE_NATIVE,
    DM_HOOK_AFTER_NATIVE
};

enum DM_SceneHookScope
{
    DM_HOOK_OBJSOPDOP_VIEW = 0x1,
    DM_HOOK_LOP_VIEW       = 0x2,
    
    DM_HOOK_ALL_VIEWS      = 0x3
};

/// Data structure for rendering scene hooks.
class DM_API DM_SceneHookData
{
public:
    // class containing all viewport display options
    const GUI_DisplayOption *disp_options;

    // Size of the viewport in pixels
    int                      view_width;
    int                      view_height;

    // only non-NULL in DM_HOOK_SHADOW and DM_HQ_LIGHT_PASS
    RE_Light                *light;

    // In case this is registered more than once to different spots, this
    // allows the hook to differentiate the callers.
    DM_SceneHookType         hook_type;
    DM_SceneHookPolicy       hook_policy;

    // For picking, what is being requested for picking
    // (GR_PICK_* in GR_PickRecord.h)
    int                      pick_type;
 
    // Frustum culling picks only
    UT_DimRect               pick_area;
    const uint8             *pick_mask;
};



/// Scene render hook instance, which does the actual rendering for a viewport
class DM_API DM_SceneRenderHook
{
public:
    /// A Scene render hook has a parent viewport and a view type mask which
    /// determines which viewport types it will display in (eg. perspective,
    /// ortho, UV, all). The viewer_scope determines which viewer type it will
    /// appear in (Obj/Sop/Dop, or Lop).
             DM_SceneRenderHook(DM_VPortAgent &vport,
                                DM_ViewportType view_mask);
    virtual ~DM_SceneRenderHook();

    /// @brief Restrict hook to only certain Viewport Renderer versions
    /// This method allows you to restrict this hook to only operate in some of
    /// the viewport renderers (H11 - GL3). If the viewport is set to a
    /// a renderer and this method returns false, it will be skipped. The
    /// default action is to support all viewport renderers.
    virtual bool         supportsRenderer(GR_RenderVersion version)
                            { return true; }

    /// @brief Render method called when the rendering task is required.
    /// render() performs the rendering task for the hook, or returns false if
    /// if it cannot. The RE_Render contains the active GL context and the
    /// hook_data contains viewport-specific and hook-specific data.
    virtual bool         render(RE_RenderContext r,
                                const DM_SceneHookData &hook_data) = 0;

    /// @brief Callback method when the viewport is no longer visible.
    /// Called when the viewport is temporarily closed (quad/single switch, pane
    /// switch). This gives the hook the opportunity to clean up expensive GL
    /// objects or caches.
    virtual void         viewportClosed();

    /// For hooks that register with DM_HOOK_FRAMEBUFFER_PICK, this reports the
    /// selection back to the hook once it is complete.
    /// only picks for this hook are returned, and this may be an empty list.
    virtual void selectionResult(const UT_Array<GR_PickRecord> &selection);
   
    /// Viewport this scene render is attached to.
    DM_VPortAgent       &viewport() const { return myAgent; }
    DM_ViewportType      getViewportMask() const { return myViewportMask; }
    int                  getID() const { return myID; }

    /// Get the currently displayed LOP (LOP hook specific)
    const OP_Node       *getDisplayLOP() const;

    /// Get the current LOP, the LOP that is displaying handles and in the parm
    /// dialog (LOP hook specific)
    const OP_Node       *getCurrentLOP() const;
private:
    DM_VPortAgent       &myAgent;
    DM_ViewportType      myViewportMask;
    int                  myID;
};



/// A Scene Hook creates new scene render hooks when new viewports are created.
class DM_API DM_SceneHook
{
public:
    /// Create a scene hook which creates scene render hook instances for
    /// specific viewports. Only one scene hook is ever created, and it is
    /// responsible for managing the scene render hooks for viewports.
    /// Each hook requires a name (for error reporting) and a priority level
    /// to resolve multiple scene hook conflicts.
             DM_SceneHook(const char *hook_name,
                          int priority,
                          DM_SceneHookScope viewer_scope); 
    virtual ~DM_SceneHook();

    const char                 *getName() const     { return myHookName; }
    int                         getPriority() const { return myPriority; }
    DM_SceneHookScope           getViewerScope() const { return myViewerScope; }

    /// @brief Called when a viewport needs to create a new hook.
    /// Each viewport has its own scene hook.
    virtual DM_SceneRenderHook *newSceneRender(DM_VPortAgent &vport,
                                               DM_SceneHookType type,
                                               DM_SceneHookPolicy policy) = 0;

    /// @brief Called when a viewport no longer requires the hook.
    /// When a viewport is destroyed, it retires all its hooks. Because a hook
    /// could be shared between all viewports, this method gives the scene hook
    /// the opportunity to delete it, dereference it, etc. The viewport doing
    /// the retiring is passed in along with the hook it is retiring.
    virtual void                retireSceneRender(DM_VPortAgent &vport,
                                                  DM_SceneRenderHook *hook) = 0;

private:
    UT_String           myHookName;
    int                 myPriority;
    DM_SceneHookScope   myViewerScope;
};
#endif