light2.h

Go to the documentation of this file.

#line 1 "D:/Jenkins/workspace/EMS/ECG/ufe/full/ufe-full-python3.11-windows/ufe/include/light2.h"
#ifndef UFE_LIGHT2_H
#define UFE_LIGHT2_H
// ===========================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
#include "common/ufeExport.h"
#include "sceneItem.h"
#include "observer.h"
#include "baseUndoableCommands.h"
#include "types.h"
#include "value.h"
#include "lightNotification.h"
 
#include <memory>
#include <array>
#include <vector>
 
UFE_NS_DEF
{
 
class UndoableCommand;
 
class UFE_SDK_DECL LightInterface
{
    public:
    typedef std::shared_ptr<LightInterface> Ptr;
    LightInterface();
    LightInterface(const LightInterface&) = default;
    virtual ~LightInterface();
};
 
class UFE_SDK_DECL AreaLightInterface : public LightInterface
{
public:
    typedef std::shared_ptr<AreaLightInterface> Ptr;
    AreaLightInterface();
    AreaLightInterface(const AreaLightInterface&) = default;
    virtual ~AreaLightInterface() override;
 
    using NormalizeUndoableCommand = SetBoolUndoableCommand;
    using WidthUndoableCommand = SetFloatUndoableCommand;
    using HeightUndoableCommand = SetFloatUndoableCommand;
 
    virtual NormalizeUndoableCommand::Ptr normalizeCmd(bool nl) = 0;
 
    virtual void normalize(bool nl) {
        if (auto cmd = normalizeCmd(nl)) {
            cmd->execute();
        }
    }
 
    virtual bool normalize() const = 0;
 
    virtual WidthUndoableCommand::Ptr widthCmd(float w) = 0;
 
    virtual void width(float w) {
        if (auto cmd = widthCmd(w)) {
            cmd->execute();
        }
    }
 
    virtual float width() const = 0;
 
    virtual HeightUndoableCommand::Ptr heightCmd(float h) = 0;
 
    virtual void height(float h) {
        if (auto cmd = heightCmd(h)) {
            cmd->execute();
        }
    }
 
    virtual float height() const = 0;
};
 
class UFE_SDK_DECL Light2 : public std::enable_shared_from_this<Light2>
{
public:
    typedef std::shared_ptr<Light2> Ptr;
 
    enum Type
    {
        Invalid,
        Area,
    };
 
    using IntensityUndoableCommand = SetFloatUndoableCommand;
    using ColorUndoableCommand = SetColor3fUndoableCommand;
    using ShadowEnableUndoableCommand = SetBoolUndoableCommand;
    using ShadowColorUndoableCommand = SetColor3fUndoableCommand;
    using DiffuseUndoableCommand = SetFloatUndoableCommand;
    using SpecularUndoableCommand = SetFloatUndoableCommand;
 
    static Ptr light(const SceneItem::Ptr& item);
 
    static bool addObserver(
        const SceneItem::Ptr& item, const Observer::Ptr& obs);
    static bool removeObserver(
        const SceneItem::Ptr& item, const Observer::Ptr& obs);
 
    static std::size_t nbObservers(const SceneItem::Ptr& item);
 
    static bool hasObserver(
        const SceneItem::Ptr& item, const Observer::Ptr& obs);
 
    static bool hasObservers(const Path& path);
 
    static bool hasObservers(Rtid runTimeId);
 
    static void notify(const Ufe::LightChanged& notification);
 
    // --------------------------------------------------------------------- //
     // --------------------------------------------------------------------- //
 
    virtual Value getMetadata(const std::string& key) const = 0;
 
    virtual bool setMetadata(const std::string& key, const Value& value) = 0;
 
    virtual UndoableCommand::Ptr setMetadataCmd(const std::string& key, const Value& value);
 
    virtual bool clearMetadata(const std::string& key) = 0;
 
    virtual UndoableCommand::Ptr clearMetadataCmd(const std::string& key);
 
    virtual bool hasMetadata(const std::string& key) const = 0;
 
    // --------------------------------------------------------------------- //
    // --------------------------------------------------------------------- //
 
    Light2();
    Light2(const Light2&) = default;
    virtual ~Light2();
 
    virtual const Path& path() const = 0;
 
    virtual SceneItem::Ptr sceneItem() const = 0;
 
    virtual Type type() const = 0;
 
    std::vector<LightInterface::Ptr> interfaces;
 
    /*************************************************
        Light intensity attribute.
        Valid for the following light types: [all]
    *************************************************/
 
    virtual IntensityUndoableCommand::Ptr intensityCmd(float li) = 0;
 
    virtual void intensity(float li) {
        if (auto cmd = intensityCmd(li)) {
            cmd->execute();
        }
    }
 
    virtual float intensity() const = 0;
 
    /*************************************************
        Light color attribute, defined in energy-linear terms
        Valid for the following light types: [all]
    *************************************************/
 
    virtual ColorUndoableCommand::Ptr colorCmd(float r, float g, float b) = 0;
 
    virtual void color(float r, float g, float b) {
        if (auto cmd = colorCmd(r, g, b)) {
            cmd->execute();
        }
    }
 
    virtual Color3f color() const = 0;
 
    /*************************************************
        Light shadow enable attribute.
        Valid for the following light types: [all]
    *************************************************/
 
    virtual ShadowEnableUndoableCommand::Ptr shadowEnableCmd(bool se) = 0;
 
    virtual void shadowEnable(bool se) {
        if (auto cmd = shadowEnableCmd(se)) {
            cmd->execute();
        }
    }
 
    virtual bool shadowEnable() const = 0;
 
    /*************************************************
        Shadow color attribute.
        Valid for the following light types: [all]
    *************************************************/
 
    virtual ShadowColorUndoableCommand::Ptr shadowColorCmd(float r, float g, float b) = 0;
 
    virtual void shadowColor(float r, float g, float b) {
        if (auto cmd = shadowColorCmd(r, g, b)) {
            cmd->execute();
        }
    }
 
    virtual Color3f shadowColor() const = 0;
 
    /*************************************************
        Light diffuse attribute, a multiplier for the effect
        of this light on the diffuse response of materials.
        Valid for the following light types: [all]
    *************************************************/
 
    virtual DiffuseUndoableCommand::Ptr diffuseCmd(float ld) = 0;
 
    virtual void diffuse(float ld) {
        if (auto cmd = diffuseCmd(ld)) {
            cmd->execute();
        }
    }
 
    virtual float diffuse() const = 0;
 
    /*************************************************
        Light specular attribute, a multiplier for the effect
        of this light on the specular response of materials.
        Valid for the following light types: [all]
    *************************************************/
 
    virtual SpecularUndoableCommand::Ptr specularCmd(float ls) = 0;
 
    virtual void specular(float ls) {
        if (auto cmd = specularCmd(ls)) {
            cmd->execute();
        }
    }
 
    virtual float specular() const = 0;
};
}
 
#endif /* UFE_LIGHT2_H */