LightHandler.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_LIGHTHANDLER_H
#define MATERIALX_LIGHTHANDLER_H

 
#include <MaterialXRender/Export.h>
#include <MaterialXRender/Image.h>
#include <MaterialXRender/Util.h>
 
#include <MaterialXCore/Document.h>
 
MATERIALX_NAMESPACE_BEGIN
 
extern MX_RENDER_API const int DEFAULT_ENV_SAMPLE_COUNT;
 
class GenContext;

using LightHandlerPtr = std::shared_ptr<class LightHandler>;

using LightIdMap = std::unordered_map<string, unsigned int>;

class MX_RENDER_API LightHandler
{
  public:
    LightHandler() :
        _lightTransform(Matrix44::IDENTITY),
        _directLighting(true),
        _indirectLighting(true),
        _usePrefilteredMap(false),
        _envLightIntensity(1.0f),
        _envSampleCount(DEFAULT_ENV_SAMPLE_COUNT),
        _refractionTwoSided(false)
    {
    }
    virtual ~LightHandler() { }

    static LightHandlerPtr create() { return std::make_shared<LightHandler>(); }


    void setLightTransform(const Matrix44& mat)
    {
        _lightTransform = mat;
    }

    Matrix44 getLightTransform() const
    {
        return _lightTransform;
    }

    void setDirectLighting(bool enable)
    {
        _directLighting = enable;
    }

    bool getDirectLighting() const
    {
        return _directLighting;
    }

    void setIndirectLighting(bool enable)
    {
        _indirectLighting = enable;
    }

    bool getIndirectLighting() const
    {
        return _indirectLighting;
    }


    void setEnvRadianceMap(ImagePtr map)
    {
        _envRadianceMap = map;
    }

    ImagePtr getEnvRadianceMap() const
    {
        return _envRadianceMap;
    }

    void setEnvPrefilteredMap(ImagePtr map)
    {
        _envPrefilteredMap = map;
    }

    ImagePtr getEnvPrefilteredMap() const
    {
        return _envPrefilteredMap;
    }

    void setUsePrefilteredMap(bool val)
    {
        _usePrefilteredMap = val;
    }

    bool getUsePrefilteredMap()
    {
        return _usePrefilteredMap;
    }

    void setEnvIrradianceMap(ImagePtr map)
    {
        _envIrradianceMap = map;
    }

    ImagePtr getEnvIrradianceMap() const
    {
        return _envIrradianceMap;
    }

    void setEnvSampleCount(int count)
    {
        _envSampleCount = count;
    }

    int getEnvSampleCount() const
    {
        return _envSampleCount;
    }

    void setEnvLightIntensity(const float intensity)
    {
        _envLightIntensity = intensity;
    }

    float getEnvLightIntensity()
    {
        return _envLightIntensity;
    }

    void setRefractionTwoSided(bool enable)
    {
        _refractionTwoSided = enable;
    }

    int getRefractionTwoSided() const
    {
        return _refractionTwoSided;
    }


    void setAlbedoTable(ImagePtr table)
    {
        _albedoTable = table;
    }

    ImagePtr getAlbedoTable() const
    {
        return _albedoTable;
    }


    void addLightSource(NodePtr node);

    void setLightSources(const vector<NodePtr>& lights)
    {
        _lightSources = lights;
    }

    const vector<NodePtr>& getLightSources() const
    {
        return _lightSources;
    }

    NodePtr getFirstLightOfCategory(const string& category)
    {
        for (NodePtr light : _lightSources)
        {
            if (light->getCategory() == category)
            {
                return light;
            }
        }
        return nullptr;
    }


    const std::unordered_map<string, unsigned int>& getLightIdMap() const
    {
        return _lightIdMap;
    }

    LightIdMap computeLightIdMap(const vector<NodePtr>& nodes);

    void findLights(DocumentPtr doc, vector<NodePtr>& lights);

    void registerLights(DocumentPtr doc, const vector<NodePtr>& lights, GenContext& context);

 
  protected:
    Matrix44 _lightTransform;
    bool _directLighting;
    bool _indirectLighting;
    bool _usePrefilteredMap;
 
    ImagePtr _envRadianceMap;
    ImagePtr _envPrefilteredMap;
    ImagePtr _envIrradianceMap;
    float _envLightIntensity;
    int _envSampleCount;
 
    bool _refractionTwoSided;
 
    ImagePtr _albedoTable;
 
    vector<NodePtr> _lightSources;
    std::unordered_map<string, unsigned int> _lightIdMap;
};
 
MATERIALX_NAMESPACE_END
 
#endif