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

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

#include <UT/UT_IntrusivePtr.h>
#include <UT/UT_Map.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_OptionEntry.h>
#include <UT/UT_RWLock.h>
#include <UT/UT_Set.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_VectorTypes.h>
#include <UT/UT_Vector2.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Debug.h>
#include <DEP/DEP_MicroNode.h>

#ifdef USE_VULKAN
#include <RV/RV_ShaderProgram.h>
#include <RV/RV_TextureCache.h>
#endif

class UT_Options;
class RV_ShaderProgramBase;
class RV_Render;
class RV_ShaderProgram;
class RV_ShaderCompute;
class GR_MaterialParms;
class GR_DisplayOption;

class GR_API GR_Material : public GR_SceneItem
{
public:
    // Alpha blend/cutout modes, meant to mirror the enum in RE_Material.h
    // also defined in glsl/block/VK/glH_Material.blk
    enum AlphaMode
    {
        ALPHA_BLEND = 0, // normal alpha blending C*A + Cbg*(1-A)
        ALPHA_CUTOUT,    // (A >= cutoff) ? C : 0
        ALPHA_IGNORE,    // C
    };
    enum MaterialType
    {
        SIMPLE_SURFACE,
        UNLIT_SURFACE,
        FILM_SURFACE,
        HAIR_CURVE,
        HEIGHTFIELD_SURFACE,
        MATX_SURFACE,
        MATCAP_SURFACE
    };

    static GR_MaterialPtr create(MaterialType type,
                               const UT_StringHolder &name);
    MaterialType type() const { return myType; }
    
    // Some materials may be defined by nodes; this is the ID of that node.
    int         getNodeID() const { return myNodeID; }
    void        setNodeID(int id) { myNodeID = id; }
    UT_StringHolder getNodePath() const;  
    
    void        setTimeDependent(bool timedep, fpreal t = 0.0);
    void        setOPTimeDependent(bool timedep, fpreal t = 0.0);
    bool        isTimeDependent() const { return myTimeDep; }
    bool        isOPTimeDependent() const { return myOPTimeDep; }
    fpreal      getCurrentTime() const  { return myTime; }


    bool        isDirty(fpreal time)
                {
                    if(isTextured())
                    {
                        exint cache_version = 0;
#ifdef USE_VULKAN
                        cache_version = RV_TextureCache::cacheRefresh();
#endif
                        if(myTexCacheVersion != cache_version)
                            return true;
                    }
                    if(myDirtyFlag || myDepNode.isDirty())
                        return true;
                    if(myTimeDep && !SYSisEqual(time, myTime))
                        return true;
                    return false;
                }
    void        dirty(bool dirty = true)
                {
                    myDirtyFlag = dirty;
                    if(!dirty)
                    {
                        myDepNode.update(myTime);
#ifdef USE_VULKAN
                        myTexCacheVersion = RV_TextureCache::cacheRefresh();
#endif
                    }
                }

    virtual     void dirtyTextures() {}

    // Returns true if this material has a texture map (diffuse, bump, etc).
    bool        isTextured() const        { return myIsTextured; }
    void        setTextured(bool has_tex) { myIsTextured = has_tex; }

    bool        hasUDIM() const           { return myHasUDIM; }
    void        setHasUDIM(bool has_udim) { myHasUDIM = has_udim; }

    bool        hasDisplacement() const           { return myHasDisplacement; }
    void        setHasDisplacement(bool has_disp) {myHasDisplacement=has_disp;}

    // Requires UVs outside of texturing
    bool        needsUVs() const      { return myNeedsUVs; }
    void        setNeedsUVs(bool uvs) { myNeedsUVs = uvs; }

    // Requires tangents for tangent-space generation
    bool        needsTangents() const       { return myNeedsTangents; }
    void        setNeedsTangents(bool tan)  { myNeedsTangents = tan; }

    bool        isTransparent() const        { return myIsTransparent; }
    void        setTransparent(bool has_tex) { myIsTransparent = has_tex; }

    bool        texturesLoaded() const       { return myTexturesLoaded; }
    void        setTexturesLoaded(bool loaded) { myTexturesLoaded = loaded; }

    bool        bindWithoutUpdate(RV_Render *r, RV_ShaderProgramBase *shader,
                     const GR_DisplayOption *opts, bool for_curve = false)
                {
                    return bindSets(r, shader, for_curve);
                }

    bool        bind(RV_Render *r, RV_ShaderProgramBase *shader,
                     const GR_DisplayOption *opts, bool for_curve = false)
                {
                    bool created = false;
                    return (initMaterialSetForRender(r, shader, created) &&
                            initBlocks(r, opts) &&
                            bindSets(r, shader, for_curve));
                }
    virtual bool bindForCompute(RV_Render *r,
                                RV_ShaderProgramBase *shader,
                                const GR_DisplayOption &opts);

    virtual void update(const GR_MaterialParms &options) = 0;
    
