Caméra TPS sur une planéte, besoin d'aide !

[Charmimolette]

Salut a tous =)

pour faire simple, j'ai suivis le tutoriel d'un youtuber pour crée une Caméra vue FPS en gravitant autour d'une planète et tout marche très bien. mais problème étant, j'aimerais bien le faire en TPS moi =/

voici les Script du système de FPS et gravitation autour de planète = https://github.com/SebLague/Spherical-G ... f589e0fee5

je crois pas que ce soit si dur que sa a faire, juste quelque modif par-ci par la ... je n'ai pas trouver de vidéos tuto qui donnaient et vue TPS et gravitation autour de planète Alor je suis venus réclamer votre aide les amis =) merci d'avance

[Zhass]

Salut,

Je comprend pas trop, une caméra TPS sur une planète ?? ^^ Une caméra qui tourne autour d'une planète ?

Parce que pour une caméra TPS, je te conseil ce tuto :

https://www.youtube.com/watch?v=sNmeK3qK7oA

Il explique très bien comment réaliser une caméra TPS confortable (en anglais par contre)



EDIT : je viens de voir que c'est du même youtubeur, désolé ^^ Mais en tout cas je te conseil son tuto sur le TPS c'est ce que tu cherches je pense

Mais du coup que ce soit FPS ou TPS je sais pas si ça change grand choses ? pour marcher autour de la planète c'est avec le RigidBody qu'il fait ça non ? du coup tu peux passer de FPS à TPS normalement je pense

[Greg]

