pluginscenemanager.c

Go to the documentation of this file.

class PluginSceneManager extends PluginBase
{
    static string       SCENE_DEFAULT_NAME      = "default";
    static string       SCENE_SUFIX             = "scene";
    static PlayerBase   PLAYER;
    static PluginSceneManager instance;
    
    bool            m_RulerActivated;
    ref array<vector>   m_RulerPoints;
    ref array<Shape>    m_RulerLines;
    ref array<Shape>    m_RulerSpheres;
    
    static const int SCENE_EDITOR_CMD_REFRESH   = 0;
    static const int SCENE_EDITOR_CMD_POPUP     = 1;
    static const int SCENE_EDITOR_CMD_SAVE      = 2;
    
    //---------------------------------------------------------------------------------
    // >> Public scope
 
    // System Events
    void PluginSceneManager()
    {
        if ( instance == NULL )
        {
            instance = this;
        }
    }
    
    // System Events
    void ~PluginSceneManager()
    {
        if ( instance == NULL )
        {
            instance = this;
        }
    }
    
    static PluginSceneManager GetInstance()
    {
        return PluginSceneManager.Cast( GetPlugin( PluginSceneManager ) );
    }
 
    //==========================================
    // OnInit (System Event)
    //==========================================
    override void OnInit()
    {
        m_ModuleDeveloper           = PluginDeveloper.Cast( GetPlugin(PluginDeveloper) );
        m_ModuleConfigScene         = PluginConfigScene.Cast( GetPlugin(PluginConfigScene) );
        m_ModuleConfigDebugProfile  = PluginConfigDebugProfile.Cast( GetPlugin(PluginConfigDebugProfile) );
        
        //Ruler
        m_RulerActivated = false;
        m_RulerPoints   = new array<vector>;
        m_RulerLines    = new array<Shape>;
        m_RulerSpheres  = new array<Shape>;
    }
 
    //==========================================
    // OnDestroy (destructor)
    //==========================================
    override void OnDestroy()
    {
        SceneUnload();
    }
    
    //==========================================
    // OnMouseWheel
    //==========================================
    void OnMouseWheel(int wheel)
    {
        if ( !IsMouseInScene() )
        {
            return;
        }
        
        if ( GetSelectedSceneObject() )
        {
            GetSelectedSceneObject().AddRotation(GetRotationAngle() * wheel);
        }
        
        EditorUpdate();
    }
 
    //==========================================
    // OnUIEditorOpened
    //==========================================
    void OnUIEditorOpened()
    {   
        m_IsOpen = true;
 
        DeveloperFreeCamera.EnableFreeCameraSceneEditor( PlayerBase.Cast( g_Game.GetPlayer() ) );
        
        g_Game.GetCallQueue(CALL_CATEGORY_SYSTEM).Call(this.FreeCameraControlDisable);
        
        EditorUpdate();
    }
 
    //==========================================
    // OnUIEditorClosed
    //==========================================
    void OnUIEditorClosed()
    {
        m_IsOpen = false;
        
        FreeCameraControlEnable();
        
        m_ModuleDeveloper.ToggleFreeCameraBackPos();
        
        EditorUpdate();
    }
    
    //::::::::::::::::::::::::::::::::::::::::::
    // Event_OnClick
    //::::::::::::::::::::::::::::::::::::::::::
    void Event_OnClick()
    {
        if ( !IsMouseInScene() || !m_IsOpen )
        {
            return;
        }
            
        // Direction Vector from current active Camera
        vector dir = g_Game.GetPointerDirection();
        
        // Raycast from
        vector from = FreeDebugCamera.GetInstance().GetPosition(); 
        // Raycast to
        vector to = from + ( dir * 10000 );
        // Raycast out parameter
        vector contact_pos;
        vector contact_dir;
        int contact_component;
        set<Object> objects = new set<Object>;
        bool selected = false;
        
        if ( DayZPhysics.RaycastRV(from, to, contact_pos, contact_dir, contact_component, objects) )   
        {
            for ( int i = 0; i < objects.Count(); ++i )
            {
                Object obj = objects.Get(i);
                
                if ( obj.IsInherited( EntityAI ) )
                {
                    SceneObject sc_object = SceneObject.Cast( m_SceneData.GetSceneObjectByEntityAI(EntityAI.Cast( obj ) ) );
                    
                    if ( sc_object == NULL )
                    {
                        //sc_object = m_SceneData.AddObject(obj);
                        return;
                    }
                    
                    SelectObject( sc_object );
                    selected = true;
                    
                    break;
                }
            }
        }
        
        if ( !selected )
        {
            DeselectObject();
            
            //  Ruler
            if ( IsRulerActivated() && GetSelectedSceneObject() == NULL )
            {
                RulerAddPoint();
            }
        }
        
        EditorUpdate();
    }
 
