GR_LightTypes.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_LightTypes.h (GR Library, C++)
 *
 * COMMENTS:
 *      
 */
#ifndef GR_LightTypes_h
#define GR_LightTypes_h

#include "GR_Light.h"
#include "GR_Defines.h"

#include <RV/RV_Render.h>
#include <RV/RV_TextureCache.h>
#include <RV/RV_VKEnum.h>

#include <UT/UT_StringHolder.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_UniquePtr.h>

class GR_DistantShadowMap;
class GR_PointShadowMap;
class RV_Render;
class RV_Geometry;
class RV_ShaderProgram;
class GUI_DetailLook;

#define LIGHTPARM(TYPE, NAME)                       \
    TYPE get##NAME() const { return myLight.NAME; } \
    void set##NAME(const TYPE &v)                   \
    { if(myLight.NAME != v) { myLight.NAME=v; myDirtyFlag=true; } }
#define SHADOWPARM(TYPE, NAME)                       \
    TYPE get##NAME() const { return myShadow.NAME; } \
    void set##NAME(const TYPE &v) \
    { if(myShadow.NAME != v) { myShadow.NAME=v; myShadowDirtyFlag=true; } }
// parameters affecting the shadowmap
#define LIGHTPARM_SM(TYPE, NAME)                       \
    TYPE get##NAME() const { return myLight.NAME; } \
    void set##NAME(const TYPE &v)                   \
    { if(myLight.NAME != v) {               \
          myLight.NAME=v; myDirtyFlag=true; myShadowMapDirtyFlag=true; } }
#define SHADOWPARM_SM(TYPE, NAME)                       \
    TYPE get##NAME() const { return myShadow.NAME; } \
    void set##NAME(const TYPE &v) \
    { if(myShadow.NAME != v) { \
          myShadow.NAME=v; myShadowDirtyFlag=true; \
          myShadowMapDirtyFlag=true;} }

/// Distant (infinite) light. Rays parallel
class GR_API GR_DistantLight : public GR_Light
{
    typedef UT_FixedArray<UT_Matrix4F, 4> XformsArray;
    typedef UT_FixedArray<UT_Matrix4F, 2> InvXformsArray;
    typedef UT_FixedArray<fpreal32, 4> BiasesArray;
    typedef UT_FixedArray<fpreal32, 4> DepthsArray;
public:
    GR_DistantLight(const UT_StringHolder &name);
    ~GR_DistantLight() override; // For UT_UniquePtr<> on WIN
    UT_NON_COPYABLE(GR_DistantLight);

    LIGHTPARM_SM(UT_Vector3F, Dir);
    LIGHTPARM(UT_Vector3F, Color);
    LIGHTPARM_SM(int32, WorldSpace);
    LIGHTPARM(int32, UseSpecular);
    
    SHADOWPARM_SM(XformsArray, Xforms);
    SHADOWPARM_SM(InvXformsArray, InvXforms);
    SHADOWPARM_SM(BiasesArray, Biases);
    SHADOWPARM_SM(DepthsArray, Depths);
    SHADOWPARM(fpreal32, ShadowIntensity);

    bool initBlocks(RV_Render *r, const GR_CommonDispOption &opts) override
    {
        return privInitBlocks(r, &myLight, sizeof(Light),
                              &myShadow, sizeof(Shadow));
    }
    
    RV_ShaderProgram *getShader(bool shadows, bool per_sample,
                                bool is_antialiased,
                                bool is_raytrace) override;

    void clearShadowMap() override;
private:
    unsigned setupShadowRenders(RE_RenderContext,
                                GR_RenderMode &out_render_mode,
                                bool scene_changed,
                                unsigned shadowmap_size,
                                const GR_DistantShadowMapParms&) override;
    void startShadowRender(RE_RenderContext,
                           unsigned shadowmap_index) override;
    void finishShadowRender(RE_RenderContext) override;
    void finishShadowRenders(RE_RenderContext) override;
    bool needsShadowMap() override { return true; }
    bool hasShadowMap() override { return myShadowMap.get(); }
    void attachShadowMap(RE_RenderContext) override;

    struct Light
    {
        UT_Vector3F Dir   = {0.0, 0.0, 1.0};
        int32       WorldSpace = true;
        UT_Vector3F Color = {1.0, 1.0, 1.0};
        int32       UseSpecular = true;
    } myLight;
    
    struct Shadow
    {
        XformsArray Xforms;
        InvXformsArray InvXforms;
        BiasesArray Biases;
        DepthsArray Depths;
        fpreal32 ShadowIntensity;
    } myShadow;

