GR_Light.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_Light.h (GR Library, C++)
 *
 * COMMENTS:
 *      Light list and base class for all lights.
 *      Specific lights are defined in GR_LightTypes.h.
 */
#ifndef GR_Light_h
#define GR_Light_h

#include "GR_API.h"
#include "GR_Defines.h"
#include "GR_SceneItem.h"

#include <RE/RE_RenderContext.h>
#include <UT/UT_Array.h>
#include <UT/UT_BoundingBox.h>
#include <UT/UT_Map.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Set.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_Vector4.h>
#include <UT/UT_IntArray.h>

class RV_Instance;
class RV_Render;
class RV_ShaderBlock;
class RV_ShaderProgram;
class RV_ShaderProgramBase;
class RV_ShaderVariableSet;
class RV_TextureRef;
class RV_VKImage;
class GR_CommonDispOption;

/// Base class for all light types
class GR_API GR_Light : public GR_SceneItem
{
public:
    enum LightType
    {
        AMBIENT,
        DISTANT,
        POINT,
        ENVIRONMENT,
        AREA
    };

    LightType    type() const { return myType; }

    bool         isHeadlight() const { return myIsHeadlight; }
    void         setHeadlight(bool e) { myIsHeadlight = e; }

    bool         isEnabled() const { return myIsEnabled; }
    void         setEnabled(bool e) { myIsEnabled = e; }

    bool         canShadow() const { return myCanShadow; }
    void         setCanShadow(bool e) { myCanShadow = e; }

    bool         shadowEnabled() const { return myShadowEnabled; }
    void         setShadowEnabled(bool s) { myShadowEnabled = s; }

    void         setLightID(exint id) { setID(id); }

    void         setInstanceTransforms(const UT_Matrix4FArray &transforms,
                                       const UT_Vector4FArray &colors);
    bool         isInstanced() const { return (myInstanceParms.size()>0); }
    int          numInstances() const { return myInstanceParms.size(); }

    bool         initSceneSetForRender(
                        RV_Render *r,
                        RV_ShaderProgramBase *shader,
                        UT_UniquePtr<RV_ShaderBlock> &scene_block,
                        UT_UniquePtr<RV_ShaderVariableSet> &scene_set);
    bool         initLightSetForRender(RV_Render *r,
                                       RV_ShaderProgramBase *shader);
    bool         bindSets(RV_Render *r, RV_ShaderProgramBase *shader);
    virtual bool initBlocks(RV_Render *r, const GR_CommonDispOption &opts) = 0;
    bool         isDirty() const { return myDirtyFlag; }

    // returns number of required shadow render passes (see DM_RenderVulkan.C)
    virtual unsigned setupShadowRenders(RE_RenderContext,
                                        GR_RenderMode &out_render_mode,
                                        bool scene_changed,
                                        unsigned shadowmap_size,
                                        const GR_DistantShadowMapParms&) = 0;
    virtual RV_ShaderProgram *getShader(bool shadows, bool per_sample,
                                        bool is_antialiased,
                                        bool is_raytrace) = 0;
    static  RV_ShaderProgram *getAmbientOcclusionShader(bool is_raytrace);

    virtual bool         canRayTraceShadow() const { return false; }
    
    // Returns true if the shadowmap render was started, false otherwise.
    // Eg. returns false when the shadowmap is already up-to-date.
    virtual void startShadowRender(RE_RenderContext rc,
                                   unsigned shadowmap_index) {}
    virtual void finishShadowRender(RE_RenderContext) {}
    virtual void finishShadowRenders(RE_RenderContext) {}
    virtual bool needsShadowMap() = 0;
    virtual bool hasShadowMap() = 0;
    virtual void attachShadowMap(RE_RenderContext) {}
    virtual void clearShadowMap() {}

    // Secondary "gsplats-excluded" shadow map used to suppress gsplats
    // self-shadowing.
    virtual unsigned setupGsplatShadowRenders(RE_RenderContext,
                                              GR_RenderMode &out_render_mode,
                                              bool scene_changed,
                                              unsigned shadowmap_size,
                                              const GR_DistantShadowMapParms&)
                     { return 0; }
    virtual void startGsplatShadowRender(RE_RenderContext,
                                         unsigned shadowmap_index) {}
    virtual void finishGsplatShadowRender(RE_RenderContext) {}
    virtual void finishGsplatShadowRenders(RE_RenderContext) {}
    virtual bool hasGsplatShadowMap() { return false; }
    virtual void attachGsplatShadowMap(RE_RenderContext) {}
    virtual void clearGsplatShadowMap() {}

    static bool initShaders(RV_Instance *inst);
    static void cleanupShaders();

    void        setLightLink(const UT_StringHolder &link) { myLightLink=link; }
    const UT_StringHolder &lightLink() const { return myLightLink; }
    virtual void setShadowMask(const UT_StringHolder &mask)
        { myShadowMask=mask; }
    const UT_StringHolder &shadowMask() const { return myShadowMask; }
    
protected:
    GR_Light(const UT_StringHolder &name, LightType type);
    ~GR_Light() override;
    
    UT_NON_COPYABLE(GR_Light);