Bonjour,
peut-être (si j'ai compris...) est-ce les fonctions RotateAround et LookAt qui t'intéresse?

Dans ce cas, il y a de nombreux topics existant sur le net comme par exemple ici .

[Charmimolette]

Oh merci bien de votre aide c'est sympa je pensait que personne n'allait me répondre

et oui en effet j'ai une vue fps capable de tourner autour d'une planéte MAIS j'ai aussi l'autre tutoriel pour la caméra TPS qui marche super bien (Mais sans pouvoir tourner autour d'une planéte) et j'aurais juste voulus savoir comment fusionner les 2 quoi ...

[Greg]

Alors...

bien que tu puisses de te servir de tes scripts 'FPS' et 'TPS' comme base, cela correspond à un contexte et une utilisation spécifique qui ne semble pas être les tiens...
A ce titre, tu devrais te renseigner sur la définition de FPS et TPS parce qu'il semble que l'utilisation faite ici semble impropre.

Donc en faite, tu veux simplement une caméra qui tourne autour d'une planète en la regardant?
Ce n'est pas très dur et c'est un bon exercice. Sers toi des conseils que l'on t'as fournit et si tu bloques, postes nous le bout de code sur lequel tu travailles et nous essayerons de t'éclairer de tes erreurs.

[Charmimolette]

mince je n'ai peut être pas été claire sur ce coup-ci c'est de ma faute x(

je parle bien d'un personnage qui bouge SUR une planète (donc qui a comme centre de gravités la planète).

bon le 'personnage' n'est qu'un cylindre pour l'instant, mais le problème est que la vue est en FPS (l'on ne voit pas le personnage, c'est du fps quoi) et je voudrais simplement que la vue du personnage soit en TPS (qu'on puisse le voir de dos et pouvoir tourner autour de lui comme dans n'importe quel tps)

voici le script de la vue FPS qui fonctionne quand tu marche autour d'une planète =

DONC le 'Gravity Body' posés sur le cylindre =

Code : Tout sélectionner

using UnityEngine; 
using System.Collections; 

[RequireComponent (typeof (Rigidbody))] 

public class GravityBody : MonoBehaviour
{ 

	GravityAttractor planet; 
Rigidbody rigidbody; 

	void Awake()
    {
        planet = GameObject.FindGameObjectWithTag("Planet").GetComponent<GravityAttractor>();
        rigidbody = GetComponent<Rigidbody>();

             // Disable rigidbody gravity and rotation as this is simulated in GravityAttractor script 
        rigidbody.useGravity = false;
        rigidbody.constraints = RigidbodyConstraints.FreezeRotation;
      } 


	void FixedUpdate()
    {
              // Allow this body to be influenced by planet's gravity 
        planet.Attract(rigidbody);
      } 


}

ET le gravity attractor posés sur la planéte =

Code : Tout sélectionner

using UnityEngine; 
using System.Collections; 

public class GravityAttractor : MonoBehaviour
{ 

	public float gravity = -9.8f; 
	public void Attract(Rigidbody body)
    {
        Vector3 gravityUp = (body.position - transform.position).normalized;
        Vector3 localUp = body.transform.up;

          // Apply downwards gravity to body 
        body.AddForce(gravityUp * gravity);

              // Allign bodies up axis with the centre of planet 
        body.rotation = Quaternion.FromToRotation(localUp, gravityUp) * body.rotation;
           }   
}

ET sinon, Voici mon autres script de personnage en vue TPS qui fonctionne très bien mais sans système de gravitations autour d'une planète (qui est exactement le même que celui de ton tutoriel zhass !). donc celui-ci a tout ce qui faut ( i compris un vrais personnage avec des animation

Pour le 'ThirdPersonCamera' ! =

Code : Tout sélectionner

using UnityEngine;
using System.Collections;

public class ThirdPersonCamera : MonoBehaviour
{

    public bool lockCursor;
    public float mouseSensitivity = 10;
    public Transform target;
    public float dstFromTarget = 2;
    public Vector2 pitchMinMax = new Vector2(-45, 85);

    public float rotationSmoothTime = .12f;
    Vector3 RotationSmoothVelocity;
    Vector3 currentRotation;

    float yaw;
    float pitch;

    void Start()
    {
        if (lockCursor)
        {

            Cursor.lockState = CursorLockMode.Locked;
            Cursor.visible = false;
        }

    }

    void LateUpdate()
    {
        yaw += Input.GetAxis("Mouse X") * mouseSensitivity;
        pitch -= Input.GetAxis("Mouse Y") * mouseSensitivity;
        pitch = Mathf.Clamp(pitch, pitchMinMax.x, pitchMinMax.y);

        currentRotation = Vector3.SmoothDamp(currentRotation, new Vector3(pitch, yaw), ref RotationSmoothVelocity, rotationSmoothTime);
        transform.eulerAngles = currentRotation;

        transform.position = target.position - transform.forward * dstFromTarget;

    }

}

ET pour le 'player controller' =

Code : Tout sélectionner

using UnityEngine;
using System.Collections;

public class PlayerController : MonoBehaviour {

    public float walkspeed = 2;
    public float runSpeed = 6;
    public float gravity = -12;

    public float turnSmoothTime = 0.2f;
    float turnSmoothVelocity;

    public float speedSmoothTime = 0.1f;
    float speedSmoothVelocity;
    float currentSpeed;
    float velocityY;

    Animator animator;
    Transform cameraT;
    CharacterController controller; 

    void Start() {
        animator = GetComponent<Animator>();
        cameraT = Camera.main.transform;
        controller = GetComponent<CharacterController> ();
    }

    void Update() {

        Vector2 input = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
        Vector2 inputDir = input.normalized;

        if (inputDir != Vector2.zero) {
            float targetRotation = Mathf.Atan2(inputDir.x, inputDir.y) * Mathf.Rad2Deg + cameraT.eulerAngles.y;
            transform.eulerAngles = Vector3.up * Mathf.SmoothDampAngle(transform.eulerAngles.y, targetRotation, ref turnSmoothVelocity, turnSmoothTime);

        }

        bool running = Input.GetKey(KeyCode.LeftShift);
        float targetSpeed = ((running) ? runSpeed : walkspeed) * inputDir.magnitude;
        currentSpeed = Mathf.SmoothDamp(currentSpeed, targetSpeed, ref speedSmoothVelocity, speedSmoothTime);

        velocityY += Time.deltaTime * gravity;
        Vector3 velocity = transform.forward * currentSpeed + Vector3.up * velocityY;

        controller. Move(velocity * Time.deltaTime);
        currentSpeed = new Vector2(controller.velocity.x, controller.velocity.z).magnitude;

        if (controller.isGrounded) {
            velocityY = 0;
        }

        float animationSpeedPercent = ((running) ? currentSpeed / runSpeed : currentSpeed / walkspeed * .5f);
            animator.SetFloat("speedPercent", animationSpeedPercent, speedSmoothTime, Time.deltaTime);

        }
  }

Je voudrais juste fusionner tout ces script afin de faire un personnage en Vue TPS Capable de marcher autour d'une planète avec une caméra qui fonctionne

mais merci de votre aide sinon

Les balises code SVP
Merci de lire la Netiquette.

[Greg]

ok, un Mario Galaxy Like! ^^

Le réglage et paramétrage d'une caméra est une vrai plaie, je te l'accorde.
Ceci est essentiellement du au faite des multiples approches et possibilités en fonction du résultat voulu.

Que se passe t'il si tu met ton script tps en place dans ton approche actuelle?

Pour 'comprendre' plus en détail, tu peux démarrer un nouveau projet de test et importer le Standard Assets Package.

Mais... en théorie, je pense que si tu vas dans Menu > Assets > Import Package > Camera
Il y a 5 ou 6 scripts de base Unity dont un qui devrait marché je crois direct pour toi mais je sais plus son nom. ^^

Tu peux aussi regrarder dans Menu > Assets > Import Package > Characters > ThirdPersonController

Les scripts issus du staff d'Unity sont rigoureusement commentés et possèdent de nombreux attributs publiques afin de pouvoir les adapter sans trop se 'salir les mains'...

Ne te décourages pas, ça va être difficile mais c'est une grosse partie du moteur de ton jeu.

[Charmimolette]

si je met le script TPS sur FPS sa me met bien une caméra TPS mais avec des angles de rotations erronés (car ceux du monde et non pas de la planéte)

enfaite je pense que c'est juste un truc a échanger mais je sait pas quoi

je te remercie de ton aide ^^ je vais voir sa et non sa n'est pas un mario galaxy like ^^ mais merci en tout cas !

[ZJP]

Tu peux aussi regrarder dans Menu > Assets > Import Package > Characters > ThirdPersonController

Le "ThirdPersonController" standard ne fonctionnera pas, ainsi que TOUT scripts ( Frameworks, Tools, Shaders, Physique -avec son Wheel Collider- ) etc etc.. qui fait référence à l'AXE Y Global. 99% des outils que tu utiliseras pour ce projet devra être -au pire- fait from scratch au mieux être réécris en partie.

Par exemple, on pourrait penser que pour faire évoluer un véhicule à la surface du monde c'est facile : il suffirait juste de décocher le "Apply Gravity" du RigidBody, puis de coller des scripts de gravité et paf, c'est bon. Bin non !!!. PB de wheel collider... Des soucis comme cela, tu en rencontres des tonnes.

Bienvenu dans mon..."cauchemar" Moonnien.

A ce propos, les scripts de gravités que tu utilises, s'ils ont l'avantage d'être ultra-connus (je suis passé par là aussi) sont toutefois loin d'être performants : tout dépendra du nombre de persos/npc/entités qu'il y aura à la surface de ton monde, ainsi que la dimension (diamètre) de celui-ci.
Extrait de ma gestion de la gravité. Diametre du monde 36000, Superficie 160000 terrains de foot.

Code : Tout sélectionner

	// ************************************************************************************* Gravité / Deplacement ****
	// ****************************************************************************************************************
	void MoveOnGround()	{
		if (Physics.Raycast(MarqueurAnimBodyPos.position, -this.transform.up, out hitRAYCAST, 2.0f)) rigBody.MovePosition(hitRAYCAST.point);
	}

	public void UpdateMoveGravity() {

		if (!isMoving && alreadyUpdated) return;
		alreadyUpdated = false;
		gravityUp = (transform.position - centrePlanete).normalized;

		// Layer  8 = Mobile
		// Layer  9 = Plaine
		// Layer 10 = Elevation
		// Layer 11 = Structure/Base

		ActualLayer = 9; // Plaine
		isTimeToCheckGRAV = !isTimeToCheckGRAV;
		if (isTimeToCheckGRAV) Altitude = Vector3.Distance(centrePlanete, transform.position) - RayonPlanet; // Lourd!!!. 1/2
//		Debug.Log(Altitude);

		if ( Altitude > RayonPlanetAjust) ActualLayer = 10;
		if (isMoving && ActualLayer == 9 ) {
			tempoPos = ((gravityUp * RayonPlanet + centrePlanete) + transform.forward * (newSpeed * v));
			rigBody.MovePosition(tempoPos);
		}
		if (isMoving && ActualLayer == 10 )	{
			tempoPos = rigBody.position + (transform.forward * (newSpeed * v));
			rigBody.MovePosition(tempoPos);
			if (isTimeToCheckGRAV) rigBody.AddForce(gravityUp * m_Gravity); // Lourd!!!. 1/2
		}

		// Rotation
		rotateMe++;
		if (rotateMe < doRotate) return;  // Lourd !!! 1/300
		rigBody.rotation = Quaternion.FromToRotation(transform.up, gravityUp) * transform.rotation;
		alreadyUpdated = true;
		rotateMe = 0;
	}
	// ************************************************************************************* Gravité / Deplacement ****
	// ****************************************************************************************************************

Il faut les voir comme un début, mais honnêtement ce genre de projet demande mieux que de simples connaissances en script : codeur fortement recommandé.

Une des nombreuses discutions sur le sujet : viewtopic.php?f=7&t=6130
viewtopic.php?f=2&t=13472&p=100035
viewtopic.php?f=7&t=9457&p=73020

[EdLooping]

Bonjour à tous !

J'aimerais faire un RTS sur un monde sphérique, une planète, et non sur un plan.
J'ai donc le même problème.

En effet aucun script tout fait ne fonctionne, ni dans les assets de base ni sur le net, en tout cas j'ai pas trouvé...

J'essaie donc de la coder. Pour info je débute sur Unity. J'programme parfaitement dans des petits langages comme le basic mais je débute en C# et javascript. Par ailleurs, je précise que j'apprends davantage le c# que le java. Pk ? Je sais pas, j'ai l'impression qu'il est plus utilisé que le java et qu'on trouve plus d'infos dessus sur le net que le java. Tout ça pour dire que bien que j'aie de bonnes connaissances en basic, évitez de parler chinois en c# ou java pcq je débute !

Vous allez me dire "Tu débutes et tu veux faire un RTS, qui plus est sur un monde sphérique ? Laisse tomber, trop compliqué !".
Ok je me rends bien compte que sur un monde sphérique 99% des scripts ne fonctionneront pas et qu'il va falloir tout coder soi-même, mais je ne suis pas limité dans le temps, et j'me dis surtout que d'ici quelques mois, je saurai suffisamment bien programmé pour y arriver.

Bref on s'en fout de ma vie ! Passons au vive du sujet !

Le but est donc de faire une RTS caméra avec les mêmes fonctions que celle qui suit mais sur un monde sphérique.

Pour vous expliquer mon problème, je vais vous dire c'que j'ai fait (pas grand chose pour le moment... )

Tout d'abord on place une sphère assez grande qui sera ma planète. Pour le moment pas besoin de mettre les scripts de gravité sphérique, la caméra n'en aura pas besoin. Je place ma sphère aux coordonnées (0,0,0).

Ma première étape est de déterminer un angle en fonction d'où se trouve ma camera par rapport au centre de ma planète.
Je le fais dans un premier plan pour commencer qu'on va appelé Plan X dans lequel les axes Y et Z sont coplanaires.

On détermine donc un angle à partir de 3 point selon la formule suivante :

cos a = (Xa*Xb + Ya*Yb + Za*Zb) / sqrt((Xa² + Ya² + Za²) * (Xb² + Yb² + Zb²))

Mes 3 points seront :
- Le pôle nord (0, PlanetRayon, 0) où PlanetRayon représente bien entendu le rayon de ma planète.
- Le centre de la planète (0, 0, 0)
- Et ma caméra dont les coordonées vont être variables (x, y, z).

Bon la formule générale donne un cosinus mais je me suis aperçu que ça fonctionne avec un sinus...

On remplace les valeurs, y a bcp de zéro donc on simplifie tout et on obtient en code :

Code : Tout sélectionner

    void Update()
    {
            PlanetAngle = Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg;
    }

Si on fait un Debug.Log(PlanetAngle); et qu'on s'amuse à bouger la caméra autour de la planète, on trouve ceci :
- Au pôle nord : PlanetAngle = 90
- Au pôle sud : PlanetAngle = -90
- Au pôle est : PlanetAngle = 0
- Au pôle ouest : PlanetAngle = 0

Cet angle va représenter l'angle de base de ma caméra.
Du coup comme je veux que ma caméra soit horizontale au pôle nord et inclinée de 90 aux pôles est et ouest je rajoute -90 dans mon code :

Code : Tout sélectionner

    void Update()
    {
            PlanetAngle = Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90 ;
     }

A ce moment j'obtiens :
- Au pôle nord : PlanetAngle = 0
- Au pôle sud : PlanetAngle = -180
- Au pôle est : PlanetAngle = -90
- Au pôle ouest : PlanetAngle = -90

A ce moment-là j'ai un soucis au niveau de mes pôles est et ouest puisqu'ils sont les deux égaux à -90, or j'en veux un à +90 et l'autre à -90.
J'écris donc ceci dans mon code :

Code : Tout sélectionner

    void Update()
    {
    
        if (transform.position.z >= 0)
        {
            PlanetAngleX = -(Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90);
        }
        else
        {
            PlanetAngleX = Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90;
        }     
        
    }   

A ce moment-là, si on relance le programme et qu'on bouge la caméra autour de la planète on obtient bien :
- Au pôle nord : PlanetAngle = 0
- Au pôle sud : PlanetAngle = +180 ou -180
- Au pôle est : PlanetAngle = +90
- Au pôle ouest : PlanetAngle = -90

Et là on se dit bingo, si on applique cet angle à la caméra elle va bien s'incliner tout autour de la planète, mais non !
On va se heurter à un problème qui est MON PROBLEME, celui que je cherche à résoudre.

Bon pour appliquer cet angle à la caméra j'ai écris :

Code : Tout sélectionner

    void Update()
    {
    
        if (transform.position.z >= 0)
        {
            PlanetAngleX = -(Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90);
        }
        else
        {
            PlanetAngleX = Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90;
        }        
                
        transform.Rotate(new Vector3(PlanetAngleX - transform.rotation.eulerAngles.x, 0, 0));
        
    }

A ce moment-là on teste en plaçant la caméra au pôle nord et on s'aperçoit que ça fonctionne très bien dans l'hémisphère nord mais que dès qu'on passe dans l'hémisphère sud, la caméra se met à tourner sur elle-même.

J'ai cherché le problème et me suis rendu compte que lorsque l'angle de la caméra dépasse les 90°, Unity va changer tout seul les rotations en x, y et z !!!

Je m'explique. Si on désactive le script, on en a pas besoin pour comprendre et qu'on met dans la caméra directement dans l'inspector un angle de plus de 90°, par exemple disons 120° en x, 0 en y et 0 en z, et qu'on démarre le programme, on s'aperçoit que Unity transforme ces valeurs en (60, 180, 180) !!!
Pourquoi Unity me met (60, 180, 180) plutôt que de me laisser (120, 0, 0) ???

Du coup j'ai bidouiller dans mon code et j'ai mis ceci :

Code : Tout sélectionner

    void Update()
    {
    
        if (transform.position.z >= 0)
        {
            PlanetAngleX = -(Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90);
        }
        else
        {
            PlanetAngleX = Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90;
        }        
                
        if (transform.position.y >= 0)
        {
            transform.Rotate(new Vector3(PlanetAngleX - transform.rotation.eulerAngles.x, 0, 0));
        }
        else
        {
            transform.Rotate(new Vector3(360 - PlanetAngleX - transform.rotation.eulerAngles.x, 180, 180));
        }
        
    }

A ce moment-là ça résoud le problème mais hélas que temporairement. Si on teste le programme en état on arrive parfaitement avec la caméra à faire le tour de la planète. Mais pour le moment seulement dans le plan X.

J'ai donc fait la même chose dans le plan Z qui lui est perpendiculaire. Tout d'abord je me rends compte qu'il y a quelques différences entre les 2 plans. Des différences au signe près, encore je peux comprendre, mais ce qui est bizarre c'est que je vais pas avoir dans le plan Z ce problème dans l'hémisphère sud... Bizarre. J'obtiens donc le code suivant dans le plan Z.

Code : Tout sélectionner

    void Update()
    {
    
        if (transform.position.x >= 0)
        {
            PlanetAngleZ = Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.x * transform.position.x) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90;
        }
        else
        {
            PlanetAngleZ = -(Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.x * transform.position.x) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90);
        }


        if (transform.position.y >= 0)
        {
            transform.Rotate(new Vector3(0, 0, PlanetAngleZ - transform.rotation.eulerAngles.z));
        }
        else
        {
            transform.Rotate(new Vector3(0, 0, PlanetAngleZ - transform.rotation.eulerAngles.z));
        }
        
    }

Bon répéter la même rotation dans l'hémisphère nord (transform.position.y >= 0) et l'hémisphère sud, c'est inutile, c'est juste pour vous montrer que j'ai pas eu besoin de le changer contrairement au plan X.
Si on teste indépendamment dans le plan X et dans le plan Z ça fonctionne parfaitement.
Je me suis donc dis qu'en réunissant les deux, ma caméra pourrait pivoter correctement tout autour de ma planète. Bon peut-être qu'il faudra rajouter des cosinus et/ou sinus pour passer d'un plan à un autre mais j'en suis même pas là pcq quand je réunis mes 2 plans et que je teste dans le plan X qui fonctionnait très bien et bien le plan Z va venir interagir avce et ma caméra va se remettre à tourner dans tous les sens dans l'hémisphère sud ?!!
J'en déduis donc que c'est le même problème que tout à l'heure, Unity va changer mes valeurs de rotation x, y, et z, et là où dans le plan X je devrais avoir une rotation uniquement en z et dans le plan Z une rotation seulement en x, Unity va me mettre des valeurs de rotation en x,y,z et par conséquent mes 2 plans vont interagir l'un avec l'autre et la caméra va se mettre à tourner.

J'ai essayer de bidouiller mes valeurs mais rien y fait. Si quelqu'un peut me dire pourquoi Unity fait ça tout seul et si quelqu'un à la solution ce serait sympa de m'éclairer !!

Je vous mets mon code en entier cette fois avec les variables. J'ai rajouté juste le fait d'avancer avec la flèche Up. Faites une sphère, mettez la caméra au pôle nord.
Faites 2 scripts. Un pour la sphere, l'autre pour la camera.
Appelez le script de la sphere "PlanetRotation" et mettez ceci dans le script :

Code : Tout sélectionner

    public int Rayon = 100;

A la place de 100, vous devez bien indiquer le rayon de votre sphere.

Dans le script de la caméra que vous appelerez comme vous voulez mettez :

Code : Tout sélectionner

    [Header("Planet")]
    public GameObject Planet;
    private PlanetRotation PlanetRotationScrpit;
    private int PlanetRayon;
    private float PlanetAngleX;
    private float PlanetAngleZ;


    [Header("Translation")]
    public int VitesseTranslationClavier = 20;
    //public int VitesseTranslationSouris = 20;

    private float PlanetAngleX_z;
    private float PlanetAngleX_y;


    // Use this for initialization
    void Start()
    {

        PlanetRotationScrpit = Planet.GetComponent<PlanetRotation>();
        PlanetRayon = PlanetRotationScrpit.Rayon;

    }

    // Update is called once per frame
    void Update()
    {


        #region Détermination PLanetAngle

        #region Axe X

        if (transform.position.z >= 0)
        {
            PlanetAngleX = -(Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90);
        }
        else
        {
            PlanetAngleX = Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.z * transform.position.z) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90;
        }

        #endregion

        #region Axe Z

        if (transform.position.x >= 0)
        {
            PlanetAngleZ = Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.x * transform.position.x) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90;
        }
        else
        {
            PlanetAngleZ = -(Mathf.Asin((PlanetRayon * transform.position.y) / Mathf.Sqrt((PlanetRayon * PlanetRayon) * ((transform.position.x * transform.position.x) + (transform.position.y * transform.position.y)))) * Mathf.Rad2Deg - 90);
        }

        #endregion

        #endregion


        if (transform.position.y >= 0)
        {
            transform.Rotate(new Vector3(PlanetAngleX - transform.rotation.eulerAngles.x, 0, 0));
            transform.Rotate(new Vector3(0, 0, PlanetAngleZ - transform.rotation.eulerAngles.z));
        }
        else
        {
            transform.Rotate(new Vector3(360 - PlanetAngleX - transform.rotation.eulerAngles.x, 180, 180));
            transform.Rotate(new Vector3(0, 0, PlanetAngleZ - transform.rotation.eulerAngles.z));
        }

        
        if (Input.GetKey(KeyCode.UpArrow))
        {
            PlanetAngleX_z = Mathf.Cos(PlanetAngleX * Mathf.Deg2Rad);
            PlanetAngleX_y = Mathf.Sin(PlanetAngleX * Mathf.Deg2Rad);
            transform.position += new Vector3(0, -PlanetAngleX_y * VitesseTranslationClavier, PlanetAngleX_z * VitesseTranslationClavier) * Time.deltaTime;
        }       

    }

Dans l'inspector de la caméra, au niveau du script, indiquez bien que la planète correspond à la sphère, lancez le programme, appuyez sur la flèche Up pour avancer et voyez ce qui se passe quand on arrive dans l'hémisphère sud.

Merci de votre aide, j'espère avoir suffisamment bien expliqué mon problème.