GR_GeoRenderGL.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:        GR_GeoRender.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Base class for all drawing methds that Houdini is natively capable of
 *      rendering with OpenGL.
 */
#ifndef GR_GeoRenderGL_H
#define GR_GeoRenderGL_H

#include "GR_GeoRender.h"

#include <RE/RE_Types.h>

class RE_Render;
class RE_ElementArray;
class RE_Geometry;
class RE_Render;
class RE_Shader;
class RE_VertexArray;

class GR_API GR_GeoRenderGL : public GR_GeoRender
{
public:
     GR_GeoRenderGL(GR_Primitive *parent_prim);
    ~GR_GeoRenderGL() override;

     /// add an array to, or update an array in, an instance group. If
    /// 'instance_group' is -1, RE_VertexArray must specify an instance group
    /// via setInstanceGroup().
    virtual void        updateInstanceGroupArray(const RE_VertexArray *array,
                                                 int instance_group = -1,
                                                 const char *attrib_name = NULL,
                                                 RE_GenericAttribID id
                                                    = RE_GENATTRIB_NONE);


    RE_Geometry         *createGeometry(int npoints = 0);
    RE_Geometry         *getGeometry() override { return myGeometry; }
    void                 retireGeometry() override;

    void                 getPickConnectGroup(unsigned int pick_mode,
                                             GR_PickGeometry pick_geo,
                                             int &out_connect_start,
                                             int &out_connect_num) override;

    // Creates an RE_OverrideList (or adds to an existing one) for the color
    // and uv overrides if required. Cleanup will undo any changes to the
    // state setup made.
    void                setupGeoOverride(
                                RE_Render *r,
                                const GR_DisplayOption *opt,
                                RE_Geometry *geo,
                                UT_UniquePtr<RE_OverrideList> &override_list);
    void                cleanupGeoOverride(
                                RE_Render *r,
                                const GR_DisplayOption *opt,
                                RE_Geometry *geo);
    
    static RE_VertexArray *getDirtyAttribArray(
                                RE_Render                *r,
                                RE_Geometry              *geo,
                                const char               *attrib_name,
                                const GT_DataArrayHandle &h,
                                const GR_DisplayOption   &opts,
                                RE_ArrayType              atype,
                                RE_CacheVersion           attr_version);

    static void         fillGeoAttribs(RE_Render          *r,
                                       const GT_Primitive *prim,
                                       const GR_UpdateParms &p,
                                       RE_Geometry      *geo,
                                       bool              needs_nml,
                                       bool              needs_uv,
                                       bool              needs_tangent,
                                       bool              need_prim_vert_info, 
                                       const GT_DataArrayHandle &point_norm,
                                       GR_BasePrimType   packed_type,
                                       bool              build_point_id,
                                       bool              build_prim_id,
                                       GR_GeoRenderGL   *geo_ren = nullptr,
                                       bool *has_detail_prim_id = nullptr,
                                       int  *detail_prim_id = nullptr,
                                       int  *num_bone_deform = nullptr);
                                       

protected:
    void        initLights(RE_Render *r,
                           RE_Shader *sh,
                           GR_RenderMode mode,
                           GR_RenderFlags flags,
                           const GR_DisplayOption *opt);
    
    // For picking, these methods turn the GT __primitive_id, __vertex_id and
    // points (__vertex_id + vertexlist)
    void          buildPointID(RE_Render *r,
                               const GT_Primitive &prim,
                               const GU_ConstDetailHandle &geo,
                               RE_CacheVersion geo_version);
    void          buildPrimitiveID(RE_Render            *r,
                                   const GT_Primitive   &primh,
                                   const GU_ConstDetailHandle   &geo,
                                   RE_CacheVersion       geo_version);

    // GL32 stuff.
    GR_SelectMode       buildSelection(RE_Render                *r,
                                       const GR_UpdateParms     &parms,
                                       RE_Geometry              &obj,
                                       const GT_PrimitiveHandle &primh,
                                       const GT_DataArrayHandle &vertexlist);
    
    GR_SelectMode       addToPointSelection(RE_Render           *r,
                                            RE_VertexArray      *select_array,
                                            int                  length,
                                            const GU_Detail     &geo, 
                                            const GT_DataArrayHandle &vh,
                                            const GT_DataArrayHandle &vl,
                                            const GA_PointGroup *pntsel,
                                            bool use_vertex_for_point_select,
                                            bool &init);
    
    GR_SelectMode       addToVertexSelection(RE_Render          *r,
                                             RE_VertexArray     *select_array,
                                             int                 length,
                                             const GU_Detail    &geo, 
                                             const GT_DataArrayHandle &vh,
                                             const GA_VertexGroup *vertsel,
                                             bool               &init);
    
    GR_SelectMode       addToEdgeSelection(RE_Render            *r,
                                           RE_VertexArray       *select_array,
                                           int                   length,
                                           const GU_Detail      &geo, 
                                           const GT_DataArrayHandle &vt,
                                           const GT_DataArrayHandle &vert_list,
                                           const GA_EdgeGroup   *edgesel,
                                           bool                 &init);
    
    GR_SelectMode       addToPrimSelection(RE_Render                *r,
                                           RE_VertexArray           *sel_array,
                                           const GT_DataArrayHandle &vh,
                                           const GA_PrimitiveGroup  *primsel,
                                           bool                     &init);

    virtual GR_SelectMode addToBreakpointSelection(RE_Render *r,
                                                   RE_VertexArray *select,
                                                   int bpnt_len,
                                                   const GA_BreakpointGroup *bps,
                                                   bool &init);

    GR_SelectMode       buildInstanceSelection(RE_Render *r,
                                               const GR_UpdateParms &p,
                                               RE_Geometry &obj);

    void                fillAttributesGL3(RE_Render            *r,
                                          const GT_Primitive   *prim,
                                          const GR_UpdateParms &p,
                                          RE_Geometry   *geo,
                                          bool           needs_nml,
                                          bool           needs_uv,
                                          bool           needs_tangent,
                                          bool           need_prim_vert_info, 
                                          const GT_DataArrayHandle &point_norm);

    /// Set selection uniforms SELECT_MODE and SELECT_INSTANCE. Returns an int
    /// which should be passed to cleanup selection.
    virtual int         setupSelection(RE_Render *r,
                                       const GR_DisplayOption *opt,
                                       GR_RenderFlags flags,
                                       bool supports_outline = false) const;
    
    /// Clean up selection uniforms; much be paired with a setupSelection().
    virtual void        cleanupSelection(RE_Render *r, int key) const;

    void                updateWireColor(RE_Render *r,
                                        RE_Geometry *geo,
                                        const GR_DisplayOption *opt,
                                        int start_draw_idx,
                                        int num_draw_idx = 1) const;

    // Data
    RE_Geometry         *myGeometry;
};

#endif