    UT_UniquePtr<GR_DistantShadowMap> myShadowMap;
    bool myShadowMapDirtyFlag = true;
};

// Point Light (spot or omni). Inifinitely small source.
class GR_API GR_PointLight : public GR_Light
{
public:
    GR_PointLight(const UT_StringHolder &name);
    ~GR_PointLight() override; // For UT_UniquePtr<> on WIN
    UT_NON_COPYABLE(GR_PointLight);

    LIGHTPARM(UT_Matrix4F, Projection);
    LIGHTPARM(UT_Vector4F, Focus);
    LIGHTPARM_SM(UT_Vector3F, Pos);
    LIGHTPARM_SM(UT_Vector3F, Dir);
    LIGHTPARM(UT_Vector3F, LightX);
    LIGHTPARM(UT_Vector3F, LightY);
    LIGHTPARM(UT_Vector3F, Color);
    LIGHTPARM(UT_Vector3F, Atten);
    LIGHTPARM(UT_Vector2F, ActiveRadius);
    LIGHTPARM(UT_Vector2F, AttenRange);
    LIGHTPARM(UT_Vector2F, AttenRampRange);
    LIGHTPARM(UT_Vector2F, LeftBarn);
    LIGHTPARM(UT_Vector2F, RightBarn);
    LIGHTPARM(UT_Vector2F, TopBarn);
    LIGHTPARM(UT_Vector2F, BottomBarn);
    LIGHTPARM_SM(fpreal32, Cutoff);
    LIGHTPARM(fpreal32, Falloff);
    LIGHTPARM(fpreal32, SpotRolloff);
    LIGHTPARM(int32, HasSpot);
    LIGHTPARM(int32, HasProject);
    LIGHTPARM(int32, ProjectClamp);
    LIGHTPARM(int32, HasAttenRamp);
    
    SHADOWPARM_SM(UT_Matrix4F, ShadowTransform);
    SHADOWPARM_SM(fpreal32, ShadowBias);
    SHADOWPARM(fpreal32, ShadowIntensity);

    void setProjectMap(const UT_StringHolder &map_name, int op_id)
    {
        if(myProjectMap != map_name || myProjectMapOpId != op_id)
        {
            myProjectMap = map_name;
            myProjectMapOpId = op_id;
#ifdef USE_VULKAN
            myProjectMapRef.reset();
#endif
            myTexDirty = true;
        }
    }
    const UT_StringHolder &projectMap() const { return myProjectMap; }
    int                    projectMapOpId() const { return myProjectMapOpId; }
    
    bool initBlocks(RV_Render *r, const GR_CommonDispOption &opts) override
    {
#ifdef USE_VULKAN
        RV_TextureCache::checkTextureDirty(myProjectMapRef, myTexDirty);
#endif
        if(myTexDirty)
        {
            myTexDirty = false;
#ifdef USE_VULKAN
            privBindTexture(r, myProjectMap, myProjectMapOpId, myProjectMapRef,
                            "projectMap", opts);
#endif
        }
        return privInitBlocks(r, &myLight, sizeof(Light),
                              &myShadow, sizeof(Shadow));
    }
    
    RV_ShaderProgram *getShader(bool shadows, bool per_sample,
                                bool is_antialiased,
                                bool is_raytrace) override;

    void clearShadowMap() override;
private:
    friend class GR_PointShadowMap;
    bool shouldUseCubeMap();
    unsigned setupShadowRenders(RE_RenderContext,
                                GR_RenderMode &out_render_mode,
                                bool scene_changed,
                                unsigned shadowmap_size,
                                const GR_DistantShadowMapParms&) override;
    void startShadowRender(RE_RenderContext,
                           unsigned shadowmap_index) override;
    void finishShadowRender(RE_RenderContext) override;
    void finishShadowRenders(RE_RenderContext) override;
    bool needsShadowMap() override { return true; }
    bool canRayTraceShadow() const override { return true; }
    bool hasShadowMap() override { return myShadowMap.get(); }
    void attachShadowMap(RE_RenderContext) override;