    //::::::::::::::::::::::::::::::::::::::::::
    // Event_OnClickMiddle
    //::::::::::::::::::::::::::::::::::::::::::
    void Event_OnClickMiddle()
    {
        if ( !IsMouseInScene() || !m_IsOpen )
        {
            return;
        }
        
        if ( GetSelectedSceneObject() != NULL )
        {
            // Direction Vector from current active Camera
            vector dir = g_Game.GetPointerDirection();
            
            // Raycast from
            vector from = FreeDebugCamera.GetInstance().GetPosition(); 
            // Raycast to
            vector to = from + ( dir * 10000 );   
            // Raycast out parameter
            vector contact_pos;
            vector contact_dir;
            int contact_component;
            set<Object> objects = new set<Object>;
            bool selected = false;
            
            if ( DayZPhysics.RaycastRV(from, to, contact_pos, contact_dir, contact_component, objects) )   
            {
                for ( int i = 0; i < objects.Count(); ++i )
                {
                    Object obj = objects.Get(i);
                    
                    if ( obj.IsInherited( EntityAI ) )
                    {
                        EntityAI eai = EntityAI.Cast( obj );
                        SceneObject scene_object = m_SceneData.GetSceneObjectByEntityAI(eai);
                        
                        if ( !scene_object.IsPlayer() )
                        {
                            if ( scene_object != NULL && scene_object != GetSelectedSceneObject() )
                            {
                                if ( !AreSceneObjectsLinked(GetSelectedSceneObject(), scene_object) ) 
                                {
                                    LinkSceneObjects( GetSelectedSceneObject(), scene_object );
                                }
                                else
                                {
                                    UnlinkSceneObjects( GetSelectedSceneObject(), scene_object );
                                }
                            }
                        }
                        else
                        {
                            SceneEditorMenuCmdPopup("I am sorry. You cant create link on player!");
                        }
                    }
                }
            }
        }
        
        EditorUpdate();
    }
 
    //::::::::::::::::::::::::::::::::::::::::::
    // Event_OnDrag
    //::::::::::::::::::::::::::::::::::::::::::
    void Event_OnDrag()
    {
        if ( !IsMouseInScene() || !m_IsOpen )
        {
            return;
        }
        
        if ( GetSelectedSceneObject() != NULL )
        {
            // Direction Vector from current active Camera
            vector dir = g_Game.GetPointerDirection();
            
            // Raycast from
            vector from = FreeDebugCamera.GetInstance().GetPosition(); 
            // Raycast to
            vector to = from + ( dir * 10000 );   
            // Raycast out parameter
            vector contact_pos;
            vector contact_dir;
            int contact_component;
            
            //Raycast(vector begPos, vector endPos, out vector contactPos, out vector contactDir, out int contactComponent, out set<Object> results = NULL, Object with = NULL, Object ignore = NULL,  bool sorted = false,  bool ground_only = false,  int iType = ObjIntersectView, float radius = 0.0);
            
            if ( DayZPhysics.RaycastRV(from, to, contact_pos, contact_dir, contact_component, NULL, NULL, NULL, false, true) )   
            {
                GetSelectedSceneObject().SetPosition(contact_pos);
            }
            
            EditorUpdate();
        }
    }
 
    //::::::::::::::::::::::::::::::::::::::::::
    // Event_OnDoubleClick
    //::::::::::::::::::::::::::::::::::::::::::
    SceneObject Event_OnDoubleClick()
    {
        if ( !IsMouseInScene() || !m_IsOpen || m_ClassBrowserSelected == "" )
        {
            return null;
        }
        
        // Direction Vector from current active Camera
        vector dir = g_Game.GetPointerDirection();
        
        // Raycast from
        vector from = FreeDebugCamera.GetInstance().GetPosition(); 
        // Raycast to
        vector to = from + ( dir * 10000 );   
        // Raycast out parameter
        vector contact_pos;
        vector contact_dir;
        int contact_component;
        
        if ( DayZPhysics.RaycastRV(from, to, contact_pos, contact_dir, contact_component) )   
        {
            SceneObject obj = m_SceneData.CreateSceneObject(m_ClassBrowserSelected, contact_pos);
            
            if ( obj != NULL )
            {
                SelectObject(obj);
                return obj;
            }           
        }
        
        return NULL;
    }
    
