Reset camera orbit - can someone please review my code for errors?

Hello, I have been working on this for several days and not getting anywhere. I need to "reset" my camera so that each and every time it is used in a screen it start from its initial position and rotation - as if it has not been orbited at all.

I am following the examples on the forum, setting up position and rotation in start and then calling to these transforms - but nothing is working, it is not resetting - can someone please take a look at my code and let me know what I have missed?

Thanks in advance.

Code (csharp):

1. using UnityEngine;
2. using System.Collections;
3.  
4. /// <summary>
5. /// Adaptation of the standard MouseOrbit script to use the finger drag gesture to rotate the current object using
6. /// the fingers/mouse around a target object
7. /// NOTE: TBInputManager NOT required
8. /// </summary>
9. [AddComponentMenu( "FingerGestures/Toolbox/Misc/DragOrbit" )]
10. public class TBDragOrbitTwo : MonoBehaviour
11. {
12.    
13.     public enum PanMode
14.     {
15.         Disabled,
16.         OneFinger,
17.         TwoFingers
18.     }
19.  
20.     /// <summary>
21.     /// The object to orbit around
22.     /// </summary>
23.     public Transform target;
24.  
25.  
26.     private Vector3 initialTwoposition;//what I need to reset the camera position
27.     private Quaternion initialTworotation;//what I need to reset teh camera rotation
28.    
29.    
30.     public float rotationX = 0F;//X rotation
31.     public float rotationY = 0F;//Y rotation
32.    
33.     /// <summary>
34.     /// Initial camera distance to target
35.     /// </summary>
36.     public float initialDistance = 10.0f;
37.  
38.     /// <summary>
39.     /// Minimum distance between camera and target
40.     /// </summary>
41.     public float minDistance = 1.0f;
42.  
43.     /// <summary>
44.     /// Maximum distance between camera and target
45.     /// </summary>
46.     public float maxDistance = 20.0f;
47.  
48.     /// <summary>
49.     /// Affects horizontal (y-axis) rotation speed
50.     /// </summary>
51.     public float yawSensitivity = 80.0f;
52.  
53.      /// <summary>
54.      /// Keep yaw angle value (horizontal rotation) between minYaw and maxYaw
55.      /// </summary>
56.      public bool clampYawAngle = false;
57.      public float minYaw = 0;
58.      public float maxYaw = 360;
59.  
60.     /// <summary>
61.     /// Affects vertical (X-axis) rotation speed
62.     /// </summary>
63.     public float pitchSensitivity = 80.0f;
64.  
65.     /// <summary>
66.     /// Keep pitch angle value between minPitch and maxPitch?
67.     /// </summary>
68.     public bool clampPitchAngle = true;
69.     public float minPitch = -20;
70.     public float maxPitch = 80;
71.  
72.     /// <summary>
73.     /// Allow the user to affect the orbit distance using the pinch zoom gesture
74.     /// </summary>
75.     public bool allowPinchZoom = true;
76.  
77.     /// <summary>
78.     /// Affects pinch zoom speed
79.     /// </summary>
80.     public float pinchZoomSensitivity = 2.0f;
81.  
82.     /// <summary>
83.     /// Use smooth camera motions?
84.     /// </summary>
85.     public bool smoothMotion = true;
86.     public float smoothZoomSpeed = 3.0f;
87.     public float smoothOrbitSpeed = 4.0f;
88.  
89.     /// <summary>
90.     /// Two-Finger camera panning.
91.     /// Panning will apply an offset to the pivot/camera target point
92.     /// </summary>
93.     public bool allowPanning = false;
94.     public bool invertPanningDirections = false;
95.     public float panningSensitivity = 1.0f;
96.     public Transform panningPlane;  // reference transform used to apply the panning translation (using panningPlane.right and panningPlane.up vectors)
97.     public bool smoothPanning = true;
98.     public float smoothPanningSpeed = 8.0f;
99.     float lastPanTime = 0;
100.  
101.     float distance = 0.0f;
102.     float yaw = 0;
103.     float pitch = 0;
104.  
105.     float idealDistance = 0;
106.     float idealYaw = 0;
107.     float idealPitch = 0;
108.    
109.     /// <summary>
110.     /// Reset Panning
111.     /// </summary>
112.    
113.     Vector3 idealPanOffset = Vector3.zero;
114.     Vector3 panOffset = Vector3.zero;
115.    
116.     public float Distance
117.     {
118.         get { return distance; }
119.     }
120.  
121.     public float IdealDistance
122.     {
123.         get { return idealDistance; }
124.         set { idealDistance = Mathf.Clamp( value, minDistance, maxDistance ); }
125.     }
126.  
127.     public float Yaw
128.     {
129.         get { return yaw; }
130.     }
131.  
132.     public float IdealYaw
133.     {
134.         get { return idealYaw; }
135.         set { idealYaw = clampYawAngle ? ClampAngle( value, minYaw, maxYaw): value ; }
136.     }
137.  
138.     public float Pitch
139.     {
140.         get { return pitch; }
141.     }
142.  
143.     public float IdealPitch
144.     {
145.         get { return idealPitch; }
146.         set { idealPitch = clampPitchAngle ? ClampAngle( value, minPitch, maxPitch ) : value; }
147.     }
148.  
149.     public Vector3 IdealPanOffset
150.     {
151.         get { return idealPanOffset; }
152.         set { idealPanOffset = value; }
153.     }
154.  
155.     public Vector3 PanOffset
156.     {
157.         get { return panOffset; }
158.     }
159.  
160.    void Start()
161.    
162.  
163.     {
164.    
165.    
166.         //Apply();
167.        
168.         if( !panningPlane )
169.             panningPlane = this.transform;
170.  
171.       Vector3 angles = transform.eulerAngles;
172.  
173.        distance = IdealDistance = initialDistance;
174.         yaw = IdealYaw  = angles.y;
175.         pitch = IdealPitch = angles.x;
176.  
177.          //Make the rigid body not change rotation
178.         if( rigidbody )
179.         rigidbody.freezeRotation = true;
180.        
181.         //set the inital position and rotation
182.         initialTwoposition = GameObject.Find("Camera180").transform.localPosition;
183.         initialTworotation = transform.localRotation;
184.    
185.         //call for a reset
186.         rotationX = 0;
187.         rotationY = 0;
188.         ResetCamera();
189.        
190.  
191.         }
192.        
193. //reset the camera
194.    void ResetCamera()
195.    
196. {
197.         transform.localPosition = initialTwoposition;
198.         transform.position = initialTwoposition;
199.        
200.         transform.localRotation = initialTworotation;
201.         print(initialTworotation);
202.        
203.     }
204.    
205.     void OnEnable()
206.     {
207.         FingerGestures.OnDragMove += FingerGestures_OnDragMove;
208.         FingerGestures.OnPinchMove += FingerGestures_OnPinchMove;
209.         FingerGestures.OnTwoFingerDragMove += FingerGestures_OnTwoFingerDragMove;
210.     }
211.        
212.     void OnDisable()
213.     {
214.         FingerGestures.OnDragMove -= FingerGestures_OnDragMove;
215.         FingerGestures.OnPinchMove -= FingerGestures_OnPinchMove;
216.         FingerGestures.OnTwoFingerDragMove -= FingerGestures_OnTwoFingerDragMove;
217.     }
218.  
219.     void FingerGestures_OnDragMove( Vector2 fingerPos, Vector2 delta )
220.     {
221.         // if we panned recently, give a bit of time for all the fingers to lift off before we allow for one-finger drag
222.         if( Time.time - lastPanTime < 0.25f )
223.             return;
224.  
225.         if( target )
226.         {
227.             IdealYaw += delta.x * yawSensitivity * 0.02f;
228.             IdealPitch -= delta.y * pitchSensitivity * 0.02f;
229.         }
230.     }
231.  
232.     void FingerGestures_OnPinchMove( Vector2 fingerPos1, Vector2 fingerPos2, float delta )
233.     {
234.         if( allowPinchZoom )
235.             IdealDistance -= delta * pinchZoomSensitivity;
236.     }
237.  
238.     void FingerGestures_OnTwoFingerDragMove( Vector2 fingerPos, Vector2 delta )
239.     {
240.         if( allowPanning )
241.         {
242.             Vector3 move = -0.02f * panningSensitivity * ( panningPlane.right * delta.x + panningPlane.up * delta.y );
243.            
244.             if( invertPanningDirections )
245.                 IdealPanOffset -= move;
246.             else
247.                 IdealPanOffset += move;
248.  
249.             lastPanTime = Time.time;
250.         }
251.     }
252.  
253.     void Apply()
254.     {
255.         if( smoothMotion )
256.         {
257.             distance = Mathf.Lerp( distance, IdealDistance, Time.deltaTime * smoothZoomSpeed );
258.             yaw = Mathf.Lerp( yaw, IdealYaw, Time.deltaTime * smoothOrbitSpeed );
259.             pitch = Mathf.Lerp( pitch, IdealPitch, Time.deltaTime * smoothOrbitSpeed );
260.         }
261.         else
262.         {
263.             distance = IdealDistance;
264.             yaw = IdealYaw;
265.             pitch = IdealPitch;
266.         }
267.  
268.         if( smoothPanning )
269.             panOffset = Vector3.Lerp( panOffset, idealPanOffset, Time.deltaTime * smoothPanningSpeed );
270.         else
271.             panOffset = idealPanOffset;
272.  
273.         transform.rotation = Quaternion.Euler( pitch, yaw, 0 );
274.         transform.position = ( target.position + panOffset ) - distance * transform.forward;
275.     }
276.  
277.     void LateUpdate()
278.     {
279.         Apply();
280.     }
281.  
282.     static float ClampAngle( float angle, float min, float max )
283.     {
284.         if( angle < -360 )
285.             angle += 360;
286.        
287.         if( angle > 360 )
288.             angle -= 360;
289.  
290.         return Mathf.Clamp( angle, min, max );
291.     }
292.  
293.     // recenter the camera
294.     public void ResetPanning()
295.     {
296.         IdealPanOffset = Vector3.zero;
297.     }
298.    
299. }
300.  
301.  
302.  

 