    struct Light
    {
        UT_Matrix4F Projection;
        UT_Vector4F Focus = {0.0, 0.0, 0.0, 0.0};
        UT_Vector3F Pos   = {0.0, 0.0, 1.0};
        fpreal32    unused1 = 0.0;
        UT_Vector3F Dir   = {0.0, 0.0, 1.0};
        fpreal32    unused2 = 0.0;
        UT_Vector3F LightX= {1.0, 0.0, 0.0};
        fpreal32    unused3 = 0.0;
        UT_Vector3F LightY= {0.0, 1.0, 0.0};
        fpreal32    unused4 = 0.0;
        UT_Vector3F Color = {1.0, 1.0, 1.0};
        fpreal32    unused5 = 0.0;
        UT_Vector3F Atten = {0.0, 0.0, 1.0};
        fpreal32    unused6 = 0;
        UT_Vector2F ActiveRadius = { 0.0, 1e20 };
        UT_Vector2F LeftBarn   = { 0.0, 0.0 };
        UT_Vector2F RightBarn  = { 0.0, 0.0 };
        UT_Vector2F TopBarn    = { 0.0, 0.0 };
        UT_Vector2F BottomBarn = { 0.0, 0.0 };
        UT_Vector2F AttenRange = { 0.0, 1e20 };
        UT_Vector2F AttenRampRange = { 0.0, 0.0 };
        fpreal32    Cutoff = -1.0;
        fpreal32    Falloff = -1.0;
        fpreal32    SpotRolloff = 1.0;
        int32       HasSpot = false;
        int32       HasProject = false;
        int32       ProjectClamp = false;
        int32       HasAttenRamp = false;
    } myLight;
    
    struct Shadow
    {
        UT_Matrix4F ShadowTransform;
        fpreal32 ShadowBias = 0.01;
        fpreal32 ShadowIntensity = 1.0;
    } myShadow;

    bool            myTexDirty = true;
    UT_StringHolder myProjectMap;
    int             myProjectMapOpId = -999;
#ifdef USE_VULKAN
    RV_TextureRef   myProjectMapRef;
#endif

    bool myShadowMapDirtyFlag = true;
    UT_UniquePtr<GR_PointShadowMap> myShadowMap;
};

/// Distant (infinite) light. Rays parallel
class GR_API GR_AmbientLight : public GR_Light
{
public:
    GR_AmbientLight(const UT_StringHolder &name)
        : GR_Light(name, AMBIENT)
        {}
    ~GR_AmbientLight() override; // For UT_UniquePtr<> on WIN
    UT_NON_COPYABLE(GR_AmbientLight);

    LIGHTPARM(UT_Vector3F, Color);
    
    bool initBlocks(RV_Render *r, const GR_CommonDispOption &opts) override
    {
        return privInitBlocks(r, &myLight, sizeof(Light), nullptr, 0);
    }
    
    RV_ShaderProgram *getShader(bool shadows, bool per_sample,
                                bool is_antialiased,
                                bool is_raytrace) override;
    
    unsigned setupShadowRenders(RE_RenderContext,
                                GR_RenderMode &out_render_mode,
                                bool scene_changed,
                                unsigned shadowmap_size,
                                const GR_DistantShadowMapParms&) override
    { return 0; }
    bool needsShadowMap() override { return false; }
    bool hasShadowMap() override { return false; }

private:
    struct Light
    {
        UT_Vector3F Color = {1.0, 1.0, 1.0};
    } myLight;
};

/// Environment light. Infinitely far away incoming rays from all directions.
class GR_API GR_EnvLight : public GR_Light
{
public:
    GR_EnvLight(const UT_StringHolder &name)
        : GR_Light(name, ENVIRONMENT)
        {}
    ~GR_EnvLight() override; // For UT_UniquePtr<> on WIN
    UT_NON_COPYABLE(GR_EnvLight);

    LIGHTPARM(UT_Matrix4F, EnvRotate);
    LIGHTPARM(UT_Vector3F, Color);

    void setEnvMap(const UT_StringHolder &map_name, int op_id)
    {
        if(myEnvMap != map_name || myEnvMapOpId != op_id)
        {
            myEnvMap = map_name;
            myEnvMapOpId = op_id;
            if(map_name.isstring() != (myLight.HasMap!=0))
            {
                myLight.HasMap = map_name.isstring();
                myDirtyFlag = true;
            }
            
#ifdef USE_VULKAN
            myEnvMapRef.reset();
#else
            myEnvMapRef = 0; // to suppress unused member warning
#endif
            myTexDirty = true;
        }
        else if (myEnvMapOpId && !myIsSkyMap)
        {
            // always dirty Op textures
            myTexDirty = true;
        }
        myIsSkyMap = false;
    }
    const UT_StringHolder &envMap() const     { return myEnvMap; }
    int                    envMapOpId() const { return myEnvMapOpId; }
    