    virtual bool initMaterialSetForRender(RV_Render *r,
                                          RV_ShaderProgramBase *shader,
                                          bool &created)=0;
    virtual bool initBlocks(RV_Render *r, const GR_DisplayOption *opts) = 0;
    bool         checkCompatible(RV_Render* r, RV_ShaderProgramBase* sh, bool for_curve = false) const;
    bool         bindSets(RV_Render *r, RV_ShaderProgramBase *shader, bool for_curve);

    DEP_MicroNode &dependencies() { return myDepNode; }

    virtual RV_ShaderProgram *getSurfaceShader() const { return nullptr; }
    virtual RV_ShaderProgram *getCurveShader() const { return nullptr; }
    virtual RV_ShaderCompute *getDisplaceShader() const { return nullptr; }

    bool opDependenciesDirty() const { return myOpDepsDirty; }
    void clearOpDependenciesDirty() { myOpDepsDirty = false; }
    const UT_Set<int> opDependencies() const { return myOpNodes; }

    // Attribute overrides (mapping an attribute to a shader input)
    void        setOverrides(const UT_Options *overrides);
    const UT_Options *getOverrides() const { return myOverrides.get(); }
    // Attribute fallback (value to use if attribute does not exist)
    void        setFallbacks(const UT_Options *attrib_fallbacks);
    const UT_Options *getFallbacks() const { return myFallbacks.get(); }

    enum InputType
    {
        IN_INT,
        IN_FLOAT,
        IN_VEC2,
        IN_VEC3,
        IN_VEC4
    };
    void        setExtraInputs(const UT_StringMap<InputType> &extra_inputs)
                    { myExtraInputs = extra_inputs; }
    const UT_StringMap<InputType> &extraInputs() const { return myExtraInputs; }

    static exint getUniqueMaterialID();
    
protected:
    GR_Material(const UT_StringHolder &name,
                MaterialType type);
    ~GR_Material() override;
    UT_NON_COPYABLE(GR_Material);

    void        clearOpIDs() { myOpNodes.clear(); myOpDepsDirty = true; }
    void        addOpID(int id);

    bool        timeChangeCheck() const;

#ifdef USE_VULKAN
    UT_UniquePtr<RV_ShaderVariableSet>  myMaterialSet;
    UT_UniquePtr<RV_ShaderVariableSet>  myTexMaterialSet;
    UT_UniquePtr<RV_ShaderVariableSet>  myTexCurveMaterialSet;
    
    void        initTextureParms(RV_TextureParms &parms,
                                 const GR_DisplayOption *opts,
                                 RV_ImageDim tex_type);

#endif
    
    bool        myDirtyFlag;
    bool        myBlockDirtyFlag;

private:

    UT_Set<int>     myOpNodes;
    DEP_MicroNode   myDepNode;
    MaterialType    myType;
    int             myNodeID = -999;
    exint           myTexCacheVersion = 0;
    unsigned        myTimeDep : 1,
                    myOPTimeDep : 1,
                    myIsTextured : 1,
                    myNeedsUVs : 1,
                    myHasUDIM : 1,
                    myHasDisplacement : 1,
                    myIsTransparent : 1,
                    myNeedsTangents : 1,
                    myTexturesLoaded : 1,
                    myOpDepsDirty : 1;
    fpreal          myTime = 0.0;
    UT_UniquePtr<UT_Options> myOverrides;
    UT_UniquePtr<UT_Options> myFallbacks;
    UT_StringMap<InputType> myExtraInputs;
};

static inline void intrusive_ptr_add_ref(GR_Material *m) { m->incref(); }
static inline void intrusive_ptr_release(GR_Material *m) { m->decref(); }


class GR_API GR_MaterialAtlas : public UT_Map<int,GR_MaterialPtr>
{
public:
    // Default material for unassigned prims.
    const GR_MaterialPtr &getDefaultMaterial() const
                { return myDefault; }

    // Factory default material if materials are disabled.
    const GR_MaterialPtr &getFactoryMaterial() const
                { return myFactory; }

    // True if any of the materials in the atlas are dirty.
    bool        isDirty(fpreal time) const;

    // Fetch a material by its ID.
    GR_MaterialPtr get(int material_id) const
                {
                    if(myAltAtlas && material_id < 0)
                        return myAltAtlas->get(-material_id);
                    if(material_id == 0)
                        return myDefault ? myDefault : myFactory;
                    const_iterator entry =  find(material_id);
                    if(entry != end())
                        return entry->second;
                    return nullptr;
                }
    // Fetch a material by ID, and if it doesn't exist, check the draw parms
    // default material, then fallback to the default or factory if there is
    // no draw parms default.
    GR_MaterialPtr get(int material_id, const GR_DrawParms &dp) const
                {
                    if(myAltAtlas && material_id < 0)
                        return myAltAtlas->get(-material_id);
                    
                    if(material_id == 0 && dp.vk_default_mat_id != 0)
                        material_id = dp.vk_default_mat_id;

                    if(material_id == 0)
                        return myDefault ? myDefault : myFactory;
                    
                    const_iterator entry =  find(material_id);
                    if(entry != end())
                        return entry->second;
                    return nullptr;
                }