bump. please?

 

UPDATE. I have been able to set up a button that resets the camera. The problem is that it does not reset it to the original yaw, pitch and position - it keeps "resetting to the LAST yaw and pitch and position -

Can anyone help me figure out how I can set up the Original rotation and position in start so that it goes back to this on "reset" thanks in advance.

Code (csharp):

1. using UnityEngine;
2. using System.Collections;
3.  
4. /// <summary>
5. /// Adaptation of the standard MouseOrbit script to use the finger drag gesture to rotate the current object using
6. /// the fingers/mouse around a target object
7. /// NOTE: TBInputManager NOT required
8. /// </summary>
9. [AddComponentMenu( "FingerGestures/Toolbox/Misc/DragOrbitTwo" )]
10. public class TBDragOrbitTwo : MonoBehaviour
11. {
12.    
13.     public enum PanMode
14.     {
15.         Disabled,
16.         OneFinger,
17.         TwoFingers
18.     }
19.  
20.     /// <summary>
21.     /// The object to orbit around
22.     /// </summary>
23.     public Transform target;
24.    
25.    
26.     /// <summary>
27.     /// Initial camera distance to target
28.     /// </summary>
29.     public float initialDistance = 10.0f;
30.  
31.     /// <summary>
32.     /// Minimum distance between camera and target
33.     /// </summary>
34.     public float minDistance = 1.0f;
35.  
36.     /// <summary>
37.     /// Maximum distance between camera and target
38.     /// </summary>
39.     public float maxDistance = 20.0f;
40.  
41.     /// <summary>
42.     /// Affects horizontal (y-axis) and (X-axis) rotation speed
43.     /// </summary>
44.     public float yawSensitivity = 80.0f;
45.     public float pitchSensitivity = 80.0f;
46.    
47.      /// <summary>
48.      /// Keep yaw angle value (horizontal rotation) between minYaw and maxYaw
49.      /// </summary>
50.      public bool clampYawAngle = false;
51.      public float minYaw = 0;
52.      public float maxYaw = 360;
53.  
54.  
55.     /// <summary>
56.     /// Keep pitch angle value between minPitch and maxPitch?
57.     /// </summary>
58.     public bool clampPitchAngle = true;
59.     public float minPitch = -20;
60.     public float maxPitch = 80;
61.    
62.     public float yaw = 0;
63.     float pitch = 0;
64.    
65.     float idealYaw = 0;
66.     float idealPitch = 0;
67.    
68.    
69.     /// <summary>
70.     /// Allow the user to affect the orbit distance using the pinch zoom gesture
71.     /// </summary>
72.     public bool allowPinchZoom = true;
73.  
74.     /// <summary>
75.     /// Affects pinch zoom speed
76.     /// </summary>
77.     public float pinchZoomSensitivity = 2.0f;
78.  
79.     /// <summary>
80.     /// Use smooth camera motions?
81.     /// </summary>
82.     public bool smoothMotion = true;
83.     public float smoothZoomSpeed = 3.0f;
84.     public float smoothOrbitSpeed = 4.0f;
85.  
86.     /// <summary>
87.     /// Two-Finger camera panning.
88.     /// Panning will apply an offset to the pivot/camera target point
89.     /// </summary>
90.     public bool allowPanning = false;
91.     public bool invertPanningDirections = false;
92.     public float panningSensitivity = 1.0f;
93.     public Transform panningPlane;  // reference transform used to apply the panning translation (using panningPlane.right and panningPlane.up vectors)
94.     public bool smoothPanning = true;
95.     public float smoothPanningSpeed = 8.0f;
96.     float lastPanTime = 0;
97.  
98.     float distance = 0.0f;
99.     float idealDistance = 0;
100.    
101.    
102.     /// <summary>
103.     /// Reset Panning
104.     /// </summary>
105.    
106.     Vector3 idealPanOffset = Vector3.zero;
107.     Vector3 panOffset = Vector3.zero;
108.  
109.    
110.     //reset camera
111.     public bool resetCam;
112.     private Vector3 resetTwoposition;
113.     private Quaternion resetTworotation;
114.     Quaternion originalRotation;
115.    
116.  
117.     public float Distance
118.     {
119.         get { return distance; }
120.     }
121.  
122.     public float IdealDistance
123.     {
124.         get { return idealDistance; }
125.         set { idealDistance = Mathf.Clamp( value, minDistance, maxDistance ); }
126.     }
127.  
128.     public float Yaw
129.     {
130.         get { return yaw; }
131.     }
132.  
133.     public float IdealYaw
134.     {
135.         get { return idealYaw; }
136.         set { idealYaw = clampYawAngle ? ClampAngle( value, minYaw, maxYaw): value ; }
137.     }
138.  
139.     public float Pitch
140.     {
141.         get { return pitch; }
142.     }
143.  
144.     public float IdealPitch
145.     {
146.         get { return idealPitch; }
147.         set { idealPitch = clampPitchAngle ? ClampAngle( value, minPitch, maxPitch ) : value; }
148.     }
149.  
150.     //----------------------------------
151.     public Vector3 IdealPanOffset
152.    {
153.        get { return idealPanOffset; }
154.         set { idealPanOffset = value; }
155.    }
156.  
157.     public Vector3 PanOffset
158.     {
159.         get { return panOffset; }
160.     }
161.    
162.    void Start()
163.    
164.  
165.     {
166.         //Apply();
167.        
168.         if( !panningPlane )
169.             panningPlane = this.transform;
170.  
171.         Vector3 angles = transform.eulerAngles;
172.  
173.         distance = IdealDistance = initialDistance;
174.         //yaw = IdealYaw  = angles.y;
175.         //pitch = IdealPitch = angles.x;
176.  
177.          //Make the rigid body not change rotation
178.         if( rigidbody )
179.         rigidbody.freezeRotation = true;
180.        
181.         //set the inital position and rotation
182.         resetTwoposition = GameObject.Find("Camera180").transform.localPosition;
183.         resetTworotation = transform.localRotation;
184.        
185.         if (target)
186.  
187.         {
188.  
189.             transform.localPosition = target.localPosition;
190.         }
191.  
192.         else
193.  
194.             target.localPosition = transform.localPosition;
195.  
196.        
197.         originalRotation = transform.localRotation;
198.    
199.         //ResetCamera();
200.        
201.         //ResetPanning();
202.  
203.         }
204.        
205.  
206.    
207.     void OnEnable()
208.     {
209.         FingerGestures.OnDragMove += FingerGestures_OnDragMove;
210.         FingerGestures.OnPinchMove += FingerGestures_OnPinchMove;
211.         FingerGestures.OnTwoFingerDragMove += FingerGestures_OnTwoFingerDragMove;
212.     }
213.        
214.     void OnDisable()
215.     {
216.         FingerGestures.OnDragMove -= FingerGestures_OnDragMove;
217.         FingerGestures.OnPinchMove -= FingerGestures_OnPinchMove;
218.         FingerGestures.OnTwoFingerDragMove -= FingerGestures_OnTwoFingerDragMove;
219.     }
220.  
221.     void FingerGestures_OnDragMove( Vector2 fingerPos, Vector2 delta )
222.     {
223.         // if we panned recently, give a bit of time for all the fingers to lift off before we allow for one-finger drag
224.         if( Time.time - lastPanTime < 0.25f )
225.             return;
226.  
227.         if( target )
228.         {
229.             IdealYaw += delta.x * yawSensitivity * 0.02f;
230.             IdealPitch -= delta.y * pitchSensitivity * 0.02f;
231.         }
232.     }
233.  
234.     void FingerGestures_OnPinchMove( Vector2 fingerPos1, Vector2 fingerPos2, float delta )
235.     {
236.         if( allowPinchZoom )
237.             IdealDistance -= delta * pinchZoomSensitivity;
238.     }
239.  
240.     void FingerGestures_OnTwoFingerDragMove( Vector2 fingerPos, Vector2 delta )
241.     {
242.         if( allowPanning )
243.         {
244.             Vector3 move = -0.02f * panningSensitivity * ( panningPlane.right * delta.x + panningPlane.up * delta.y );
245.            
246.             if( invertPanningDirections )
247.                 IdealPanOffset -= move;
248.             else
249.                 IdealPanOffset += move;
250.  
251.             lastPanTime = Time.time;
252.         }
253.     }
254.  
255.     void Apply()
256.     {
257.         if( smoothMotion )
258.         {
259.             distance = Mathf.Lerp( distance, IdealDistance, Time.deltaTime * smoothZoomSpeed );
260.             yaw = Mathf.Lerp( yaw, IdealYaw, Time.deltaTime * smoothOrbitSpeed );
261.             pitch = Mathf.Lerp( pitch, IdealPitch, Time.deltaTime * smoothOrbitSpeed );
262.         }
263.         else
264.         {
265.             distance = IdealDistance;
266.             yaw = IdealYaw;
267.             pitch = IdealPitch;
268.         }
269.  
270.         if( smoothPanning )
271.             panOffset = Vector3.Lerp( panOffset, idealPanOffset, Time.deltaTime * smoothPanningSpeed );
272.         else
273.             panOffset = idealPanOffset;
274.  
275.         transform.rotation = Quaternion.Euler( pitch, yaw, 0 );
276.         transform.position = ( target.position + panOffset ) - distance * transform.forward;
277.     }
278.  
279.     void LateUpdate()
280.     {
281.         Apply();
282.     }
283.  
284.     static float ClampAngle( float angle, float min, float max )
285.     {
286.         if( angle < -360 )
287.             angle += 360;
288.        
289.         if( angle > 360 )
290.             angle -= 360;
291.  
292.         return Mathf.Clamp( angle, min, max );
293.     }
294.  
295.     // recenter the camera
296.     public void ResetPanning()
297.     {
298.         IdealPanOffset = Vector3.zero;
299.         print(IdealPanOffset);
300.        
301.     }
302.    
303.    public void ResetCamera()
304.    
305.     {
306.         transform.localPosition = resetTwoposition;
307.         transform.position = resetTwoposition;
308.         print(resetTwoposition);
309.    
310.         transform.localRotation = resetTworotation;
311.         transform.rotation = resetTworotation;
312.            
313.     }
314.    
315.  
316.     void OnGUI ()
317.     {
318.    
319.         if( GUI.Button(new Rect (739, 390, 97, 34),"Reset")){
320.        
321.        
322.         yaw = 0;
323.         pitch = 0; 
324.         ResetCamera();
325.         ResetPanning();
326.         }
327.     }
328. }

 

UPDATE (SOLVED)

lines 22 thru 23 as follows:

yaw = idealYaw = 0;
pitch = idealPitch = 0;

 

I am trying to understand your fix so I can add a reset to the C# MouseOrbitZoom camera from the wiki.

I have been setting the transform.position and transform.rotation to an initial camera location but it only works for one frame whether I use void LateUpdate or Void Update. I'm not sure what part of my understanding is missing, but days of work and I still can not get the camera to reset.

Any ideas?

Also did you really place the yaw and pitch code at line 22 and 23 (" /// </summary> , public Transform target;") or was it line 122 thru 123 or even line 222 thru 223 or a different line altogether?