GR_PolyCurveGL3.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_PolyCurveGL3.h ( GR Library, C++)
 *
 * COMMENTS:
 *      Polygon curve rendering in GL3.
 */
#ifndef GR_PolyCurveGL3_h
#define GR_PolyCurveGL3_h

#include "GR_GeoRenderGL.h"
#include <GT/GT_DataArray.h>
#include <RE/RE_Material.h>

class GU_Detail;
class RE_VertexArray;
class GT_PrimCurveMesh;
class RE_Shader;

// The non-extruded line connectivity (GL_LINES). All others will
// have thickness when in shaded modes (TODO)
#define GR_BASIC_WIRE_IDX       1

class GR_API GR_PolyCurveGL3 : public GR_GeoRenderGL
{
public:
             GR_PolyCurveGL3(GR_Primitive *prim);
            ~GR_PolyCurveGL3() override;

    void        setSubdivisionCurve(bool subdiv);

    const char         *className() const override { return "GR_PolyCurveGL3"; }
    
    void                update(RE_RenderContext r,
                               const GT_PrimitiveHandle &primh,
                               const GR_UpdateParms     &parms,
                               const char               *cache_name) override;

    void                draw(RE_RenderContext r,
                             GR_RenderMode mode,
                             GR_RenderFlags flags,
                             GR_DrawParms dp) override;
    
    bool                supportsInstances() const override { return true; }
    void                geometryUpdated(RE_RenderContext r) override;

    static GT_PrimitiveHandle   getCurveMesh(const GT_PrimitiveHandle &primh,
                                             const GR_UpdateParms &parms);

    void                        setSplineParms(const void *spline,
                                               int nu, int nv, 
                                               bool uwrap, bool vwrap,
                                               int density)
                                {   mySpline = spline;
                                    myNumU = nu;
                                    myNumV = nv;
                                    myDensity = density;
                                    myWrapU = uwrap;
                                    myWrapV = vwrap;
                                }

    exint              getNumGLPrimitives() const override;

    // fetch LOD parameters for SudD curves based on display options
    static void         getLODParms(const GR_DisplayOption *opt,
                                    UT_Vector2F &lod_parms);
private:
    
    void                buildConnectivity(RE_Render *r,
                                          const GT_PrimCurveMesh *cmesh,
                                          const char *cache_name,
                                          RE_CacheVersion geo_version,
                                          const RE_MaterialAtlas &mats);
    
    void                addCurveToElement(RE_Render *r,
                                          const GT_PrimCurveMesh *cmesh,
                                          int curve_indexi,
                                          RE_ElementArray *element,
                                          const int curve_vertex_cutoff,
                                          UT_IntArray &temp);

    inline int          getNumMaterials() const
                                { return myMaterials.entries(); }

    void                buildPrimInfo(RE_Render *r,
                                      const GT_PrimCurveMesh *cmesh,
                                      const GR_UpdateParms &parms,
                                      RE_CacheVersion geo_version,
                                      RE_Geometry *geo);

    void                buildLineConnectivity(RE_Render *r,
                                              const GT_PrimCurveMesh *cmesh,
                                              const char *cache_name,
                                              RE_CacheVersion version);
    
    int                 setupSelection(RE_Render *r,
                                       const GR_DisplayOption *opt,
                                       GR_RenderFlags flags,
                                       bool support_outline=false) const override;

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

    void                drawHairShadow(RE_Render *r,
                                       const GR_DisplayOption *opt,
                                       int num_materials,
                                       int instance_group,
                                       bool subdiv);

    void                updateFeatherAttribs(RE_Render *r,
                                          const GT_PrimCurveMesh *cmesh,
                                          RE_CacheVersion &geo_version);

    struct BarbAttrib
    {
        UT_StringRef         myName;
        UT_StringRef         myVarName;
        int                  myVecSize = 3;
        RE_VertexArray      *myArray = nullptr;
        exint                myPointCount = 0;
    };

    struct BarbConfig
    {
        int             myDrawMode;
    };

    RE_VertexArray      *myCd;
    RE_VertexArray      *myAlpha;
    bool                 myHasDetailCd;
    bool                 myHasDetailAlpha;
    bool                 myHasPrimAttribs;
    bool                 myHasWidthAttrib;
    bool                 myHasNormalAttrib;
    bool                 myHasTangentAttrib;
    bool                 myHasUVAttrib;
    bool                 myHasBarbAttribs;
    bool                 myHasBarbOrientAttrib;
    bool                 myObjectSelectedFlag;
    UT_Array<BarbAttrib> myBarbAttribs;
    BarbConfig           myBarbConfig;
    RE_CacheVersion      myLastTopVersion;
    GT_PrimitiveHandle   myRefinedBezier;
    bool                 myUseFurShaders;
    bool                 myHasFurShader;
    bool                 myUseSparkShaders;
    RE_Texture          *myRandomTex;
    RE_Texture          *myRandomMaskTex;
    int                  myRandomMaskTexSamples;

    UT_IntArray          myMaterials;
    RE_MaterialPtr       myDefaultHairShader;
    
    // For splines, such as bezier or NURBS. Defines the isoparm detail for
    // breakpoint selections.
    const void           *mySpline;      
    int                   myNumU, myNumV;
    bool                  myWrapU, myWrapV;
    int                   myDensity;

    // subd curves
    bool                 myIsSubdivisionCurve;
    
    int                  myHairShadowPassID;
};
#endif