    //==========================================
    // Load
    //==========================================
    void InitLoad()
    {       
        PLAYER = PlayerBase.Cast( g_Game.GetPlayer() );
        
        SceneLoad( PluginMissionConfig.GetInstance().GetSceneEditorName() );
        
        RestoreSceneObjectsLinks();
        
        ExecuteInitScripts();
    }
 
    //==========================================
    // RestoreSceneObjectsLinks
    //==========================================
    void RestoreSceneObjectsLinks()
    {
        array<ref SceneObject> scene_objects = GetSceneObjects();
            
        for ( int i = 0; i < scene_objects.Count(); i++ )
        {
            SceneObject scene_object = scene_objects.Get(i);
            
            array<int> linked_scene_objects_indices = scene_object.m_LinkedSceneObjectsIndices;
            if (linked_scene_objects_indices)
            {
                for ( int j = 0; j < linked_scene_objects_indices.Count(); j++ )
                {
                    int index = linked_scene_objects_indices.Get(j);
                    if ( index >= 0 && index < scene_objects.Count() )
                    {
                        scene_object.LinkSceneObject( scene_objects.Get(index), false );
                        
//PrintString("Load link: "+ ToString(scene_object.GetObject()) +" <-> "+ ToString(scene_objects.Get(index).GetObject()) );
                    }
                }
            }
            scene_object.m_LinkedSceneObjectsIndices = NULL;
        }
    }
 
    //==========================================
    // ExecuteInitScripts
    //==========================================
    void ExecuteInitScripts()
    {
        array<ref SceneObject> scene_objects = GetSceneObjects();   
        for ( int i = 0; i < scene_objects.Count(); i++ )
        {
            SceneObject scene_object = scene_objects.Get(i);
            ExecuteEnforceScript( i, scene_object, scene_object.GetInitScript() );
        }
    }
    
    //==========================================
    // EditorToggle
    //==========================================
    void EditorToggle()
    {   
        //Log("EditorToggle");
 
        if ( g_Game.IsMultiplayer() )
        {
            return;
        }
 
        if ( IsOpened() )
        {
            // Close UI Scene Editor Menu
            g_Game.GetUIManager().Back();
        }
        else
        {
            // Open UI Scene Editor Menu
            g_Game.GetUIManager().EnterScriptedMenu(MENU_SCENE_EDITOR, NULL);
            EditorUpdate();
        }
    }
    
    //==========================================
    // IsOpened
    //==========================================
    bool IsOpened()
    {
        return m_IsOpen;
    }
 
    //==========================================
    // SelectClassName
    //==========================================
    void SelectClassName(string class_name)
    {
        m_ClassBrowserSelected = class_name;
    }
 
    //==========================================
    // FreeCameraControlEnable
    //==========================================
    void FreeCameraControlEnable()
    {
        // Enable Camera control
        g_Game.GetInput().ChangeGameFocus(-1);
        
        // Disable Cursor
        g_Game.GetUIManager().ShowUICursor(false);
        
        if( g_Game.GetUIManager().GetMenu() )
            g_Game.GetUIManager().GetMenu().OnHide();
    }
 
    //==========================================
    // FreeCameraControlDisable
    //==========================================
    void FreeCameraControlDisable()
    {
        // Disable Camera control
        g_Game.GetInput().ChangeGameFocus(1);
        
        // Enable Cursor
        g_Game.GetUIManager().ShowUICursor(true);
        
        if( g_Game.GetUIManager().GetMenu() )
            g_Game.GetUIManager().GetMenu().OnShow();
    }
    
