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_Matrix4.h>

class RE_LightList;
class RV_Instance;
class RV_Render;
class RV_ShaderBlock;
class RV_ShaderProgram;
class RV_ShaderProgramBase;
class RV_ShaderVariableSet;
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; }

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

    bool         initSceneSetForRender(
                        RV_Render *r,
                        RV_ShaderProgram *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;
   
    // 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) = 0;
    static  RV_ShaderProgram *getAmbientOcclusionShader();
    // 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 hasShadowMap() = 0;
    virtual void attachShadowMap(RE_RenderContext) {}

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

    void        setLightLink(const UT_StringHolder &link) { myLightLink=link; }
    const UT_StringHolder &lightLink() const { return myLightLink; }
    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);
    
#ifdef USE_VULKAN
    UT_UniquePtr<RV_ShaderVariableSet>  myLightSet;
    UT_UniquePtr<RV_ShaderBlock>  myLightBlock;
    UT_UniquePtr<RV_ShaderBlock>  myShadowBlock;
#endif
    bool myDirtyFlag;
    bool myShadowDirtyFlag;
    bool mySetBound;

    enum
    {
        GLOBAL_SET = 0,
        LIGHT_SET = 1
    };

private:
    UT_StringHolder myLightLink;
    UT_StringHolder myShadowMask;
    LightType       myType;
    uint32
        myIsHeadlight :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;

    void          setGLLights(RE_LightList *list) { myGLLights = list; }
    const RE_LightList *glLights() const { return myGLLights; }
          RE_LightList *glLights()       { return myGLLights; }

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

    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); }
    
    void        add(int id, GR_Light *new_light)
    {
        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);

private:
    RE_LightList *myGLLights = nullptr;
    UT_Map<int,int> myLightMap;
    UT_Array<GR_LightPtr> myList;
};

#endif