    bool initBlocks(RV_Render *r, const GR_CommonDispOption &opts) override
    {
#ifdef USE_VULKAN
        RV_TextureCache::checkTextureDirty(myEnvMapRef, myTexDirty);
#endif
        if(myTexDirty)
        {
            myTexDirty = false;
            if(myIsSkyMap)
            {
                createAndCacheSkyMap(r, myEnvMap, 256,
                                     myGroundColor,myGroundAlbedo, myTurbidity,
                                     myHorizonBlur,myAltitude,myAzimuth);

            }
#ifdef USE_VULKAN
            RV_TextureParms parms;
            parms.MipMap = true;
            initTexParms(r, opts, parms);
            privBindTexture(r, myEnvMap, myEnvMapOpId, myEnvMapRef, "envMap",
                            opts, &parms, true);
#endif
        }
        return privInitBlocks(r, &myLight, sizeof(Light), nullptr, 0);
    }
    
    RV_ShaderProgram *getShader(bool shadows, bool per_sample,
                                bool is_antialiased,
                                bool is_raytrace) override;

    bool     setSkyMapParms(const char *map_name,
                            const UT_Vector3F &gcol,
                            const UT_Vector3F &galbedo,
                            fpreal turbidity,
                            fpreal horizon_blur,
                            fpreal solar_altitude,
                            fpreal solar_azimuth)
    {
        if(gcol != myGroundColor || galbedo != myGroundAlbedo ||
           turbidity != myTurbidity || horizon_blur != myHorizonBlur ||
           solar_altitude != myAltitude || solar_azimuth != myAzimuth)
        {
            myGroundColor = gcol;
            myGroundAlbedo = galbedo;
            myTurbidity = turbidity;
            myHorizonBlur = horizon_blur;
            myAltitude = solar_altitude;
            myAzimuth = solar_azimuth;
            myEnvMap = map_name;
            myEnvMapOpId = -999;
            myTexDirty = true;
            myIsSkyMap = true;
            myLight.HasMap = true;
            return true;
        }
        return false;
    }

    bool        hasMap() const { return myLight.HasMap; }

private:
    unsigned setupShadowRenders(RE_RenderContext,GR_RenderMode&,bool,unsigned,
                                const GR_DistantShadowMapParms&) override
             { return 0; }
    bool needsShadowMap() override { return false; }
    bool hasShadowMap() override { return false; }

    // Defined in GR_Light.C.
    bool     createAndCacheSkyMap(RV_Render *r,
                                  const UT_StringHolder &map_name,
                                  int map_res,
                                  const UT_Vector3F &gcol,
                                  const UT_Vector3F &galbedo,
                                  fpreal turbidity,
                                  fpreal horizon_blur,
                                  fpreal solar_altitude,
                                  fpreal solar_azimuth);
    struct Light
    {
        UT_Matrix4F EnvRotate;
        UT_Vector3F Color = {1.0, 1.0, 1.0};
        int32       HasMap = 0;
    } myLight;

    UT_Vector3F     myGroundColor = { 0.0f, 0.0f, 0.0f };
    UT_Vector3F     myGroundAlbedo = { 0.0f, 0.0f, 0.0f };
    fpreal          myTurbidity = 0.0;
    fpreal          myHorizonBlur = 0.0;
    fpreal          myAltitude = 0.0;
    fpreal          myAzimuth = 0.0;

    bool            myTexDirty = true;
    bool            myIsSkyMap = false;
    UT_StringHolder myEnvMap;
    int             myEnvMapOpId = -999;
    RV_TextureRef   myEnvMapRef;
};

/// Area light. Light whose source has a funky shape.
class GR_API GR_AreaLight : public GR_Light
{
public:
    GR_AreaLight(const UT_StringHolder &name, LightType type = GR_Light::AREA);
    ~GR_AreaLight() override; // For UT_UniquePtr<> on WIN
    UT_NON_COPYABLE(GR_AreaLight);

    enum Shapes
        {
            RECTANGLE,
            ELLIPSE,
            ELLIPSOID,
            CYLINDER,
            GEOMETRY
        };

