Effect.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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 Model;
    class DesignObjectLookup;
    /**--------------------------------------------------------------------------------------------------
    \brief A core class that provides a dynamic effect to an object in a model heirarchy.
    **/
    class NDEVR_DESIGN_API Effect : public DesignObject
    {
    public:
        enum EffectType : uint01
        {
              e_none
            , e_placeholer
            , 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
        };
 
        enum EffectProperties : uint01
        {
              e_effect_type
            , e_is_active
            , e_start_time
            , e_end_time
            , e_frequency
            , e_extra_size
            , e_extra_transform
            , e_destroy_when_finished
            , e_target_property
            , e_target_value_a
            , e_target_value_b
        };
    public:
        Effect();//constructor for invalid object
        Effect(uint04 index, DesignObjectBase* property_table);
        Effect(DesignObjectBase* property_table);
 
        template<class t_type>
        void setEffectProperty(EffectProperties mat_index, const t_type& type)
        {
            m_base->effect_table.get()[m_base->effect_property_index[mat_index]].set(m_design_index, type);
        }
        template<class t_type>
        [[nodiscard]] t_type getEffectProperty(EffectProperties mat_index) const
        {
            t_type type;
            m_base->effect_table.get()[m_base->effect_property_index[mat_index]].get(m_design_index, type);
            return type;
        }
        void cleanup();
        void setupAsLight(fltp04 intensity = 1.0);
        void setupAsBlinking(fltp04 frequency);
        void setupAsBoundingBox(const Model& bounds);
        void setupAsBoundingBox(const Model& bounds, const Model& target);
        void setupAsBoundingBox(const Model& bounds, const Buffer<Model, uint04, ObjectAllocator<DESIGN_PRIM>>& 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 setupAsSetTransform(const Model& target, const Matrix<fltp08>& transform, const TimeSpan& span = TimeSpan(1.0));
        uint04 numberOfTargets() 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)
        {
            setEffectProperty(EffectProperties::e_target_property, property_name);
            setEffectProperty(EffectProperties::e_target_value_a, value);
        }
        template<class t_type>
        void setTargetProperty(uint04 property_name, t_type value_a, t_type value_b)
        {
            setEffectProperty(EffectProperties::e_target_property, property_name);
            setEffectProperty(EffectProperties::e_target_value_a, value_a);
            setEffectProperty(EffectProperties::e_target_value_b, value_b);
        }
        void clearTargets() const;
        void removeTarget(uint04 index);
        
        Buffer<DesignObject, uint04, ObjectAllocator<DESIGN_PRIM>> 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& mat) const
        {
            return mat.index() != index();
        }
    private:
        void _updateTargetProperty(EffectType effect_type, Buffer<DesignObject>& targets, const String& value, const void* lock_ptr = nullptr);
#if NDEVR_STATION_MODEL
        void _updateStation(const Time& update_time, DesignObjectLookup* lookup);
#endif
        void _updateAzimuth(const Time& update_time, DesignObjectLookup* lookup);
        void _updateLocation(const Time& update_time, DesignObjectLookup* lookup);
#if NDEVR_SCAN
        void _updateScan(const Time& update_time, const void* lock_ptr);
#endif
    };
 
 
}