Effect.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Design
File: Effect
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/DesignObject.h>
#include <NDEVR/BaseValues.h>
#include <NDEVR/TimeSpan.h>
namespace NDEVR
{
    class DesignObjectLookup;

    enum class NDPE : uint01
    {
          effect_type             
        , is_active               
        , start_time              
        , end_time                
        , frequency               
        , extra_size              
        , extra_transform         
        , destroy_when_finished   
        , target_property         
        , target_value_a          
        , target_value_b          
    };
    template<> struct PropertySpec<NDPE::is_active> { using type = bool; };             
    template<> struct PropertySpec<NDPE::start_time> { using type = Time; };             
    template<> struct PropertySpec<NDPE::end_time> { using type = Time; };               
    template<> struct PropertySpec<NDPE::frequency> { using type = fltp08; };             
    template<> struct PropertySpec<NDPE::destroy_when_finished> { using type = bool; };   
    template<> struct PropertySpec<NDPE::extra_transform> { using type = Matrix<fltp08>; }; 
    template<> struct PropertySpec<NDPE::target_value_a> { using type = StringView; };    
    template<> struct PropertySpec<NDPE::target_value_b> { using type = StringView; };    

    template<>
    class PropertyInterface<NDPE>
    {
    public:
        template<class t_value_type>
        static void Set(DesignInfo* object, NDPE property, const t_value_type& value)
        {
            object->m_base->effect_properties[eint01(property)]->set(object->m_design_index, value);
        }

        template<NDPE t_property, class t_value_type>
        static void Set(DesignInfo* object, const t_value_type& value)
        {
            object->m_base->effect_properties[eint01(t_property)]->set(object->m_design_index, value);
        }

        template<class t_value_type>
        static decltype(auto) Get(const DesignInfo* object, NDPE property)
        {
            return object->m_base->effect_properties[eint01(property)]->get<t_value_type>(object->m_design_index);
        }

        template<NDPE t_property, class t_value_type>
        static decltype(auto) Get(const DesignInfo* object)
        {
            return object->m_base->effect_properties[eint01(t_property)]->get<t_value_type>(object->m_design_index);
        }

        template<NDPE t_property>
        static decltype(auto) Get(const DesignInfo* object)
        {
            return object->m_base->effect_properties[eint01(t_property)]->get<typename PropertySpec<t_property>::type>(object->m_design_index);
        }

        static bool IsSame(const DesignInfo* object, NDPE property, const StringView& value)
        {
            return object->m_base->effect_properties[eint01(property)]->isSame(object->m_design_index, value);
        }
    };

    class NDEVR_DESIGN_API Effect : public DesignObject
    {
    public:
        enum EffectType : uint01
        {
              e_none                  
            , e_placeholder            
            , e_3D_fade_in            
            , e_3D_fade_out           
            , e_draw_bounding_box     
            , e_station               
            , e_set_transform         
            , e_scan                  
            , e_light                 
            , e_design_property       
            , e_model_property        
            , e_material_property     
            , e_geometry_property     
            , e_material_uv_color     
            , e_location_operations   
            , e_azimuth_operations    
            , e_tile_model_to_object  
            , e_motion                
        };
    public:
        Effect();
        Effect(uint04 index, DesignObjectBase* property_table);
        Effect(DesignObjectBase* property_table);
        explicit Effect(const DesignObject& object);
        void cleanup();
        void setupAsLight(fltp04 intensity = 1.0);
        void setupAsMotion(const Vector<3, fltp08>& speed, const Vector<3, fltp08>& acceleration, const Vector<3, Angle<fltp08>>& rotation_speed, const Vector<3, Angle<fltp08>>& rotation_acc);
        void setupAsBlinking(fltp04 frequency);
        void setupAsBoundingBox(const Model& bounds);
        void setupAsBoundingBox(const Model& bounds, const Model& target);
        void setupAsBoundingBox(const Model& bounds, const ModelBuffer& targets);
        void setBoundsRotation(bool bounds_can_rotate);
        bool getBoundsRotation() const;
#if NDEVR_STATION_MODEL
        void setupAsStation(const Model& station);
#endif
        void copyFrom(const Effect& effect);
        void setupAsModelTile(const Model& model_tile);
#if NDEVR_CALIBRATION
        void setupAsCalibration(const Model& calibration);
#endif
#if NDEVR_SCAN
        void setupAsScan(const Model& scan);
#endif
        void setupAsLocationOperations(const Model& reference);
        void setupAsTransformAnimation(const Model& target, const Matrix<fltp08>& transform, const TimeSpan& span = TimeSpan(1.0), bool hide_at_end = false);
        uint04 targetCount() const;
        DesignObject getTarget(uint04 target) const;
        void update(Time current_time, DesignObjectLookup* lock_ptr);

        template<class t_type>
        void setTargetProperty(uint04 property_name, t_type value)
        {
            set(NDPE::target_property, property_name);
            set(NDPE::target_value_a, value);
        }

        template<class t_type>
        void setTargetProperty(uint04 property_name, t_type value_a, t_type value_b)
        {
            set(NDPE::target_property, property_name);
            set(NDPE::target_value_a, value_a);
            set(NDPE::target_value_b, value_b);
        }

        void clearTargets();
        void removeTarget(uint04 index);
        void setTargets(const Buffer<DesignObject>& targets);
        Buffer<DesignObject> getTargets() const;
        void setTarget(uint04 index, const DesignObject& target);
        void addTarget(uint04 index, const DesignObject& target);
        void addTarget(const DesignObject& target);
        EffectType effectType() const;
        void setEffectType(EffectType type);
        void deactivate();
        void activate();
        void deleteEffect();
        bool operator==(const Effect& mat) const
        {
            return mat.index() == index();
        }

        bool operator!=(const Effect& effect) const
        {
            return effect.index() != index();
        }
    private:
        void _updateBoundingBox(Buffer<DesignObject>& targets, const Time& update_time, const void* lock_ptr = nullptr);
        void _updateTargetProperty(EffectType effect_type, Buffer<DesignObject>& targets, const StringView& value, const void* lock_ptr = nullptr);
#if NDEVR_STATION_MODEL
        void _updateStation(Buffer<DesignObject>& targets, const Time& update_time, DesignObjectLookup* lookup);
#endif
        void _updateAzimuth(Buffer<DesignObject>& targets, const Time& update_time, DesignObjectLookup* lookup);
        void _updateLocation(Buffer<DesignObject>& targets, const Time& update_time, DesignObjectLookup* lookup);
        void _updateMotion(Buffer<DesignObject>& targets, const Time& update_time, DesignObjectLookup* lookup);
        void _updateTileModel(Buffer<DesignObject>& targets, const Time& update_time, DesignObjectLookup* lookup);
#if NDEVR_SCAN
        void _updateScan(Buffer<DesignObject>& targets, const Time& update_time, const void* lock_ptr);
#endif
    };

    template<>
    struct ObjectInfo<Effect, false, false>
    {
        static const uint01 Dimensions = 0;   
        static const bool Vector = false;      
        static const bool Buffer = false;      
        static const bool Primitive = true;    
        static const bool Pointer = false;     
        static const bool Unsigned = false;    
        static const bool Float = false;       
        static const bool Integer = false;     
        static const bool Number = false;      
        static const bool Enum = false;        
        static const bool String = false;      
        static const bool Color = false;       
        static const bool Boolean = false;     
        static constexpr ObjectInfo<Effect, false, false> VectorSub() { return ObjectInfo<Effect, false, false>(); }
    };
}