    LIGHTPARM_SM(UT_Vector3F, Pos);
    LIGHTPARM_SM(UT_Vector4F, XAxis);
    LIGHTPARM_SM(UT_Vector4F, YAxis);
    LIGHTPARM_SM(UT_Vector4F, ZAxis);
    LIGHTPARM_SM(int32, IsSingleSided);
    LIGHTPARM_SM(int32, IsReversed);
    LIGHTPARM(UT_Vector3F, Color);
    LIGHTPARM(fpreal32, DiffuseIntensity);
    LIGHTPARM(fpreal32, SpecularIntensity);
    LIGHTPARM(fpreal32, BoundingRadius);
    LIGHTPARM(int32, UseBoundingRadius);
    LIGHTPARM(int32, UseSpotlight);
    LIGHTPARM(UT_Vector2F, LeftBarn);
    LIGHTPARM(UT_Vector2F, RightBarn);
    LIGHTPARM(UT_Vector2F, TopBarn);
    LIGHTPARM(UT_Vector2F, BottomBarn);
    LIGHTPARM(fpreal32, Cutoff);
    LIGHTPARM(fpreal32, Falloff);
    LIGHTPARM(fpreal32, SpotRolloff);

    SHADOWPARM(UT_Matrix4F, ShadowTransform);
    SHADOWPARM(fpreal32, ShadowIntensity);

    unsigned setupShadowRenders(RE_RenderContext r,
                                GR_RenderMode &out_render_mode,
                                bool scene_changed,
                                unsigned shadowmap_size,
                                const GR_DistantShadowMapParms&) override;
    void startShadowRender(RE_RenderContext,
                           unsigned shadowmap_index) override;
    void finishShadowRender(RE_RenderContext) override;
    void finishShadowRenders(RE_RenderContext) override;
    bool needsShadowMap() override { return true; }
    bool hasShadowMap() override { return myShadowMap.get(); }
    void attachShadowMap(RE_RenderContext) override;
    void clearShadowMap() override;
    void setShadowMask(const UT_StringHolder &mask) override;
    bool canRayTraceShadow() const override { return true; }

    bool initBlocks(RV_Render *r, const GR_CommonDispOption &opts) override;
    RV_ShaderProgram *getShader(bool shadows, bool per_sample,
                                bool is_antialiased,
                                bool is_raytrace) override;

    void setShape(const Shapes shape) { myShape = shape; }
    Shapes getShape()                 { return myShape; }

    void setGeometryLook(GUI_DetailLook *look)     { myLook = look; }
    GUI_DetailLook* getGeometryLook() const        { return myLook; }

    UT_UniquePtr<RV_Geometry> &getGeometry() { return myGeometry; }

    void               setTransform(const UT_Matrix4F &t) { myTransform = t; }
    const UT_Matrix4F &getTransform() const { return myTransform; }

    void               setSize(fpreal w, fpreal h) { myWidth = w; myHeight = h; }
    fpreal             getWidth() const { return myWidth; }
    fpreal             getHeight() const { return myHeight; }
    
private:
    struct Light
    {
        UT_Vector3F Pos = {0.0, 0.0, 1.0};
        int32 IsSingleSided = false;
        UT_Vector4F XAxis = {1.0, 0.0, 0.0};
        UT_Vector4F YAxis = {0.0, 1.0, 0.0};
        UT_Vector4F ZAxis = {0.0, 0.0, 1.0};
        UT_Vector3F Color = {1.0, 1.0, 1.0};
        int32 IsReversed = false;
        fpreal32 DiffuseIntensity = 1.0;
        fpreal32 SpecularIntensity = 1.0;
        fpreal32 BoundingRadius = 0.0;
        int32 UseBoundingRadius = 0;
        int32 UseSpotlight = 0;
        fpreal32 Cutoff = -1.0;
        fpreal32 Falloff = -1.0;
        fpreal32 SpotRolloff = 1.0;
        UT_Vector2F LeftBarn   = { 0.0, 0.0 };
        UT_Vector2F RightBarn  = { 0.0, 0.0 };
        UT_Vector2F TopBarn    = { 0.0, 0.0 };
        UT_Vector2F BottomBarn = { 0.0, 0.0 };
    } myLight;

    struct Shadow
    {
        UT_Matrix4F ShadowTransform;
        fpreal32 ShadowBias = 0.01;
        fpreal32 ShadowIntensity = 1.0;
    } myShadow;

    UT_UniquePtr<GR_PointShadowMap> myShadowMap;
    bool                            myShadowMapDirtyFlag = true;
    Shapes                          myShape;
    GUI_DetailLook                 *myLook = nullptr;
    UT_UniquePtr<RV_Geometry>       myGeometry;
    UT_Matrix4F                     myTransform;
    fpreal                          myWidth = 1.0;
    fpreal                          myHeight = 1.0;
};
#endif