Rolling ball spherical terrain relative controls - C#

Ok I takes everything from the beginning.

I have a camera following my player (a rolling ball) around a planet with a gravity script. Everything works fine, except for the controls. Depending on where I am on the planet directions are reversed, they do anything ...

Below the script controller. I tried all full of things, nothing works. The controls are not related to the camera .... How to do that?

Thanks for your help.

 using UnityEngine;
 using System.Collections;
 using UnityStandardAssets.CrossPlatformInput;
 
 public class PlayerController : MonoBehaviour
 {
 
     PhotonView view;
     public Ball ball;
 
     private Transform cam; // A reference to the main camera in the scenes transform
     private Vector3 camForward; // The current forward direction of the camera
     private bool jump; // whether the jump button is currently pressed
     private Vector3 move; // the world-relative desired move direction, calculated from the camForward and user input.
 
     private void Awake()
     {
         // Set up the reference.
         ball = GetComponent<Ball>();
 
         // get the transform of the main camera
         if (Camera.main != null)
         {
             cam = Camera.main.transform;
 
             //cam = cam.transform;
         }
         else
         {
             Debug.LogWarning(
                 "Warning: no main camera found. Ball needs a Camera tagged \"MainCamera\", for camera-relative controls.");
             // we use world-relative controls in this case, which may not be what the user wants, but hey, we warned them!
         }
     }
 
     // Use this for initialization
     void Start()
     {
         view = GetComponent<PhotonView>();
     }
 
     // Update is called once per frame
     void Update()
     {
         if (view.isMine)
         {
             // Get the axis and jump input.
 
             float h = CrossPlatformInputManager.GetAxis("Horizontal");
             float v = CrossPlatformInputManager.GetAxis("Vertical");
             jump = CrossPlatformInputManager.GetButton("Jump");
 
 
             // calculate move direction
             if (cam != null)
             {
                 // calculate camera relative direction to move:
 
 
 
                 camForward = Vector3.Scale(cam.forward, new Vector3(3, 0, 1)).normalized;
                 move = (v * camForward + h * cam.right).normalized;
                 //move = (v * Vector3.forward + h * Vector3.right).normalized;
             }
             else
             {
                 // we use world-relative directions in the case of no main camera
                 //move = (v * Vector3.forward + h * Vector3.right).normalized;
                 Debug.Log("no camera");
             }
 
             Vector3 movement = new Vector3(h, 0.0f, v);
             movement = Camera.main.transform.TransformDirection(movement);
 
             ball.Move(move, jump);
             jump = false;
         }
 
     }
 
     void FixedUpdate()
     {
        
 
     }
 }
 

And The ball script :

 using System;
 using UnityEngine;
 using UnityStandardAssets.CrossPlatformInput;
 
 public class Ball : MonoBehaviour
     {
         [SerializeField]
         private float m_MovePower = 5; // The force added to the ball to move it.
         [SerializeField]
         private bool m_UseTorque = false; // Whether or not to use torque to move the ball.
         [SerializeField]
         private float m_MaxAngularVelocity = 25; // The maximum velocity the ball can rotate at.
         [SerializeField]
         private float m_JumpPower = 2; // The force added to the ball when it jumps.
 
         private const float k_GroundRayLength = 1f; // The length of the ray to check if the ball is grounded.
         private Rigidbody m_Rigidbody;
 
 
         private void Start()
         {
             m_Rigidbody = GetComponent<Rigidbody>();
             // Set the maximum angular velocity.
             GetComponent<Rigidbody>().maxAngularVelocity = m_MaxAngularVelocity;
         }
 
 
         public void Move(Vector3 moveDirection, bool jump)
         {
             // If using torque to rotate the ball...
             if (m_UseTorque)
             {
                 // ... add torque around the axis defined by the move direction.
                 m_Rigidbody.AddTorque(new Vector3(moveDirection.z, 0, -moveDirection.x) * m_MovePower);
          
         }
             else
             {
             // Otherwise add force in the move direction.
             
             m_Rigidbody.AddForce(moveDirection * m_MovePower);
             }
 
             // If on the ground and jump is pressed...
             if (Physics.Raycast(transform.position, -Vector3.up, k_GroundRayLength) && jump)
             {
                 // ... add force in upwards.
                 m_Rigidbody.AddForce(Vector3.up * m_JumpPower, ForceMode.Impulse);
             }
         }
     }