    //==========================================
    // DeleteSelectedObject
    //==========================================
    void DeleteSelectedObject()
    {
        SceneObject selected_obj = GetSelectedSceneObject();
        
        if ( selected_obj != NULL )
        {
            if ( !selected_obj.IsPlayer() )
            {
                array<ref SceneObject> scene_objects = GetSceneObjects();
                for ( int i = 0; i < scene_objects.Count(); i++ )
                {
                    if ( AreSceneObjectsLinked(scene_objects.Get(i), selected_obj) )
                    {
                        UnlinkSceneObjects(scene_objects.Get(i), selected_obj);
                    }
                }
                
                m_SceneData.DeleteSceneObject(selected_obj);
                
                scene_objects.RemoveItem(selected_obj);
                
                DeselectObject();
            }
            else
            {
                SceneEditorMenuCmdPopup("You cant delete player!");
            }
        }
        
        EditorUpdate();
    }
    
    //==========================================
    // SelectObject
    //==========================================
    void SelectObject(SceneObject obj)
    {
        if ( GetSelectedSceneObject() != NULL && GetSelectedSceneObject() == obj )
        {
            return;
        }
        
        DeselectObject();
 
        m_SelectedObject = obj;
        
        EditorUpdate();
    }
    
    //==========================================
    // GetSelectedSceneObject
    //==========================================
    SceneObject GetSelectedSceneObject()
    {
        return m_SelectedObject;
    }
 
    //==========================================
    // SelectedObjectDuplicate
    //==========================================
    void SelectedObjectDuplicate()
    {
        SceneObject selected_obj = GetSelectedSceneObject();
        
        if ( selected_obj )
        {
            if ( selected_obj.GetObject() == PLAYER )
            {
                return;
            }
            
            vector size = GetSelectedSceneObject().GetSize();
            
            vector new_pos = selected_obj.GetPosition() + Vector(1, 0, 1) + size;
            
            SceneObject obj = m_SceneData.CreateSceneObject(selected_obj.GetTypeName(), new_pos );
            obj.SetRotation(selected_obj.GetRotation());
            
            array<EntityAI> attachments = selected_obj.GetAttachments();
            for ( int i = 0; i < attachments.Count(); i++ )
            {
                obj.AddAttachment( attachments.Get(i).GetType() );
            }
            
            SelectObject(obj);
        }
    }
 
    //==========================================
    // SelectedObjectSetRot
    //==========================================
    void SelectedObjectSetRot(float dir)
    {
        if ( GetSelectedSceneObject() )
        {
            GetSelectedSceneObject().SetRotation(dir);
            
            EditorUpdate();
        }
    }
 
    //==========================================
    // SelectedObjectSetPosX
    //==========================================
    void SelectedObjectSetPosX(float value)
    {
        SceneObject selected_obj = GetSelectedSceneObject();
        
        if ( selected_obj )
        {
            vector v = selected_obj.GetPosition();
            v[0] = value;
            selected_obj.SetPosition(v);
            
            EditorUpdate();
        }
    }
 
    //==========================================
    // SelectedObjectSetPosY
    //==========================================
    void SelectedObjectSetPosY(float value)
    {
        SceneObject selected_obj = GetSelectedSceneObject();
        
        if ( selected_obj )
        {
            vector v = selected_obj.GetPosition();
            v[1] = value;
            selected_obj.SetPosition(v);
            
            EditorUpdate();
        }
    }
 
    //==========================================
    // SelectedObjectSetPosZ
    //==========================================
    void SelectedObjectSetPosZ(float value)
    {
        SceneObject selected_obj = GetSelectedSceneObject();
        
        if ( GetSelectedSceneObject() )
        {
            vector v = selected_obj.GetPosition();
            v[2] = value;
            selected_obj.SetPosition(v);
            
            EditorUpdate();
        }
    }
 
    //==========================================
    // SelectedObjectSetDamage
    //==========================================
    void SelectedObjectSetDamage(float value)
    {
        SceneObject selected_obj = GetSelectedSceneObject();
        EntityAI selected_obj_EAI = selected_obj.GetObject();
        
        if ( selected_obj )
        {
            selected_obj.SetHealth(Math.Clamp ( value, 0, selected_obj_EAI.GetMaxHealth("", "") ));
            
            EditorUpdate();
        }
    }
 