    // Add a new material to the atlas
    void   add(const GR_MaterialPtr &material)
                { (*this)[ material->id() ] = material; }

    // Set the default material, which will be used if no other material
    // assignments are present.
    void   setDefaultMaterial(const GR_MaterialPtr &material,bool add_list=true)
            { myDefault = material; if(add_list && material) add(material); }

    // Sets the factory default material, which is used when all materials
    // are turned off (as the default material may be the object material).
    void   setFactoryMaterial(const GR_MaterialPtr &material,bool add_list=true)
            { myFactory = material; if(add_list && material) add(material); }

    // Provide another material atlas to use for material lookups. This is used
    // for LOP materials when rendering SOPs.
    void   setAlternateMaterials(GR_MaterialAtlas *atlas)
            { myAltAtlas = atlas; }
    GR_MaterialAtlas *alternateMaterials() { return myAltAtlas; }
    const GR_MaterialAtlas *alternateMaterials() const { return myAltAtlas; }

    bool   hasMaterial(int material_id) const
            {
                const_iterator entry =  find(material_id);
                return (entry != end());
            }

private:
    GR_MaterialPtr  myDefault;
    GR_MaterialPtr  myFactory;

    GR_MaterialAtlas *myAltAtlas = nullptr;
};

/// This is a fast, non-string access and cut-down version of UT_Options.
class GR_API GR_MaterialParms : public UT_NonCopyable
{
public:
     GR_MaterialParms() {}
    
    void setParmI(exint ptype, int value);
    void setParm(exint ptype, fpreal value);
    void setParm(exint ptype, const UT_Vector2 &value);
    void setParm(exint ptype, const UT_Vector3 &value);
    void setParm(exint ptype, const UT_Vector4 &value);
    void setParm(exint ptype, const UT_Matrix4 &value);
    void setParm(exint ptype, const UT_StringHolder &value);

    bool       hasParm(exint ptype) const;

    int        getParmI(exint ptype, int defval = 0) const;
    fpreal     getParmF(exint ptype, fpreal defval = 0.0) const;
    UT_Vector2 getParmV2(exint ptype, UT_Vector2 defval = {0,0}) const;
    UT_Vector3 getParmV3(exint ptype, UT_Vector3 defval = {0,0,0}) const;
    UT_Vector4 getParmV4(exint ptype, UT_Vector4 defval = {0,0,0,0}) const;
    UT_Matrix4 getParmM4(exint ptype,
                         UT_Matrix4 defval=UT_Matrix4::getIdentityMatrix()) const;
    UT_StringHolder getParmS(exint ptype, UT_StringHolder = UT_StringHolder()) const;

    void        dump();
    
private:
    UT_Array<UT_OptionEntryPtr> myParms;
};

// Cache for auto-generated shaders (MatX)
class GR_API GR_ShaderCache
{
public:
     GR_ShaderCache() {}
    ~GR_ShaderCache();
    UT_NON_COPYABLE(GR_ShaderCache);
    
    static void initCache();
    static void destroyCache();
    static void clearCache();
    
    // return the ID assoicated with this name (0 if it doesn't exist).
    static exint getShaderID(const UT_StringHolder &name);
    static exint getComputeID(const UT_StringHolder &name);

    // Return the shader program assoicated with this id (nullptr if not cached)
    static RV_ShaderProgram *getShader(exint id);
    static RV_ShaderCompute *getComputeShader(exint id);

    // Create a cache entry to store a shader with cacheShader().
    static exint createEntryID(const UT_StringHolder &name);
    static exint createComputeEntryID(const UT_StringHolder &name);

    // Cache the shader by ID, handling over ownership to the cache.
    static void  cacheShader(exint entry, const GR_Material &for_material,
                             UT_UniquePtr<RV_ShaderProgram> shader);
    static void  cacheComputeShader(exint entry, const GR_Material &for_material,
                                    UT_UniquePtr<RV_ShaderCompute> shader);

    // Add a reference to a cached shader. It must exist in the cache.
    static void  addShaderRef(exint id, const GR_Material &material);
    static void  addComputeRef(exint id, const GR_Material &material);
    
    // Remove the shader from the cache with the given name
    static bool removeShader(const UT_StringHolder &name,
                             const GR_Material &for_material);
    static bool removeComputeShader(const UT_StringHolder &name,
                                    const GR_Material &for_material);
    
private:
    UT_StringMap<exint>   myNameMap;
    UT_StringMap<exint>   myComputeNameMap;
#ifdef USE_VULKAN
    UT_Map<exint,
           std::pair<UT_Set<int>,UT_UniquePtr<RV_ShaderProgram>> > myShaders;
    UT_Map<exint,
       std::pair<UT_Set<int>,UT_UniquePtr<RV_ShaderCompute>> > myComputeShaders;
#endif
    UT_RWLock             myShaderLock;
    exint                 myCurrentID = 1;
};

#endif