    bool   privInitBlocks(RV_Render *r,
                          void *light_block, int light_size,
                          void *shadow_block, int shadow_size);
    void   privBindTexture(RV_Render *r, const UT_StringHolder &map_name,
                           int rel_op_id, RV_TextureRef &map_id,
                           const UT_StringHolder &sampler_name,
                           const GR_CommonDispOption &opts,
                           RV_TextureParms *tex_parms = nullptr,
                           bool is_cube = false);
    void   initTexParms(RV_Render *r, const GR_CommonDispOption &opts,
                        RV_TextureParms &parms) const;

    static RV_ShaderProgram *privGetShader(exint tags);
    
    UT_UniquePtr<RV_ShaderVariableSet>  myLightSet;
    UT_UniquePtr<RV_ShaderBlock>  myLightBlock;
    UT_UniquePtr<RV_ShaderBlock>  myShadowBlock;
    UT_UniquePtr<RV_ShaderBlock>  myInstanceBlock;

    bool myDirtyFlag;
    bool myShadowDirtyFlag;
    bool mySetBound;
    UT_StringHolder myShadowMask;

    enum
    {
        GLOBAL_SET = 0,
        LIGHT_SET = 1
    };

    struct LightTag
    {
        exint Cube              =0;
        exint Cylinder          =0;
        exint Distant           =0;
        exint Ellipse           =0;
        exint Ellipsoid         =0;
        exint Forward           =0;
        exint Point             =0;
        exint Rectangle         =0;
        exint Shadow            =0;
        exint Spot              =0;
        exint Ambient           =0;
        exint Env               =0;
        exint PerSample         =0;
        exint AmbOcclusion      =0;
        exint RayTrace          =0;
        exint QualityShadows    =0;
    };

    static LightTag Tag;
private:
    struct InstanceParms
    {
        UT_Matrix4F transform;
        UT_Vector4F color;
    };
    UT_Array<InstanceParms> myInstanceParms;
    UT_StringHolder myLightLink;
    LightType       myType;
    uint32
        myIsHeadlight :1,
        myCanShadow   :1,
        myShadowEnabled: 1,
        myIsEnabled   :1;

};

static inline void intrusive_ptr_add_ref(GR_Light *gl) { gl->incref(); }
static inline void intrusive_ptr_release(GR_Light *gl) { gl->decref(); }

// List of lights currently contributing to the scene
class GR_API GR_LightList 
{
public:
    uint32      getLightMask(const UT_Set<int> &active) const;

    bool        useHeadlights() const { return myUseHeadlights; }
    void        setUseHeadlights(bool v) { myUseHeadlights = v; }

    void        setShadowingLight(int id) { myShadowingLight = id; }
    const GR_Light *getShadowingLight() const
                 { return getLight(myShadowingLight).get(); }

    exint entries() const { return myList.entries(); }

    exint inUseLightCount() const
    {
        exint count = myList.entries() - myBaseIndex;
        if (myReducedIndices.entries())
            count = SYSmin(myReducedIndices.entries() - myBaseIndex, count);
        if (myMaxLights >= 0)
            count = SYSmin(myMaxLights, count);
        return count;
    }

    bool hasLight(int id) const
    {
        auto entry = myLightMap.find(id);
        return (entry != myLightMap.end());
    }

    // Fetch by light ID
    GR_LightPtr getLight(int id) const
    {
        auto entry = myLightMap.find(id);
        if(entry != myLightMap.end())
            return myList(entry->second);
        return GR_LightPtr();
    }

    // Fetch by order in the light list (for masking)
    GR_LightPtr getLightByIndex(int index) const
    {
        return myList(index);
    }
    
    GR_LightPtr getInUseLightByIndex(int index) const
    {
        index = myBaseIndex + index;
        if (myReducedIndices.isValidIndex(index))
            index = myReducedIndices(index);
        if (myList.isValidIndex(index))
            return myList(index);
        return GR_LightPtr();
    }

    void        add(int id, GR_Light *new_light)
    {
        UT_ASSERT(!myLightMap.contains(id));
        myLightMap[id] = int(myList.entries());
        myList.append(new_light);
    }
    bool        remove(int id)
    {
        auto entry = myLightMap.find(id);
        if(entry != myLightMap.end())
        {
            int index = entry->second;
            myLightMap.clear();
            myList.removeIndex(index);
            for(int i=0; i<myList.entries(); i++)
                myLightMap[myList(i)->id()] = i;
            return true;
        }
        return false;
    }
    void        removeAll();
    void        removeAllBut(const UT_Set<int> &active_lights);
    void        removeHeadLights();

    bool hasRemapping() const 
    {
        return myBaseIndex != 0 || myMaxLights != -1
               || !myReducedIndices.isEmpty();
    }

    void setBaseIndex(exint idx) { myBaseIndex = idx; }
    void setMaxLights(exint max) { myMaxLights = max; }
    void setInUseIndices(const UT_IntArray &list) { myReducedIndices = list; }

    void removeRemappings()
    {
        myBaseIndex = 0;
        myMaxLights = -1;
        myReducedIndices.clear();
    }

private:
    bool myUseHeadlights = false;
    UT_Map<int,int> myLightMap;
    UT_Array<GR_LightPtr> myList;
    int myShadowingLight = -1;

    exint myBaseIndex = 0;
    exint myMaxLights = -1;
    UT_IntArray myReducedIndices;
};

#endif