light.h

Go to the documentation of this file.

#line 1 "S:/jenkins/workspace/ECP/ufe/ufe-full-python3.10-windows/ufe/include/light.h"
#ifndef _light
#define _light
// ===========================================================================
// Copyright 2022 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 <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
        };

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

        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;

        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();
    
    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;
    };
}

#endif /* _light */