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 <UT/UT_StringHolder.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Matrix4.h>

class RV_Render;
class RV_ShaderProgram;

#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; } }


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

    LIGHTPARM(UT_Vector3F, Dir);
    LIGHTPARM(UT_Vector3F, Color);
    LIGHTPARM(int32, WorldSpace);
    LIGHTPARM(int32, UseSpecular);
    
    SHADOWPARM(UT_Matrix4F, ShadowTransform1);
    SHADOWPARM(UT_Matrix4F, ShadowTransform2);
    SHADOWPARM(UT_Matrix4F, ShadowTransform3);
    SHADOWPARM(UT_Matrix4F, ShadowTransform4);
    SHADOWPARM(fpreal32, ShadowBias);
    SHADOWPARM(fpreal32, ShadowIntensity);

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

private:
    struct Light
    {
        UT_Vector3F Dir   = {0.0, 0.0, 1.0};
        fpreal32    unused1 = 0.0;
        UT_Vector3F Color = {1.0, 1.0, 1.0};
        int32       WorldSpace = true;
        int32       UseSpecular = true;
    } myLight;
    
    struct Shadow
    {
        UT_Matrix4F ShadowTransform1;
        UT_Matrix4F ShadowTransform2;
        UT_Matrix4F ShadowTransform3;
        UT_Matrix4F ShadowTransform4;
        fpreal32 ShadowBias;
        fpreal32 ShadowIntensity;
    } myShadow;
};

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

    LIGHTPARM(UT_Matrix4F, Projection);
    LIGHTPARM(UT_Vector4F, Focus);
    LIGHTPARM(UT_Vector3F, Pos);
    LIGHTPARM(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(fpreal32, Cutoff);
    LIGHTPARM(fpreal32, Falloff);
    LIGHTPARM(fpreal32, SpotRolloff);
    LIGHTPARM(int32, HasSpot);
    LIGHTPARM(int32, HasProject);
    LIGHTPARM(int32, ProjectClamp);
    LIGHTPARM(int32, HasAttenRamp);
    
    SHADOWPARM(UT_Matrix4F, ShadowTransform);
    SHADOWPARM(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
            myProjectMapId.reset();
#endif
            myTexDirty = true;
        }
    }
    const UT_StringHolder &projectMap() const { return myProjectMap; }
    int                    projectMapOpId() const { return myProjectMapOpId; }
    
    bool initBlocks(RV_Render *r) override
    {
        if(myTexDirty)
        {
            myTexDirty = false;
#ifdef USE_VULKAN
            privBindTexture(r, myProjectMap, myProjectMapOpId, myProjectMapId,
                            "projectMap");
#endif
        }
        return privInitBlocks(r, &myLight, sizeof(Light),
                              &myShadow, sizeof(Shadow));
    }
    
    RV_ShaderProgram *getShader(bool shadows, bool per_sample) override;

private:
    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;
    RV_TextureRef   myProjectMapId;
};

/// 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) override
    {
        return privInitBlocks(r, &myLight, sizeof(Light), nullptr, 0);
    }
    
    RV_ShaderProgram *getShader(bool shadows, bool per_sample) override;

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
            myEnvMapId.reset();
#else
            myEnvMapId = 0; // to suppress unused member warning
#endif
            myTexDirty = true;
        }
    }
    const UT_StringHolder &envMap() const     { return myEnvMap; }
    int                    envMapOpId() const { return myEnvMapOpId; }
    
    bool initBlocks(RV_Render *r) override
    {
        if(myTexDirty)
        {
            myTexDirty = false;
#ifdef USE_VULKAN
            RV_TextureParms parms;
            parms.MipMap = true;
            privBindTexture(r, myEnvMap, myEnvMapOpId, myEnvMapId, "envMap",
                            &parms, true);
#endif
        }
        return privInitBlocks(r, &myLight, sizeof(Light), nullptr, 0);
    }
    
    RV_ShaderProgram *getShader(bool shadows, bool per_sample) override;

private:
    struct Light
    {
        UT_Matrix4F EnvRotate;
        UT_Vector3F Color = {1.0, 1.0, 1.0};
        int32       HasMap = 0;
    } myLight;
   
    bool            myTexDirty = true;
    UT_StringHolder myEnvMap;
    int             myEnvMapOpId = -999;
    RV_TextureRef   myEnvMapId;
};

#endif