using UnityEngine;
using System.Collections;
using System.Collections.Generic;

public class PlanetEditor : MonoBehaviour
{
          protected static Transform editorTransform;

          // MESH
          private Mesh mesh;
          private Vector3[] points;
          private Vector3[] vertices;
          private int[] triangles;
          private Vector2[] uvs;

          public float depthLimit = 25;

          public float brushStrength = 0.1f;
          public float brushSize = 1;

          void Start()
          {
              editorTransform = transform;
              mesh = GetComponent<MeshFilter>().mesh;
              Spheriphy();
          }

          void HitCollision(Vector3 colPoint)
          {
              LowerPoint(DefineBrushSize(colPoint), brushStrength);
          }

          void Spheriphy()
          {
              vertices = mesh.vertices;
              triangles = mesh.triangles;
              uvs = mesh.uv;

              mesh.Clear();
              mesh.vertices = vertices;
              mesh.triangles = triangles;
              mesh.uv = uvs;
              mesh.Optimize();
              mesh.RecalculateNormals();
              points = mesh.vertices;

              gameObject.AddComponent<MeshCollider>();
          }

          Vector3 FindNearestPoint(Vector3 point)
          {
              Vector3 nearestPoint = new Vector3();
              float lastDistance = 9999999;

              for (int i = 0; i < points.Length; i++)
              {
                  float distance = Vector3.Distance(point, points[i]);

                  if (distance < lastDistance)
                  {
                      lastDistance = distance;
                      nearestPoint = points[i];
                  }
              }
              return nearestPoint;
          }

          public Vector3[] DefineBrushSize(Vector3 point)
          {
              List<Vector3> brushPoints = new List<Vector3>();
              Vector3 nearestPoint = FindNearestPoint(point);

              for (int i = 0; i < points.Length; i++)
              {
                  float distance = Vector3.Distance(nearestPoint, points[i]);

                  if (distance <= brushSize)
                  {
                      brushPoints.Add(points[i]);
                  }
              }
              return brushPoints.ToArray();
          }

          public void LowerPoint(Vector3[] editPoints, float strength)
          {
              for (int z = 0; z < editPoints.Length; z++)
              {
                  for (int i = 0; i < points.Length; i++)
                  {
                      if (points[i] == editPoints[z])
                      {
                          float pointDistance = Vector3.Distance(points[i], editorTransform.position);

                          if (pointDistance > depthLimit)
                          {
                    for (int v = 0; v < editPoints.Length; v++)
                    {
                        points[i] = points[i].normalized * (pointDistance - strength);
                    }
                          }
                      }
                  }
              }
              UpdateMesh();
          }

          public void UpdateMesh()
          {
              mesh.Clear();
              mesh.vertices = points;
              mesh.triangles = triangles;
              mesh.uv = uvs;
              mesh.Optimize();
              mesh.RecalculateNormals();
              points = mesh.vertices;
          }
}

                        
Vector3 данные_с_джойстика = new Vector3(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), 0) * допустимое_расстояние;
                        
//мы знаем, что нужный вектор это Camera.main.transform.up

transform.position = позиция_включающая_данные_с_джойстика_относительно_Camera.main.transform.up;

Vector3 данные_с_джойстика = new Vector3(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"), 0) * допустимое_расстояние;

transform.position = начальная_позиция + (данные_с_джойстика.y * Camera.main.transform.up) + (данные_с_джойстика.x * Camera.main.transform.right);

using UnityEngine;
using UnityEngine.EventSystems;

public class VJoystick : MonoBehaviour, IPointerUpHandler, IPointerDownHandler, IDragHandler
{

           public int MovementRange = 100;

           [HideInInspector] public static float x;
           [HideInInspector] public static float y;

           public enum AxisOption
           {                    // Options for which axes to use                          
               Both,                    // Use both
               OnlyHorizontal,                    // Only horizontal
               OnlyVertical                    // Only vertical
           }

           public AxisOption axesToUse = AxisOption.Both;   // The options for the axes that the still will use
                  
           private Vector3 startPos;
           private bool useX;                    // Toggle for using the x axis
           private bool useY;                    // Toggle for using the Y axis

           void Start()
           {

               startPos = transform.position;

               // set axes to use
               useX = (axesToUse == AxisOption.Both || axesToUse == AxisOption.OnlyHorizontal);
               useY = (axesToUse == AxisOption.Both || axesToUse == AxisOption.OnlyVertical);

           }

           private void UpdateVirtualAxes(Vector3 value)
           {

               var delta = startPos - value;
               delta.y = -delta.y;
               delta /= MovementRange;
               if (useX)
                   x = -delta.x;

               if (useY)
                   y = delta.y;

           }

           public void OnDrag(PointerEventData data)
           {

               Vector3 newPos = Vector3.zero;

               if (useX)
               {
                   int delta = (int)(data.position.x - startPos.x);
                   delta = Mathf.Clamp(delta, -MovementRange, MovementRange);
                   newPos.x = delta;
               }

               if (useY)
               {
                   int delta = (int)(data.position.y - startPos.y);
                   delta = Mathf.Clamp(delta, -MovementRange, MovementRange);
                   newPos.y = delta;
               }
               transform.position = new Vector3(startPos.x + newPos.x, startPos.y + newPos.y, startPos.z + newPos.z);
               UpdateVirtualAxes(transform.position);
           }

           public void OnPointerUp(PointerEventData data)
           {
               transform.position = startPos;
               UpdateVirtualAxes(startPos);
           }

           public void OnPointerDown(PointerEventData data)
           {
           }

}