# MouseOrbitImproved camera distance seemingly inverted

I’m currently working on a game prototype where the camera is controlled by the commonly used MouseOrbitImproved script, however I’ve run into a problem concerning the camera’s distance to the player when the player is approaching a surface.

It would seem that the calculation for the collision distance is inverted, I’ll explain.
When the camera is in-between the player and a wall,
wall|__[camera]---------(player)

if the player moves towards the wall, the moment the wall comes within the same distance as the camera, the camera zooms in on the player.
wall|_______ [camera]-(player)

However, the closer the player gets to the wall, the further away from the player the camera positions itself.
wall|__[camera]----(player)

This leads to the camera clipping through walls and other geometry where it is undesired.
[camera]–wall|(player)

The MouseOrbitImproved C# code:

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

public class MouseOrbitImproved : MonoBehaviour
{

public Transform target;
public float distance = 5.0f;
public float xSpeed = 120.0f;
public float ySpeed = 120.0f;

public float yMinLimit = -20f;
public float yMaxLimit = 80f;

//public float distanceMin = .5f;
//public float distanceMax = 15f;

private Rigidbody rigidbody;

float x = 0.0f;
float y = 0.0f;

// Use this for initialization
void Start()
{
Vector3 angles = transform.eulerAngles;
x = angles.y;
y = angles.x;

rigidbody = GetComponent<Rigidbody>();

// Make the rigid body not change rotation
if (rigidbody != null)
{
rigidbody.freezeRotation = true;
}
}

void LateUpdate()
{
if (target)
{
x += Input.GetAxis("Mouse X") * xSpeed * distance * 0.02f;
y -= Input.GetAxis("Mouse Y") * ySpeed * 0.02f;

y = ClampAngle(y, yMinLimit, yMaxLimit);

Quaternion rotation = Quaternion.Euler(y, x, 0);

//distance = Mathf.Clamp(distance - Input.GetAxis("Mouse ScrollWheel") * 5, distanceMin, distanceMax);
float dst = distance;
RaycastHit hit;
if (Physics.Linecast(target.position, rotation * new Vector3(0f, 0f, -distance) + target.position, out hit))
{
dst -= hit.distance;
}
Vector3 negDistance = new Vector3(0.0f, 0.0f, -dst);
Vector3 position = rotation * negDistance + target.position;
// where the problem likely occurs

transform.rotation = rotation;
transform.position = position;
}
}

public static float ClampAngle(float angle, float min, float max)
{
if (angle < -360F)
angle += 360F;
if (angle > 360F)
angle -= 360F;
return Mathf.Clamp(angle, min, max);
}
}
``````

What i’m looking for is a possible solution or help to pinpoint the problem in this code.

While waiting for question verification i actually found a way around this problem by using the raycast’s RaycastHit.point to set the cameras position if the raycast hit a surface. However, this still caused some serious clipping for the camera and would allow the player to look through walls. My next step was to prevent camera clipping as far as possible, and i did so using a lerp between the camera target and the RaycastHit.point in order to place the camera slightly above the surface.

In the game I’m working on the world contains a lot of geometry of different sizes, for example, a forest full of thin trees, and a rocky cliff face. The way the camera worked at this point was slightly seizure inducing while running through the forest, since the camera continued to change position whenever a tree got in between the camera and the player, but if the player approaches a large rock wall the camera still needs to behave this way. By using a Transform.Comparetag() check in the raycast I’m able to tag the geometry i want to block the camera so that it behaves this way only with them, but ignores all other collisions.

So, technically I’ve made an Improved MouseOrbitImproved, and i’ll post the code here as soon as I’ve commented it properly.