light.h

Go to the documentation of this file.

#line 1 "D:/Jenkins/workspace/EMS/ECG/ufe/full/ufe-full-python3.13-windows/ufe/include/light.h"
#ifndef UFE_LIGHT_H
#define UFE_LIGHT_H
 
// ===========================================================================
// Copyright 2025 Autodesk, Inc. All rights reserved.
//
// The use of this software is subject to the Autodesk Terms of Use or other
// license agreement provided at the time of installation or download, or
// which otherwise accompanies this software.
// ===========================================================================
 
#include "common/ufeExport.h"
#include "sceneItem.h"
#include "observer.h"
#include "baseUndoableCommands.h"
#include "types.h"
 
#include <memory>
#include <array>
 
UFE_NS_DEF
{
 
 
    class UFE_SDK_DECL Light
    {
    public:
        typedef std::shared_ptr<Light> Ptr;
 
        enum Type
        {
            Invalid,
            Directional,
            Point,
            Spot,
            Area,
            Sphere,
            Cylinder,
            Disk,
            Dome
        };
 
        struct SphereProps
        {
            float radius = 0;
            bool asPoint = true;
        };
 
        struct ConeProps
        {
            // Higher focus values pull light towards the center and narrow the spread
            float focus = 0;
            // Angular limit off the primary axis to restrict the light spread
            float angle = 40;
            // Controls the cutoff softness for cone angle
            float softness = 0;
        };
 
        struct VolumeProps
        {
            float radius = 0;
            float length = 0;
        };
 
        using IntensityUndoableCommand = SetFloatUndoableCommand;
        using ColorUndoableCommand = SetColor3fUndoableCommand;
        using ShadowEnableUndoableCommand = SetBoolUndoableCommand;
        using ShadowColorUndoableCommand = SetColor3fUndoableCommand;
        using DiffuseUndoableCommand = SetFloatUndoableCommand;
        using SpecularUndoableCommand = SetFloatUndoableCommand;
        using AngleUndoableCommand = SetFloatUndoableCommand;
        using SpherePropsUndoableCommand = SetValueUndoableCommand<const SphereProps &>;
        using ConePropsUndoableCommand = SetValueUndoableCommand<const ConeProps &>;
        using NormalizeUndoableCommand = SetBoolUndoableCommand;
        using VolumePropsUndoableCommand = SetValueUndoableCommand<const VolumeProps&>;
 
        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 Path &path);
 
        Light();
        Light(const Light &) = default;
        virtual ~Light();
 
        virtual const Path &path() const = 0;
 
        virtual SceneItem::Ptr sceneItem() const = 0;
 
        virtual Type type() const = 0;
 
        /*************************************************
            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;
 
        /*************************************************
            Directional interface.
            Valid for the following light types: [Directional]
        *************************************************/
 
        class UFE_SDK_DECL DirectionalInterface
        {
        public:
            virtual ~DirectionalInterface();
 
            virtual AngleUndoableCommand::Ptr angleCmd(float la) = 0;
 
            virtual void angle(float la) {
                if (auto cmd = angleCmd(la)) {
                    cmd->execute();
                }
            }
 
            virtual float angle() const = 0;
        };
 
        std::shared_ptr<DirectionalInterface> directionalInterface();
 
        /*************************************************
            Sphere interface.
            Valid for the following light types: [Point, Spot]
        *************************************************/
 
        class UFE_SDK_DECL SphereInterface
        {
        public:
            virtual ~SphereInterface();
 
            virtual SpherePropsUndoableCommand::Ptr spherePropsCmd(float radius, bool asPoint) = 0;
 
            virtual void sphereProps(float radius, bool asPoint) {
                if (auto cmd = spherePropsCmd(radius, asPoint)) {
                    cmd->execute();
                }
            }
 
            virtual SphereProps sphereProps() const = 0;
        };
 
        std::shared_ptr<SphereInterface> sphereInterface();
 
        /*************************************************
            Cone interface.
            Valid for the following light types: [Spot]
        *************************************************/
 
        class UFE_SDK_DECL ConeInterface
        {
        public:
            virtual ~ConeInterface();
 
            virtual ConePropsUndoableCommand::Ptr conePropsCmd(float focus, float angle, float softness) = 0;
 
            virtual void coneProps(float focus, float angle, float softness) {
                if (auto cmd = conePropsCmd(focus, angle, softness)) {
                    cmd->execute();
                }
            }
 
            virtual ConeProps coneProps() const = 0;
        };
 
        std::shared_ptr<ConeInterface> coneInterface();
 
        /*************************************************
            Area interface.
            Valid for the following light types: [Area]
        *************************************************/
 
        class UFE_SDK_DECL AreaInterface
        {
        public:
            virtual ~AreaInterface();
 
 
            virtual NormalizeUndoableCommand::Ptr normalizeCmd(bool nl) = 0;
 
            virtual void normalize(bool nl) {
                if (auto cmd = normalizeCmd(nl)) {
                    cmd->execute();
                }
            }
 
            virtual bool normalize() const = 0;
        };
 
        std::shared_ptr<AreaInterface> areaInterface();
 
        class UFE_SDK_DECL CylinderInterface
        {
        public:
            virtual ~CylinderInterface();
 
            virtual VolumePropsUndoableCommand::Ptr volumePropsCmd(float radius, float length) = 0;
 
            virtual void volumeProps(float radius, float length) {
                if (auto cmd = volumePropsCmd(radius, length)) {
                    cmd->execute();
                }
            }
 
            virtual VolumeProps volumeProps() const = 0;
        };
 
        std::shared_ptr<CylinderInterface> cylinderInterface();
 
        /*************************************************
            Disk interface.
            Valid for the following light types: [Disk]
        *************************************************/
 
        class UFE_SDK_DECL DiskInterface
        {
        public:
            virtual ~DiskInterface();
 
            virtual VolumePropsUndoableCommand::Ptr volumePropsCmd(float radius) = 0;
 
            virtual void volumeProps(float radius) {
                if (auto cmd = volumePropsCmd(radius)) {
                    cmd->execute();
                }
            }
 
            virtual VolumeProps volumeProps() const = 0;
        };
 
        std::shared_ptr<DiskInterface> diskInterface();
 
        /*************************************************
            Dome interface.
            Valid for the following light types: [Dome]
        *************************************************/
 
        class UFE_SDK_DECL DomeInterface
        {
        public:
            virtual ~DomeInterface();
 
            virtual VolumePropsUndoableCommand::Ptr volumePropsCmd(float radius) = 0;
 
            virtual void volumeProps(float radius) {
                if (auto cmd = volumePropsCmd(radius)) {
                    cmd->execute();
                }
            }
 
            virtual VolumeProps volumeProps() const = 0;
        };
 
        std::shared_ptr<DomeInterface> domeInterface();
    
    protected:
        virtual std::shared_ptr<DirectionalInterface> directionalInterfaceImpl() = 0;
        virtual std::shared_ptr<SphereInterface> sphereInterfaceImpl() = 0;
        virtual std::shared_ptr<ConeInterface> coneInterfaceImpl() = 0;
        virtual std::shared_ptr<AreaInterface> areaInterfaceImpl() = 0;
        virtual std::shared_ptr<CylinderInterface> cylinderInterfaceImpl() = 0;
        virtual std::shared_ptr<DiskInterface> diskInterfaceImpl() = 0;
        virtual std::shared_ptr<DomeInterface> domeInterfaceImpl() = 0;
    };
}
 
#endif /* UFE_LIGHT_H */