    //==========================================
    // SelectedObjectFocus
    //==========================================
    void SelectedObjectFocus()
    {
        SceneObject selected_obj = GetSelectedSceneObject();
        
        if ( selected_obj )
        {
            vector      cam_pos = FreeDebugCamera.GetInstance().GetPosition();
            vector      obj_pos = selected_obj.GetPosition();
            vector      view_target = obj_pos;
            
            vector obj_size = selected_obj.GetSize();
            
            cam_pos = obj_pos;
            
            cam_pos[0] = cam_pos[0] + ( obj_size[0] * 2 );
            cam_pos[1] = cam_pos[1] + obj_size[1] + 0.5;
            cam_pos[2] = cam_pos[2] + ( obj_size[2] * 2 );      
            
            view_target[1] = view_target[1] + (obj_size[1] * 0.5);
            
            vector cam_dir = view_target - cam_pos;
            cam_dir.Normalize();
            
            FreeDebugCamera.GetInstance().SetPosition(cam_pos);
            FreeDebugCamera.GetInstance().SetDirection(cam_dir);
            
            //vector debug_pos = cam_pos + (cam_dir * 50);
            //Debug.DrawLine(cam_pos, debug_pos);
            //Debug.DrawSphere(cam_pos);
        }
    }
 
    //==========================================
    // SelectedObjectAddAttachment
    //==========================================
    void SelectedObjectAddAttachment(string att_name)
    {
        if ( GetSelectedSceneObject() )
        {
            GetSelectedSceneObject().AddAttachment(att_name);
        }
        
        EditorUpdate();
    }
 
    //==========================================
    // SelectedObjectRemoveAttachment
    //==========================================
    void SelectedObjectRemoveAttachment(EntityAI e)
    {
        if ( GetSelectedSceneObject() )
        {
            GetSelectedSceneObject().RemoveAttachment(e);
        }
        
        EditorUpdate();
    }
 
    //==========================================
    // LinkSceneObjects
    //==========================================
    void LinkSceneObjects(SceneObject scene_object1, SceneObject scene_object2)
    {
        scene_object1.LinkSceneObject(scene_object2);
        scene_object2.LinkSceneObject(scene_object1);
    }
 
    //==========================================
    // UnlinkSceneObjects
    //==========================================
    void UnlinkSceneObjects(SceneObject scene_object1, SceneObject scene_object2)
    {
        scene_object1.UnlinkSceneObject(scene_object2);
        scene_object2.UnlinkSceneObject(scene_object1);
    }
 
