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( GetGame().GetPlayer() ) );
 
 GetGame().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 = GetGame().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 = GetGame().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 = GetGame().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 = GetGame().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( GetGame().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 ( GetGame().IsMultiplayer() )
 {
 return;
 }
 
 if ( IsOpened() )
 {
 // Close UI Scene Editor Menu
 GetGame().GetUIManager().Back();
 }
 else
 {
 // Open UI Scene Editor Menu
 GetGame().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
 GetGame().GetInput().ChangeGameFocus(-1);
 
 // Disable Cursor
 GetGame().GetUIManager().ShowUICursor(false);
 
 if( GetGame().GetUIManager().GetMenu() )
 GetGame().GetUIManager().GetMenu().OnHide();
 }
 
 //==========================================
 // FreeCameraControlDisable
 //==========================================
 void FreeCameraControlDisable()
 {
 // Disable Camera control
 GetGame().GetInput().ChangeGameFocus(1);
 
 // Enable Cursor
 GetGame().GetUIManager().ShowUICursor(true);
 
 if( GetGame().GetUIManager().GetMenu() )
 GetGame().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 ( !(GetGame().IsMultiplayer() && GetGame().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() == GetGame().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";
 
 GetGame().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() != GetGame().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 ( GetGame().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 = GetGame().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";
 }
}