    //==========================================
    // AreSceneObjectsLinked
    //==========================================
    bool AreSceneObjectsLinked(SceneObject scene_object1, SceneObject scene_object2)
    {
        if ( scene_object1.IsLinkedWithSceneObject(scene_object2) && scene_object2.IsLinkedWithSceneObject(scene_object1) )
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    
    //==========================================
    // SetDrawSelection
    //==========================================
    void SetDrawSelection(bool draw)
    {
        m_ModuleConfigDebugProfile.SetSceneEditorDrawSelection(draw);
        
        EditorUpdate();
    }
 
    //==========================================
    // GetDrawSelection
    //==========================================
    bool GetDrawSelection()
    {
        return m_ModuleConfigDebugProfile.GetSceneEditorDrawSelection();
    }
 
    //==========================================
    // SetLoadPlayerPos
    //==========================================
    void SetLoadPlayerPos(bool save)
    {
        m_ModuleConfigDebugProfile.SetSceneEditorLoadPlayerPos(save);
    }
 
    //==========================================
    // SetLoadPlayerPos
    //==========================================
    bool GetLoadPlayerPos()
    {
        return m_ModuleConfigDebugProfile.GetSceneEditorLoadPlayerPos();
    }
    
    //==========================================
    // SetRotationAngle
    //==========================================
    void SetRotationAngle(int angle)
    {
        m_ModuleConfigDebugProfile.SetSceneEditorRotationAngle(angle);
    }
 
    //==========================================
    // GetRotationAngle
    //==========================================
    int GetRotationAngle()
    {
        return m_ModuleConfigDebugProfile.GetSceneEditorRotationAngle();
    }
 
    //==========================================
    // SceneLoad
    //==========================================
    void SceneLoad(string scene_name)
    {
        SceneUnload();
        
        PluginMissionConfig.GetInstance().SetSceneEditorName(scene_name);
        m_SceneData = m_ModuleConfigScene.SceneDataLoad(scene_name);
        
        if ( !(g_Game.IsMultiplayer() && g_Game.IsServer()) )
        {
            EditorUpdate();
        }
    }
 
    //==========================================
    // SceneUnload
    //==========================================
    void SceneUnload()
    {
        m_SceneData = NULL;
        DeselectObject();
    }
 
    //==========================================
    // SceneSave
    //==========================================
    void SceneSave()
    {
        m_ModuleConfigScene.ClearParams();
        m_ModuleConfigScene.SceneDataSave(m_SceneData);
        SceneEditorMenuCmdSave();
        EditorUpdate();
    }
 
    //==========================================
    // SceneDelete
    //==========================================
    bool SceneCanDelete(string scene_name)
    {
        if ( scene_name == m_SceneData.GetNameScene() )
        {
            return false;
        }
        
        return true;
    }
 
    //==========================================
    // SceneDelete
    //==========================================
    bool SceneDelete(string scene_name)
    {
        if ( scene_name == m_SceneData.GetNameScene() )
        {
            return false;
        }
        
        m_ModuleConfigScene.SceneDelete(scene_name);
        
        EditorUpdate();
        
        return true;
    }   
 
    //==========================================
    // SceneDelete
    //==========================================
    void SceneDuplicate(string scene_name)
    {
        m_ModuleConfigScene.SceneDuplicate(scene_name);
        
        EditorUpdate();
    }
 
    //==========================================
    // SceneRename
    //==========================================
    void SceneRename(string scene_name, string new_name)
    {
        m_ModuleConfigScene.SceneRename(scene_name, new_name);
        
        if ( scene_name == m_SceneData.GetNameScene() )
        {
            m_SceneData.SetNameScene(new_name);
        }
        
        EditorUpdate();
    }
 
    //==========================================
    // SceneGetName
    //==========================================
    string SceneGetName()
    {
        if ( m_SceneData )
        {
            return m_SceneData.GetNameScene();
        }
        
        return STRING_EMPTY;
    }
    
    //==========================================
    // SetWeather
    //==========================================
    void SetWeather(float overcast, float rain, float fog, float wind_force)
    {
        m_SceneData.SetInitOvercast(overcast);
        m_SceneData.SetInitRain(rain);
        m_SceneData.SetInitFog(fog);
        m_SceneData.SetInitWindForce(wind_force);
    }
 
    //==========================================
    // SetDate
    //==========================================
    void SetDate( int year, int month, int day, int hour, int minute )
    {
        m_SceneData.SetInitYear(year);
        m_SceneData.SetInitMonth(month);
        m_SceneData.SetInitDay(day);
        m_SceneData.SetInitHour(hour);
        m_SceneData.SetInitMinute(minute);
    }
 
    //==========================================
    // SelectAndFocusPlayerObject
    //==========================================
    void SelectAndFocusPlayerObject()
    {
        array<ref SceneObject> scene_objects = GetSceneObjects();
        for ( int i = 0; i < scene_objects.Count(); i++ )
        {
            if ( scene_objects.Get(i).GetObject() == g_Game.GetPlayer() )
            {
                SelectObject( scene_objects.Get(i) );
                SelectedObjectFocus();
                break;
            }
        }
    }
        
    //------------------------------------------
    // ExecuteEnforceScript
    //------------------------------------------
    void ExecuteEnforceScript( int index, SceneObject scene_object, string script )
    {
        if ( script != "" )
        {
            string cls = scene_object.GetObject().ClassName();
            string wrapped_script = "void scMngMain() \n{\n PluginSceneManager se = GetPlugin(Type(\"PluginSceneManager\")); \n SceneObject this_obj = se.GetSceneObjectByIndex(" + index.ToString() + "); \n " + cls + " this_eai = this_obj.GetObject(); \n " + script + "\n}\n";
            
            g_Game.ExecuteEnforceScript(wrapped_script, "scMngMain");
        }
    }
    
    //==========================================
    // RulerToggle
    //==========================================
    void RulerToggle()
    {
        if ( IsRulerActivated() )
        {
            m_RulerActivated = false;
        }
        else
        {
            m_RulerActivated = true;
        }
        
        SceneEditorMenuCmdRefresh();
    }
 
    //==========================================
    // ActivateRuler
    //==========================================
    bool IsRulerActivated()
    {
        return m_RulerActivated;
    }
 
    //==========================================
    // RulerAddPoint
    //==========================================
    void RulerAddPoint()
    {
        vector point_pos = GetMousePositionInScene();
        
        m_RulerPoints.Insert( point_pos );
        
        EditorUpdateRuler();
    }
 
    //------------------------------------------
    // RulerClearVisuals
    //------------------------------------------
    void RulerClearVisuals()
    {
        for ( int i = 0; i < m_RulerLines.Count(); ++i )
        {
            m_RulerLines.Get(i).Destroy();
        }
        m_RulerLines.Clear();
        
        for ( int j = 0; j < m_RulerSpheres.Count(); ++j )
        {
            m_RulerSpheres.Get(j).Destroy();
        }
        m_RulerSpheres.Clear();
    }
 
    //------------------------------------------
    // RulerDelete
    //------------------------------------------
    void RulerDelete()
    {
        m_RulerPoints.Clear();
        
        EditorUpdateRuler();
    }
 
    //==========================================
    // GetLoadedScene
    //==========================================
    SceneData GetLoadedScene()
    {
        return m_SceneData;
    }
 
    //==========================================
    // GetSelectedSceneObjectIndex
    //==========================================
    int GetSelectedSceneObjectIndex()
    {
        array<ref SceneObject> scene_objects = GetSceneObjects();
        for ( int i = 0; i < scene_objects.Count(); i++ )
        {
            if ( GetSelectedSceneObject() == scene_objects.Get(i) )
            {
                return i;
            }
        }
        
        return -1;
    }
 
    //==========================================
    // GetSceneObjects
    //==========================================
    array<ref SceneObject> GetSceneObjects()
    {
        if ( m_SceneData )
        {
            return m_SceneData.GetSceneObjects();
        }
        
        return NULL;
    }
    
    //==========================================
    // GetScenePlayers
    //==========================================
    array<ref ScenePlayer> GetScenePlayers()
    {
        if ( m_SceneData )
        {
            return m_SceneData.GetScenePlayers();
        }
        
        return NULL;
    }
    
    //==========================================
    // GetSceneObjectsAll
    //==========================================
    array<ref SceneObject> GetSceneObjectsAll()
    {
        if ( m_SceneData )
        {
            return m_SceneData.GetSceneObjectsAll();
        }
        
        return NULL;
    }
 
    //==========================================
    // GetSceneObjectByIndex
    //==========================================
    SceneObject GetSceneObjectByIndex( int index )
    {
        array<ref SceneObject> scene_objects = GetSceneObjects();
        
        if ( scene_objects != NULL )
        {
            if ( index > -1 && index < scene_objects.Count() )
            {
                return scene_objects.Get( index );
            }
        }
        
        return NULL;
    }
 
    //==========================================
    // GetSceneObjectByEntity
    //==========================================
    SceneObject GetSceneObjectByEntity( EntityAI entity )
    {
        array<ref SceneObject> scene_objects = GetSceneObjects();
        
        if ( scene_objects != NULL )
        {
            for ( int i = 0; i <= scene_objects.Count(); ++i )
            {
                SceneObject obj = scene_objects.Get(i);
                EntityAI e = obj.GetObject();       
                
                if ( e == entity )
                {
                    return obj;
                }
            }
        }
        
        return NULL;
    }
    
    //==========================================
    // GetSceneList
    //==========================================
    TStringArray GetSceneList()
    {
        return m_ModuleConfigScene.GetSceneList();
    }
 
    //==========================================
    // DeleteSceneObject
    //==========================================
    void DeleteSceneObject(SceneObject obj)
    {       
        if ( obj != NULL )
        {
            if ( obj.GetObject() != g_Game.GetPlayer() )
            {
                obj.UnlinkAll();
                
                if ( GetSelectedSceneObject() != NULL && GetSelectedSceneObject() == obj )
                {
                    DeselectObject();
                }
                
                m_SceneData.DeleteSceneObject(obj);
            }
            else
            {
                SceneEditorMenuCmdPopup("You cant delete player!");
            }
        }
            
        EditorUpdate();
    }
    
    //---------------------------------------------------------------------------------
    // >> Protected scope
    protected PluginDeveloper           m_ModuleDeveloper;
    protected PluginConfigScene         m_ModuleConfigScene;
    protected PluginConfigDebugProfile  m_ModuleConfigDebugProfile;
 
    //---------------------------------------------------------------------------------
    // >> protected Scope
    protected float                 m_TimeLastClickRelease;
    protected float                 m_TimeLastClickPress;
    protected int                   m_PressedMouseID;
    protected bool                  m_IsDragging;
    protected ref array<Shape>  m_ShapesSceneObjects;
    protected ref map<int, KeyBinding>  m_KeyBindings;
    protected ref SceneData     m_SceneData;
    protected SceneObject           m_SelectedObject;
    protected string                m_ClassBrowserSelected;
    protected bool                  m_IsOpen;
    
    //------------------------------------------
    // DeselectObject
    //------------------------------------------
    private void DeselectObject()
    {
        m_SelectedObject = NULL;
    }
    
    //------------------------------------------
    // EditorUpdate 
    //------------------------------------------
    protected void EditorUpdate()
    {
        if ( g_Game.IsMultiplayer() )
        {
            return;
        }
        
        array<ref SceneObject> objects = GetSceneObjects();
        if( !objects )
            return;
        for ( int i = 0; i < objects.Count(); ++i )
        {
            SceneObject obj = objects.Get(i);
            
            array<SceneObject> linked_scene_objects = obj.GetLinkedSceneObjects();
            int j;
            
            if ( IsOpened() )
            {
                obj.EditorShapeAdd();
                
                if ( GetSelectedSceneObject() && GetSelectedSceneObject() == obj )
                {
                    if ( GetDrawSelection() )
                    {
                        obj.EditorShapeSelect();
                    }
                }
                else
                {
                    obj.EditorShapeDeselect();
                }
                
                for ( j = 0; j < linked_scene_objects.Count(); j++ )
                {                   
                    obj.EditorLineAdd( linked_scene_objects.Get(j) );
                }
            }
            else
            {
                obj.EditorShapeRemove();
                
                if (linked_scene_objects)
                {
                    for ( j = 0; j < linked_scene_objects.Count(); j++ )
                    {
                        obj.EditorLineRemove( linked_scene_objects.Get(j) );
                    }
                }
            }
        }
 
        SceneEditorMenuCmdRefresh();
    }
    
    //------------------------------------------
    // SceneEditorMenuRefresh
    //------------------------------------------
    private void SceneEditorMenuCmdRefresh()
    {
        CallMethod(CALL_ID_SCENE_EDITOR_COMMAND, new Param2<int, Param>(SCENE_EDITOR_CMD_REFRESH, NULL));
    }
 
    //------------------------------------------
    // SceneEditorMenuCmdPopup
    //------------------------------------------
    private void SceneEditorMenuCmdPopup(string message)
    {
        CallMethod(CALL_ID_SCENE_EDITOR_COMMAND, new Param2<int, Param1<string>>(SCENE_EDITOR_CMD_POPUP, new Param1<string>(message)));
    }
 
    //------------------------------------------
    // SceneEditorMenuCmdSave
    //------------------------------------------
    private void SceneEditorMenuCmdSave()
    {
        CallMethod(CALL_ID_SCENE_EDITOR_COMMAND, new Param2<int, Param>(SCENE_EDITOR_CMD_SAVE, NULL));
    }
    
    //------------------------------------------
    // IsMouseInScene
    //------------------------------------------
    private bool IsMouseInScene()
    {
        Widget widget_under_mouse = GetWidgetUnderCursor();
        
        if ( widget_under_mouse != NULL && widget_under_mouse.GetName() == "pnl_SceneControl" )
        {
            return true;
        }
        
        return false;
    }
    
    //------------------------------------------
    // EditorUpdateRuler
    //------------------------------------------
    private void EditorUpdateRuler()
    {
        RulerClearVisuals();
        
        for ( int i = 0; i < m_RulerPoints.Count(); ++i )
        {
            vector pos1 = m_RulerPoints.Get(i);
            
            m_RulerSpheres.Insert(Debug.DrawSphere(pos1, 0.1));
            
            if ( i < m_RulerPoints.Count() - 1 )
            {
                vector pos2 = m_RulerPoints.Get(i + 1);
                m_RulerLines.Insert(Debug.DrawLine(pos1, pos2));
            }
        }
    }
    
    //------------------------------------------
    // GetMousePositionInScene
    //------------------------------------------
    private vector GetMousePositionInScene()
    {
        vector dir = g_Game.GetPointerDirection();
        vector from = FreeDebugCamera.GetInstance().GetPosition(); 
        vector to = from + ( dir * 10000 );   
        vector contact_pos;
        vector contact_dir;
        int contact_component;
        
        if ( DayZPhysics.RaycastRV(from, to, contact_pos, contact_dir, contact_component) )   
        {
            return contact_pos;
        }
        
        return "0 0 0";
    }
}