├── README.md
└── Source Code
    ├── Assets
        └── scsm
    ├── Components
        ├── CustomNameTag.cs
        ├── FlyCamera.cs
        ├── Point.cs
        ├── TabButton.cs
        ├── TabGroup.cs
        ├── ToggleButton.cs
        └── UItag.cs
    ├── HarmonyPatches.cs
    ├── LeanTween
        ├── Editor
        │   ├── LeanTweenDocumentationEditor.cs
        │   └── LeanTweenDocumentationEditor.cs.meta
        ├── LTDescr.cs
        ├── LTDescr.cs.meta
        ├── LTDescrOptional.cs
        ├── LTDescrOptional.cs.meta
        ├── LTSeq.cs
        ├── LTSeq.cs.meta
        ├── LeanAudio.cs
        ├── LeanAudio.cs.meta
        ├── LeanSmooth.cs
        ├── LeanSmooth.cs.meta
        ├── LeanTest.cs
        ├── LeanTest.cs.meta
        ├── LeanTween.cs
        ├── LeanTween.cs.meta
        ├── LeanTween.dll.zip
        ├── LeanTween.dll.zip.meta
        ├── LeanTweenExt.cs
        ├── LeanTweenExt.cs.meta
        └── camerabundlegamer
    ├── Plugin.cs
    ├── PluginInfo.cs
    └── SeventysCameraSettingsMod.csproj


/README.md:
--------------------------------------------------------------------------------
 1 | # SeventysCameraSettingsMod
 2 | Change the way Gorilla Tag is viewed by your friends and fans!
 3 | 
 4 | Key Binds:
 5 |  
 6 | FOV = Mouse wheel
 7 | 
 8 | Free Cam = F1 Key toggle
 9 | 
10 | First Person = Enter Key Toggle
11 | 
12 | Toggle UI = Tab Key
13 | 
14 | W A S D = Move :|
15 | 
16 | Rotation = Arrow Keys
17 | 
18 | Spectate Player 1 - 9 Third Person = Number keys 1 - 9
19 | 
20 | Spectate Player 1 - 9 First Person = Number keys 1 - 9 + Shift
21 | 
22 | Place waypoint = P key
23 | 
24 | Start Waypoint Mode = O key
25 | 
26 | Delete WayPoint = I key (Hold)
27 | 
28 | Reset Rotation = Z key (Might be a different key if you are not using a English keyboard)
29 | 
30 | There might be some more but those are of the dome!
31 | 


--------------------------------------------------------------------------------
/Source Code/Assets/scsm:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/7Seventy0/SeventysCameraSettingsMod/7e1508dd9ff57e149eb792155227099505684957/Source Code/Assets/scsm


--------------------------------------------------------------------------------
/Source Code/Components/CustomNameTag.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | using Photon.Pun;
 4 | using TMPLoader;
 5 | public class CustomNameTag : MonoBehaviour
 6 | {
 7 |     TMPro.TextMeshProUGUI nametag_Text;
 8 |    public  GameObject nametag;
 9 |     GameObject Inametag;
10 |     FlyCamera flyCamera;
11 | 
12 |     void Start()
13 |     {
14 |         StartCoroutine(CoolStart());
15 |     }
16 |     IEnumerator CoolStart()
17 |     {
18 |         yield return new WaitForSeconds(1);
19 |         
20 |             Inametag = Instantiate(nametag);
21 | 
22 |             Inametag.name = "GorillaTagTag";
23 |             Inametag.transform.SetParent(transform, false);
24 |             Inametag.transform.localPosition = new Vector3(0, 2.4f, 0);
25 |             Inametag.transform.localScale = new Vector3(-0.2f, 0.2f, -0.2f);
26 |             nametag_Text = Inametag.GetComponentInChildren<TMPro.TextMeshProUGUI>();
27 |             nametag_Text.text = gameObject.GetComponent<PhotonView>().Owner.NickName;
28 | 
29 |            
30 | 
31 |         flyCamera = FindObjectOfType<FlyCamera>();
32 | 
33 | 
34 | 
35 |         InvokeRepeating("SlowUpdate", 0, 0.2f);
36 |     }
37 | 
38 |     void SlowUpdate()
39 |     {
40 | 
41 |         nametag_Text.outlineColor = GetComponentInChildren<SkinnedMeshRenderer>().material.color;
42 | 
43 |     }
44 |     void Update()
45 |     {
46 |         if(flyCamera == null)
47 |         {
48 |             flyCamera = FindObjectOfType<FlyCamera>();
49 |         }
50 |         if(Inametag != null)
51 |         {
52 |             //Debug.Log("Facing");
53 |         Inametag.transform.LookAt(flyCamera.transform.position);
54 |         }
55 |     }
56 | }


--------------------------------------------------------------------------------
/Source Code/Components/FlyCamera.cs:
--------------------------------------------------------------------------------
  1 | using Photon.Pun;
  2 | using Photon.Realtime;
  3 | using System.Collections;
  4 | using System.Collections.Generic;
  5 | using UnityEngine;
  6 | using UnityEngine.InputSystem;
  7 | using UnityEngine.UI;
  8 | using UniverseLib.Input;
  9 | using UniverseLib.UI;
 10 | using UnityEngine.Rendering;
 11 | 
 12 | public class FlyCamera : MonoBehaviour 
 13 | {
 14 | 
 15 |     string CodeBox = "ABC";
 16 |     string GameobjectFinder = "Player";
 17 |     GameObject uiCanvas;
 18 |     bool uiIsShown = true;
 19 |     float mainSpeed = 10.0f; //regular speed
 20 |     float shiftAdd = 20f; //multiplied by how long shift is held.  Basically running
 21 |     float maxShift = 100f; //Maximum speed when holdin gshift
 22 |     Vector2 rotation = Vector2.zero;
 23 |     AudioListener listener;
 24 |     private float totalRun= 1.0f;
 25 |     public bool allowedToMove = true;
 26 |     public bool allowedToFreecam = true;
 27 |     bool freecam;
 28 |     bool isFPSview = false;
 29 |     string fps = "120";
 30 |     public GameObject model;
 31 | 
 32 |     TabGroup tabGroup;
 33 |     ToggleButton lookAtToggle;
 34 |     ToggleButton modelToggle;
 35 |     ToggleButton arenaMode;
 36 |     Camera fakeCam;
 37 |     Text camposText;
 38 |     Text camrotText;
 39 |     Text camFOVText;
 40 |     Text camFreeCamBool;
 41 |     Text camIsFpsBool;
 42 | 
 43 |     Slider camSpeedSlider;
 44 |     Slider camRotSpeedSlider;
 45 |     Slider nearclipslider;
 46 |     Slider smoothingSlider;
 47 | 
 48 |     Button plug;
 49 | 
 50 |     Transform playerToTrackArenaMode;
 51 | 
 52 |     Camera shoulderCamera;
 53 |     float fov;
 54 |     private int _currentWaypointIndex = 0;
 55 |     GorillaNetworking.PhotonNetworkController __instance;
 56 | 
 57 |     bool isInWayPointMode;
 58 | 
 59 |     float nearclip;
 60 |     float smoothing;
 61 | 
 62 |     bool primaryR;
 63 |     public static UIBase UiBase { get; private set; }
 64 |     GameObject player;
 65 |     public List<Transform> points = new List<Transform>();
 66 |     void Start()
 67 |     {
 68 |         shoulderCamera = GetComponent<Camera>();
 69 |         fov = shoulderCamera.fieldOfView;
 70 |         listener = gameObject.AddComponent<AudioListener>();
 71 |         listener.enabled = false;
 72 |         InvokeRepeating("SlowUpdate", 0, 0.1f);
 73 | 
 74 |         player = GameObject.Find("Player");
 75 |         StartCoroutine(LateStart());
 76 |         
 77 |     }
 78 | 
 79 |     IEnumerator LateStart()
 80 |     {
 81 |         yield return new WaitForSeconds(1);
 82 |         nearclipslider = GameObject.Find("NearClipSlider").GetComponent<Slider>();
 83 |         arenaMode = GameObject.Find("ArenaAtToggle").AddComponent<ToggleButton>();
 84 |         lookAtToggle = GameObject.Find("LookAtToggle").AddComponent<ToggleButton>();
 85 |         
 86 | 
 87 |         
 88 | 
 89 |         yield return new WaitForSeconds(1);
 90 |         uiCanvas = GameObject.FindObjectOfType<UItag>().gameObject;
 91 |         
 92 |         
 93 |         uiCanvas.GetComponent<TabGroup>().PopulateTabList(GameObject.Find("Camera Settings Tab"));
 94 |       
 95 |         uiCanvas.GetComponent<TabGroup>().PopulateTabList(GameObject.Find("Camera Info Tab"));
 96 |         uiCanvas.GetComponent<TabGroup>().PopulateTabList(GameObject.Find("CompTab"));
 97 | 
 98 |         lookAtToggle.SetFalse();
 99 |         
100 |         arenaMode.SetFalse();
101 |        
102 |         modelToggle = GameObject.Find("ModelToggle").AddComponent<ToggleButton>();
103 | 
104 |         fakeCam = GameObject.Find("FakeCam").GetComponent<Camera>();
105 |         fakeCam.gameObject.GetComponent<AudioListener>().enabled = false    ;
106 |     }
107 |     string roomCode ="OJH82D";
108 | 
109 |     float sliderMoveSpeedXFactor = 5;
110 |     float sliderRotSpeedXFactor = 150;
111 | 
112 |     bool playerMover;
113 | 
114 |     void OnPlugClick()
115 |     {
116 |          Application.OpenURL("https://7seventy0.carrd.co/");
117 |     }
118 | 
119 | 
120 |     void OnGUI()
121 |     {
122 |         if (uiIsShown)
123 |         {
124 |             
125 |             CodeBox = GUI.TextArea(new Rect(10, 10, 200, 20), CodeBox, 200);
126 | 
127 |             if (GUI.Button(new Rect(10, 35, 100, 30), "Join"))
128 |                GorillaNetworking.PhotonNetworkController.Instance.AttemptToJoinSpecificRoom(CodeBox);
129 | 
130 |             GameobjectFinder = GUI.TextArea(new Rect(10, 100, 200, 20), GameobjectFinder, 200);
131 | 
132 |             if (GUI.Button(new Rect(10, 125, 100, 30), "Track"))
133 |                 if(GameObject.Find(GameobjectFinder) != null)
134 |                 {
135 |                     playerToTrackArenaMode = GameObject.Find(GameobjectFinder).transform;
136 |                 }
137 | 
138 | 
139 |         }
140 | 
141 |     }
142 |     private LoadBalancingClient loadBalancingClient;
143 | 
144 |     float arenaCameraSwitchCoolDown = 5;
145 |     float arenaCameraSwitchNextSwitch;
146 |     // Pov: free code!
147 |     void ArenaUpdate()
148 |     {
149 | 
150 |         if(points.Count > 0)
151 |         {
152 |             if (playerToTrackArenaMode == null)
153 |             {
154 |                 playerToTrackArenaMode = Camera.main.transform;
155 |             }
156 | 
157 |             float distanceToClosestEnemy = Mathf.Infinity;
158 |             Point closestEnemy = null;
159 |             Point[] allEnemies = GameObject.FindObjectsOfType<Point>();
160 |             foreach (Point currentEnemy in allEnemies)
161 |             {
162 |                 float distanceToEnemy = (currentEnemy.transform.position - playerToTrackArenaMode.position).sqrMagnitude;
163 |                 if (distanceToEnemy < distanceToClosestEnemy)
164 |                 {
165 |                     distanceToClosestEnemy = distanceToEnemy;
166 |                     closestEnemy = currentEnemy;
167 |                 }
168 |             }
169 | 
170 |             if (transform.position != closestEnemy.transform.position && Time.time > arenaCameraSwitchNextSwitch)
171 |             {
172 |                 transform.position = closestEnemy.transform.position;
173 |                 arenaCameraSwitchNextSwitch = Time.time + arenaCameraSwitchCoolDown;
174 |             }
175 | 
176 |         }
177 | 
178 | 
179 | 
180 | 
181 | 
182 | 
183 |     }
184 |     // :)
185 |     void SlowUpdate()
186 |     {
187 |         //Had to add the logs because i could not find the line that did that bad :(
188 | 
189 |       // Debug.Log("gfadadawdadwdawdawdadadadadawdwaddadadwawdadadad");
190 |       
191 |         //Debug.Log("######################################################################");
192 |         if(uiCanvas == null)
193 |         {
194 |           //  Debug.Log("###########nnnnnnnnnnnnnnnnnnnnnnnnnn#############");
195 |             uiCanvas = GameObject.FindObjectOfType<UItag>().gameObject;
196 |            // Debug.Log("###########nnnnnnooooooooooooooooooooooooooooooonnnnnnn#############");
197 |             GameObject.Find("CameraSettingsTABButton").AddComponent<TabButton>();
198 |             GameObject.Find("infoTABButton").AddComponent<TabButton>();
199 |             GameObject.Find("RoomTABButton").AddComponent<TabButton>();
200 |             GameObject.Find("HelpTABButton").AddComponent<TabButton>();
201 |             GameObject.Find("CompTABButton").AddComponent<TabButton>();
202 |             uiCanvas.AddComponent<TabGroup>();
203 | 
204 | 
205 |           //  Debug.Log("CODE: 8888988888888888888888898888888888888888888888");
206 | 
207 |             foreach (TabButton tabButton in GameObject.FindObjectsOfType<TabButton>())
208 |             {
209 |                 tabButton.tabGroup = uiCanvas.GetComponent<TabGroup>();
210 |             }
211 | 
212 |         }
213 | 
214 |         if(uiCanvas != null)
215 |         {
216 |           //  Debug.Log("###########nnnnnnniiiiiiiiiiiiiiiinnnnnnnnnn#############");
217 |             if (uiIsShown)
218 |             {
219 |                 uiCanvas.SetActive(true);
220 |             }
221 |             else
222 |             {
223 |                 uiCanvas.SetActive(false);
224 |             }
225 |         }
226 | 
227 | 
228 | 
229 | 
230 |         model.SetActive(modelToggle.state);
231 | 
232 |         UniversalUI.EventSys.enabled = true;
233 |         
234 |              //   Debug.Log("###########nnnnnnniiiiiiiii55555555555555555555555555iiiiiiinnnnnnnnnn#############");
235 | 
236 | 
237 |         if (arenaMode.state && allowedToFreecam)
238 |         {
239 |             ArenaUpdate();
240 | 
241 |         }
242 | 
243 |        
244 |     //    Debug.Log("ddddddddddddddddddddddddddddddddddddddddddddddddd");
245 | 
246 | 
247 | 
248 |         //    Debug.Log("###########nnnnnnniiii333333337777777777777777777777777777777777777777#######");
249 |         if (smoothingSlider == null)
250 |         {
251 |         //    Debug.Log("###########nnnnnnniiii33333222222222222222222222222222223333333iiiinnnnnnnnnn#############");
252 |             smoothingSlider = GameObject.Find("SmoothingSlidergaming").GetComponent<UnityEngine.UI.Slider>();
253 |                
254 |         }
255 |         else
256 |         {
257 |            
258 |             smoothing = smoothingSlider.value / 10;
259 |         }
260 |        // Debug.Log("####0000000000000000000000000000000000000000000000000######");
261 |         if (camIsFpsBool == null)
262 |         {
263 |             camIsFpsBool = GameObject.Find("CameraisFirstPerson").GetComponent<Text>();
264 |         }
265 |         else
266 |         {
267 |             camIsFpsBool.text = "isInFirstPerson ? = " + isFPSview;
268 |         }
269 | 
270 |        // Debug.Log("gggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggggg");
271 | 
272 | 
273 |         if (camFreeCamBool == null)
274 |         {
275 |             camFreeCamBool = GameObject.Find("CameraisFreeCam").GetComponent<Text>();
276 |         }
277 |         else
278 |         {
279 |             camFreeCamBool.text = "isInFreeCam? = " + freecam;
280 |         }
281 | 
282 | 
283 |        // Debug.Log("uuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuu");
284 | 
285 | 
286 |         if (camposText != null)
287 |         {
288 |             camposText.text = "POS : " + transform.position.ToString();
289 |         }
290 |         else
291 |         {
292 |             camposText = GameObject.Find("CameraPOS TEXT").GetComponent<Text>();
293 |         }
294 |         //
295 |         //Debug.Log("rrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr");
296 | 
297 |         if (camrotText != null)
298 |        {
299 |             camrotText.text = "ROT : " + transform.eulerAngles.ToString();
300 |        }
301 |        else
302 |        {
303 |             camrotText = GameObject.Find("CameraROT TEXT").GetComponent<Text>();
304 |        }
305 | 
306 |         //Debug.Log("xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx");
307 | 
308 |         if (camFOVText != null)
309 |        {
310 |             camFOVText.text = "FOV : " + shoulderCamera.fieldOfView.ToString();
311 |        }
312 |        else
313 |        {
314 |             camFOVText = GameObject.Find("CameraFOV Text").GetComponent<Text>();
315 |        }
316 | 
317 |       //  Debug.Log("zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz");
318 |         if (camSpeedSlider == null)
319 |         {
320 |             camSpeedSlider = GameObject.Find("CAMERASPEEDSLIDER").GetComponent<Slider>();
321 |         }
322 |         if(camRotSpeedSlider == null)
323 |         {
324 | 
325 |             camRotSpeedSlider = GameObject.Find("ROTATIONSPEEDSLIDER").GetComponent<Slider>();
326 |         }
327 |       //  Debug.Log("0000000000000000000000000000000000000000000000000000000000000000000000000000");
328 |         if (plug == null)
329 |         {
330 |             plug = GameObject.Find("PlugButton").GetComponent<Button>();
331 |             plug.onClick.AddListener(OnPlugClick);
332 |         }
333 |         //Debug.Log("666666666666666666666666666666666666666666666666666666666666666666666666");
334 |     }
335 |     float animationtime = 3f;
336 |     void LatchOnToPlayer(int playerToWatch)
337 |     {
338 |         if (!arenaMode.state)
339 |         {
340 |             GameObject camera = GameObject.Find("Shoulder Camera");
341 |             if (playerToWatch > GorillaParent.instance.GetComponentsInChildren<VRRig>().Length)
342 |             {
343 |                 playerToWatch = GorillaParent.instance.GetComponentsInChildren<VRRig>().Length;
344 |             }
345 |             camera.transform.SetParent(GorillaParent.instance.GetComponentsInChildren<VRRig>()[playerToWatch].transform);
346 |             LeanTween.moveLocal(camera, new Vector3(-0.263f, 2.1212f, -2.4989f), animationtime)
347 |                 .setEaseOutCubic();
348 |             transform.localEulerAngles = Vector3.zero;
349 |             Debug.Log("Now spectating " + GorillaParent.instance.GetComponentsInChildren<VRRig>()[playerToWatch].gameObject.GetComponent<PhotonView>().Controller);
350 | 
351 |         }
352 | 
353 |     }
354 |     void LatchOnToPlayerHead(int playerToWatch)
355 |     {
356 |         if (!arenaMode.state)
357 |         {
358 |             GameObject camera = GameObject.Find("Shoulder Camera");
359 | 
360 |             if (playerToWatch > GorillaParent.instance.GetComponentsInChildren<VRRig>().Length)
361 |             {
362 |                 playerToWatch = GorillaParent.instance.GetComponentsInChildren<VRRig>().Length;
363 |             }
364 |             camera.transform.SetParent(GorillaParent.instance.GetComponentsInChildren<VRRig>()[playerToWatch].head.rigTarget);
365 |             LeanTween.moveLocal(camera, new Vector3(0, .12f, 0f), animationtime)
366 |                 .setEaseOutCubic();
367 |             transform.localEulerAngles = Vector3.zero;
368 | 
369 |             Debug.Log("Now spectating " + GorillaParent.instance.GetComponentsInChildren<VRRig>()[playerToWatch].gameObject.GetComponent<PhotonView>().Controller + " In first person!");
370 |         }
371 | 
372 |         
373 |     }
374 | 
375 |     void PlayerToTrackArenaMode(int playerToTrack)
376 |     {
377 |         GameObject camera = GameObject.Find("Shoulder Camera");
378 | 
379 |         if (playerToTrack > GorillaParent.instance.GetComponentsInChildren<VRRig>().Length)
380 |         {
381 |             playerToTrack = GorillaParent.instance.GetComponentsInChildren<VRRig>().Length ;
382 |         }
383 | 
384 |         playerToTrackArenaMode = GorillaParent.instance.GetComponentsInChildren<VRRig>()[playerToTrack].head.rigTarget;
385 | 
386 |     }
387 | 
388 | 
389 |     Vector3 firstpersonOffset = new Vector3(17,50f,-5);
390 | 
391 |     VRRig rig;
392 |     void Update () 
393 |     {
394 | 
395 | 
396 |       if(rig == null)
397 |         {
398 |             rig = GameObject.Find("Actual Gorilla").GetComponent<VRRig>();
399 |         }
400 |         // Debug.Log("DDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDDD");
401 |         if(nearclipslider == null)
402 |         {
403 |             nearclipslider = GameObject.Find("NearClipSlider").GetComponent<Slider>();
404 |         }
405 |         nearclip = nearclipslider.value / 2;
406 |      //  Debug.Log(")))))))))))eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee)))))))))))))))))))))))))))))))))");
407 |         GetComponent<Camera>().nearClipPlane = Mathf.Clamp(nearclip,0.01f,3);
408 |        // Debug.Log("))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))");
409 |         
410 |         if (Keyboard.current.tabKey.wasPressedThisFrame)
411 |         {
412 | 
413 |             uiIsShown = !uiIsShown;
414 |           
415 | 
416 |         }
417 | 
418 |         //   Debug.Log("VVVVVVVVVVVVVVVVVVVVVVV///////////////////////////////////////////////////////////////////");
419 |         if (Keyboard.current.digit1Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
420 |         {
421 |             LatchOnToPlayer(1);
422 |         }
423 | 
424 |         if (Keyboard.current.digit2Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
425 |         {
426 |             LatchOnToPlayer(2);
427 |         }
428 |         if (Keyboard.current.digit3Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
429 |         {
430 |             LatchOnToPlayer(3);
431 |         }
432 |         if (Keyboard.current.digit4Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
433 |         {
434 |             LatchOnToPlayer(4);
435 |         }
436 |         if (Keyboard.current.digit5Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
437 |         {
438 |             LatchOnToPlayer(5);
439 |         }
440 |         if (Keyboard.current.digit6Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
441 |         {
442 |             LatchOnToPlayer(6);
443 |         }
444 |         if (Keyboard.current.digit7Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
445 |         {
446 |             LatchOnToPlayer(7);
447 |         }
448 |         if (Keyboard.current.digit8Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
449 |         {
450 |             LatchOnToPlayer(8);
451 |         }
452 |         if (Keyboard.current.digit9Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
453 |         {
454 |             LatchOnToPlayer(9);
455 |         }
456 |         if (Keyboard.current.digit0Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && !Keyboard.current.leftCtrlKey.isPressed)
457 |         {
458 |             transform.SetParent(null);
459 |             isFPSview = true;
460 |         }
461 | 
462 | 
463 | 
464 | 
465 |         if (Keyboard.current.digit1Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
466 |         {
467 |             PlayerToTrackArenaMode(1);
468 |         }
469 |         if (Keyboard.current.digit2Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
470 |         {
471 |             PlayerToTrackArenaMode(2);
472 |         }
473 |         if (Keyboard.current.digit3Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
474 |         {
475 |             PlayerToTrackArenaMode(3);
476 |         }
477 |         if (Keyboard.current.digit4Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
478 |         {
479 |             PlayerToTrackArenaMode(4);
480 |         }
481 |         if (Keyboard.current.digit5Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
482 |         {
483 |             PlayerToTrackArenaMode(5);
484 |         }
485 |         if (Keyboard.current.digit6Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
486 |         {
487 |             PlayerToTrackArenaMode(6);
488 |         }
489 |         if (Keyboard.current.digit7Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
490 |         {
491 |             PlayerToTrackArenaMode(7);
492 |         }
493 |         if (Keyboard.current.digit8Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
494 |         {
495 |             PlayerToTrackArenaMode(8);
496 |         }
497 |         if (Keyboard.current.digit9Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
498 |         {
499 |             PlayerToTrackArenaMode(9);
500 |         }
501 |         if (Keyboard.current.digit9Key.wasPressedThisFrame && !Keyboard.current.shiftKey.isPressed && Keyboard.current.leftCtrlKey.isPressed)
502 |         {
503 |             playerToTrackArenaMode = Camera.main.transform;
504 |         }
505 | 
506 |         if(playerToTrackArenaMode == null)
507 |         {
508 |             playerToTrackArenaMode = Camera.main.transform;
509 |         }
510 | 
511 | 
512 | 
513 |           // Debug.Log("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
514 |         if (lookAtToggle.state && !isFPSview && playerToTrackArenaMode != null)
515 |         {
516 |             Vector3 lookDirection = playerToTrackArenaMode.transform.position - transform.position;
517 |             lookDirection.Normalize();
518 | 
519 |             transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(lookDirection), smoothing);
520 |         }
521 |         //Debug.Log("DGBWHJVBDAHJDJDBJHDHBAJVDHWVDHJADVHJHWJ");
522 |  
523 |    //     Debug.Log("ZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ");
524 | 
525 | 
526 |         if (Keyboard.current.digit1Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
527 |         {
528 |             LatchOnToPlayerHead(1);
529 |         }
530 |         if (Keyboard.current.digit2Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
531 |         {
532 |             LatchOnToPlayerHead(2);
533 |         }
534 |         if (Keyboard.current.digit3Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
535 |         {
536 |             LatchOnToPlayerHead(3);
537 |         }
538 |         if (Keyboard.current.digit4Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
539 |         {
540 |             LatchOnToPlayerHead(4);
541 |         }
542 |         if (Keyboard.current.digit5Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
543 |         {
544 |             LatchOnToPlayerHead(5);
545 |         }
546 |         if (Keyboard.current.digit6Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
547 |         {
548 |             LatchOnToPlayerHead(6);
549 |         }
550 |         if (Keyboard.current.digit7Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
551 |         {
552 |             LatchOnToPlayerHead(7);
553 |         }
554 |         if (Keyboard.current.digit8Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
555 |         {
556 |             LatchOnToPlayerHead(8);
557 |         }
558 |         if (Keyboard.current.digit9Key.wasPressedThisFrame && Keyboard.current.shiftKey.isPressed)
559 |         {
560 |             LatchOnToPlayerHead(9);
561 |         }
562 | 
563 | 
564 |       // Debug.Log("OOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOOO");
565 |         if (Keyboard.current.enterKey.wasPressedThisFrame)
566 |         {
567 |             isFPSview = !isFPSview;
568 |            
569 |             if (!isFPSview)
570 |             {
571 |                 transform.SetParent(Camera.main.transform);
572 |             }
573 |             
574 | 
575 |         }
576 | 
577 |         if (isFPSview)
578 |         {
579 |             if (transform.parent != rig.playerOffsetTransform.transform)
580 |                 transform.SetParent(rig.playerOffsetTransform.transform);
581 | 
582 |             transform.position = Camera.main.transform.position;
583 |                 transform.rotation = Quaternion.Lerp(transform.rotation, Camera.main.transform.rotation, smoothing * 1.6f);
584 |         }
585 |         if (!isFPSview)
586 |         {
587 |             allowedToMove = true;
588 |         }
589 |         if (Keyboard.current.zKey.isPressed)
590 |         {
591 |             LeanTween.rotateLocal(gameObject, Vector3.zero, 0.3f);
592 |         }
593 | 
594 |         
595 |         if (playerMover)
596 |         {
597 |             if (freecam)
598 |             {
599 |             GameObject.Find("Player").transform.position = transform.position;
600 |             GameObject.Find("Player").transform.localScale = Vector3.zero;
601 | 
602 |             }   
603 |         }
604 |         else
605 |         {
606 |             GameObject.Find("Player").transform.localScale = Vector3.one;
607 |         }
608 | 
609 |      //   Debug.Log("VVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVVV");
610 |         //Keyboard commands
611 |         float f = 0.0f;
612 |         if (allowedToMove)
613 |         {
614 |             Vector3 p = GetBaseInput();
615 |             if (p.sqrMagnitude > 0)
616 |             { // only move while a direction key is pressed
617 |                 if (Keyboard.current.leftShiftKey.isPressed)
618 |                 {
619 |                     totalRun += Time.deltaTime;
620 |                     p = p * totalRun * shiftAdd;
621 |                     p.x = Mathf.Clamp(p.x, -maxShift, maxShift);
622 |                     p.y = Mathf.Clamp(p.y, -maxShift, maxShift);
623 |                     p.z = Mathf.Clamp(p.z, -maxShift, maxShift);
624 |                 }
625 |                 else
626 |                 {
627 |                     totalRun = Mathf.Clamp(totalRun * 0.5f, 1f, 1000f);
628 |                     p = p * mainSpeed;
629 |                 }
630 | 
631 |                 p = p * Time.deltaTime;
632 |                 Vector3 newPosition = transform.position;
633 |                 if (Keyboard.current.spaceKey.isPressed)
634 |                 { 
635 |                     transform.Translate(p);
636 |                     newPosition.x = transform.position.x;
637 |                     newPosition.z = transform.position.z;
638 |                     newPosition.y = transform.position.y;
639 |                     transform.position = newPosition;
640 |                 }
641 |                 else
642 |                 {
643 |                     transform.Translate(p);
644 |                 }
645 |             }
646 |         }
647 |         if(GorillaNetworking.PhotonNetworkController.Instance != null) // Change instance to Instance when the new update hits (should be fine: Tested 4/27/2022)
648 |         {
649 |           __instance = GorillaNetworking.PhotonNetworkController.Instance;
650 |             __instance.disableAFKKick = true;
651 |         }
652 | 
653 |         if (Mouse.current.scroll.ReadValue().y < 0f)
654 |         {
655 |             fov += 0.5f * 10;
656 |            fov = Mathf.Clamp(fov, 5, 165);
657 |         }
658 |         if (Mouse.current.scroll.ReadValue().y >  0f )
659 |         {
660 |             fov -= 0.5f * 10;
661 |             fov = Mathf.Clamp(fov, 5, 165);
662 |         }
663 | 
664 |         shoulderCamera.fieldOfView = Mathf.Lerp(shoulderCamera.fieldOfView, fov, 0.08f);
665 | 
666 |         if (Keyboard.current.leftArrowKey.isPressed)
667 | 
668 |         {
669 |             rotation.y -= 1 * camRotSpeedSlider.value * sliderRotSpeedXFactor * Time.deltaTime;
670 |             transform.localEulerAngles = rotation;
671 |         }
672 |         if (Keyboard.current.rightArrowKey.isPressed)
673 |         {
674 |             rotation.y += 1 * camRotSpeedSlider.value * sliderRotSpeedXFactor * Time.deltaTime;
675 |             transform.localEulerAngles = rotation;
676 | 
677 |         }
678 |         if (Keyboard.current.upArrowKey.isPressed)
679 |         {
680 |             rotation.x -= 1 * camRotSpeedSlider.value * sliderRotSpeedXFactor * Time.deltaTime;
681 |             transform.localEulerAngles = rotation;
682 |         }
683 |         if (Keyboard.current.downArrowKey.isPressed)
684 |         {
685 |             rotation.x += 1 * camRotSpeedSlider.value * sliderRotSpeedXFactor * Time.deltaTime;
686 |             transform.localEulerAngles = rotation;
687 | 
688 |         }
689 | 
690 |      
691 | 
692 |         if (PhotonNetwork.CurrentRoom != null)
693 |         {
694 |             if (PhotonNetwork.CurrentRoom.IsVisible)
695 |             {
696 |                 allowedToFreecam = false;
697 |             }
698 |             else
699 |             {
700 |                 allowedToFreecam = true;
701 |             }
702 |         }
703 | 
704 | 
705 | 
706 |         if (allowedToFreecam)
707 |         {
708 |             if (Keyboard.current.f1Key.wasPressedThisFrame)
709 |             {
710 |                 freecam = !freecam;
711 |                 StartCoroutine(WhatToDo());
712 |             }
713 | 
714 |             
715 |         }
716 |         else
717 |         {
718 |             if(gameObject.transform.parent == null && !isFPSview)
719 |             {
720 |                 gameObject.transform.SetParent(Camera.main.transform, false);
721 |                 transform.localPosition = new Vector3(0.2412f, 0.4459f, -1.6936f);
722 |                 transform.localEulerAngles = Vector3.zero;
723 |             }
724 |         }
725 | 
726 |         //Mouse  camera angle done.  
727 | 
728 |         if (Keyboard.current.pKey.wasPressedThisFrame)
729 |         {
730 |             NewPoint();
731 | 
732 |         }
733 | 
734 |         if (Keyboard.current.iKey.isPressed)
735 |         {
736 |             DeletePoints();
737 |         }
738 | 
739 |         if (Keyboard.current.oKey.wasPressedThisFrame && points.Count > 0)
740 |         {
741 |            isInWayPointMode = !isInWayPointMode;    
742 | 
743 |         }
744 | 
745 |         if (isInWayPointMode)
746 |         {
747 |         Transform pointTransform = points.ToArray()[_currentWaypointIndex].transform;
748 |         if (Vector3.Distance(transform.position, pointTransform.position) < 1f)
749 |         {
750 |             _currentWaypointIndex = (_currentWaypointIndex + 1) % points.ToArray().Length;
751 |         }
752 |         else
753 |         {
754 | 
755 |                 transform.position = Vector3.MoveTowards(transform.position, pointTransform.position, 0.2f);
756 | 
757 | 
758 | 
759 |                 transform.rotation = Quaternion.Slerp(
760 |                     transform.rotation,
761 |                     pointTransform.rotation,
762 |                     1 * Time.deltaTime);
763 |             }
764 |         }
765 | 
766 | 
767 |     }
768 | 
769 |     IEnumerator WhatToDo()
770 |     {
771 |         if (!freecam)
772 |         {
773 |             gameObject.transform.SetParent(Camera.main.transform);
774 |             transform.localPosition = new Vector3(0.2412f, 0.4459f, -1.6936f);
775 |             listener.enabled = false;
776 |         }
777 |        
778 |         if (freecam)
779 |         {
780 |             gameObject.transform.SetParent(null, true);
781 |             transform.localEulerAngles = new Vector3(gameObject.transform.localEulerAngles.x, gameObject.transform.localEulerAngles.y, 0);
782 |             listener.enabled = true;
783 |         }
784 |         yield return new WaitForSeconds(0.1f);
785 |     }
786 | 
787 |     void DeletePoints()
788 |     {
789 |         foreach (var point in points)
790 |         {
791 |             Destroy(point.gameObject);
792 |             points.Remove(point);   
793 | 
794 |             Debug.Log(points.Count);
795 |         }
796 |     }
797 | 
798 |     void NewPoint()
799 |     {
800 |         if (freecam)
801 |         {
802 |             GameObject point = GameObject.CreatePrimitive(PrimitiveType.Sphere);
803 |             point.transform.position = transform.position;
804 |             point.transform.rotation = transform.rotation;
805 |             point.GetComponent<SphereCollider>().enabled = false;
806 |             point.AddComponent<Point>();
807 |             points.Add(point.transform);
808 |             Debug.Log(points.ToArray().Length);
809 |         }
810 |     }
811 |      
812 |     private Vector3 GetBaseInput() { //returns the basic values, if it's 0 than it's not active.
813 | 
814 | 
815 |         Vector3 p_Velocity = new Vector3();
816 |         if (Keyboard.current.wKey.isPressed){
817 |             p_Velocity += new Vector3(0, 0 , 1 * camSpeedSlider.value * sliderMoveSpeedXFactor);
818 |         }
819 |         if (Keyboard.current.sKey.isPressed)
820 |         {
821 |             p_Velocity += new Vector3(0, 0, -1 * camSpeedSlider.value * sliderMoveSpeedXFactor);
822 |         }
823 |         if (Keyboard.current.aKey.isPressed)
824 |         {
825 |             p_Velocity += new Vector3(-1 * camSpeedSlider.value * sliderMoveSpeedXFactor, 0, 0);
826 |         }
827 |         if (Keyboard.current.dKey.isPressed)
828 |         {
829 |             p_Velocity += new Vector3(1 * camSpeedSlider.value * sliderMoveSpeedXFactor, 0, 0);
830 |         }
831 |         if (Keyboard.current.leftCtrlKey.isPressed)
832 |         {
833 |             p_Velocity += new Vector3(0, -.5f * camSpeedSlider.value * sliderMoveSpeedXFactor, 0);
834 |         }
835 |         if (Keyboard.current.spaceKey.isPressed)
836 |         {
837 |             p_Velocity += new Vector3(0, .5f * camSpeedSlider.value * sliderMoveSpeedXFactor, 0);
838 |         }
839 | 
840 |         return p_Velocity;
841 |     }
842 | }


--------------------------------------------------------------------------------
/Source Code/Components/Point.cs:
--------------------------------------------------------------------------------
1 | using UnityEngine;
2 | using System.Collections;
3 | 
4 | public class Point : MonoBehaviour
5 | {
6 | }


--------------------------------------------------------------------------------
/Source Code/Components/TabButton.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | using UnityEngine.EventSystems;
 4 | using UnityEngine.UI;
 5 | public class TabButton : MonoBehaviour , IPointerEnterHandler, IPointerClickHandler, IPointerExitHandler
 6 | {
 7 |     public TabGroup tabGroup;
 8 |     public Image image;
 9 | 
10 |     public void OnPointerClick(PointerEventData eventData)
11 |     {
12 |         tabGroup.OnTabSelected(this);
13 |     }
14 | 
15 |     public void OnPointerEnter(PointerEventData eventData)
16 |     {
17 |         tabGroup.OnTabEnter(this);
18 |     }
19 | 
20 |     public void OnPointerExit(PointerEventData eventData)
21 |     {
22 |         tabGroup.OnTabExit(this);
23 |     }
24 | 
25 |     void Start()
26 |     {
27 |         image = GetComponent<Image>();  
28 |        tabGroup.Subscribe(this);
29 |     }
30 | 
31 | }
32 | 
33 | 
34 | 
35 |     


--------------------------------------------------------------------------------
/Source Code/Components/TabGroup.cs:
--------------------------------------------------------------------------------
  1 | using UnityEngine;
  2 | using System.Collections;
  3 | using UnityEngine.EventSystems;
  4 | using System.Collections.Generic;
  5 | using UnityEngine.UI;
  6 | public class TabGroup : MonoBehaviour
  7 | {
  8 |     public List<TabButton> tabButtons;
  9 |     public List<GameObject> tabs;
 10 |     public string VaporApplication = "PEH0V-62M57-7EBQN"
 11 |     Color idleColor = new Color(1,1,1);
 12 |     Color hoverColor = new Color(0.8f,0.8f,0.8f);
 13 |     Color selectedColor = new Color(0.4f, 0.4f, 0.4f);
 14 | 
 15 |     public TabButton selectedTab;
 16 | 
 17 |     void Start()
 18 |     {
 19 |         tabs = new List<GameObject>();
 20 |         Invoke("LaterStart", 2.4f);
 21 |     }
 22 | 
 23 |     public void Subscribe(TabButton tabButton)
 24 |     {
 25 |         if(tabButtons == null)
 26 |         {
 27 |             tabButtons = new List<TabButton>();
 28 |         }
 29 | 
 30 |         tabButtons.Add(tabButton);
 31 |     }
 32 | 
 33 |     public void PopulateTabList(GameObject tab)
 34 |     {
 35 |         if(tabs == null)
 36 |         {
 37 |             tabs = new List<GameObject> ();
 38 |         }
 39 |         tabs.Add(tab);
 40 |         tab.gameObject.SetActive(true);
 41 |     }
 42 | 
 43 |     void LaterStart()
 44 |     {
 45 |         foreach(GameObject tab in tabs)
 46 |         {
 47 |             tab.SetActive(false);
 48 |         }
 49 |     }
 50 | 
 51 |     public void OnTabEnter(TabButton tabButton)
 52 |     {
 53 |         if (selectedTab == null || tabButton != selectedTab)
 54 |         {
 55 |             ResetTabs();
 56 |             tabButton.image.color = hoverColor;
 57 |         }
 58 | 
 59 |        
 60 |     }
 61 | 
 62 |     public void OnTabExit(TabButton tabButton)
 63 |     {
 64 |         ResetTabs();
 65 | 
 66 |     }
 67 | 
 68 |     public void OnTabSelected(TabButton tabButton)
 69 |     {
 70 |         selectedTab = tabButton;
 71 |         ResetTabs();
 72 |         tabButton.image.color = selectedColor;
 73 | 
 74 |         int index = tabButton.transform.GetSiblingIndex();
 75 |         for(int i = 0; i < tabs.Count; i++)
 76 |         {
 77 |             if(i == index)
 78 |             {
 79 |                 tabs[i].SetActive(true);
 80 |             }
 81 |             else
 82 |             {
 83 |                 tabs[i].SetActive(false);
 84 |             }
 85 |         }
 86 |     }
 87 | 
 88 |     public void ResetTabs()
 89 |     {
 90 |         foreach(TabButton tabButton in tabButtons)
 91 |         {
 92 |             if(selectedTab != null && tabButton == selectedTab)
 93 |             {
 94 |                 continue;
 95 |             }
 96 |             tabButton.image.color = idleColor;
 97 | 
 98 |         }
 99 |         
100 |     }
101 | }
102 | 
103 | 
104 | 
105 | 
106 | 
107 |     
108 | 


--------------------------------------------------------------------------------
/Source Code/Components/ToggleButton.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | using UnityEngine.EventSystems;
 4 | using UnityEngine.UI;
 5 | public class ToggleButton : MonoBehaviour, IPointerEnterHandler, IPointerClickHandler
 6 | {
 7 |     public bool state = true;
 8 |     GameObject checkIcon;
 9 |     void Start()
10 |     {
11 | 
12 |         checkIcon = transform.GetChild(0).gameObject;
13 | 
14 |     }
15 |     public void OnPointerClick(PointerEventData eventData)
16 |     {
17 |         state = !state;
18 |         
19 |         if (state)
20 |         {
21 |             checkIcon.SetActive(true);
22 | 
23 |         }
24 |         else
25 |         {
26 |             checkIcon.SetActive(false);
27 |         }
28 |     }
29 |     public void SetFalse()
30 |     {
31 |         state = false;
32 |         checkIcon.SetActive(false);
33 |     }
34 |     public void SetTrue()
35 |     {
36 |         state = true;
37 |         checkIcon.SetActive(true);
38 |     }
39 | 
40 | 
41 |     public void OnPointerEnter(PointerEventData eventData)
42 |     {
43 | 
44 |     }
45 | }
46 | 
47 | 
48 | 
49 |     


--------------------------------------------------------------------------------
/Source Code/Components/UItag.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | 
 4 | public class UItag : MonoBehaviour
 5 | {
 6 |     void Start()
 7 |     {
 8 | 
 9 |     }
10 | 
11 | 
12 |     void Update()
13 |     {
14 | 
15 |     }
16 | }


--------------------------------------------------------------------------------
/Source Code/HarmonyPatches.cs:
--------------------------------------------------------------------------------
 1 | using HarmonyLib;
 2 | using System;
 3 | using System.Reflection;
 4 | 
 5 | namespace SeventysCameraSettingsMod
 6 | {
 7 |     /// <summary>
 8 |     /// This class handles applying harmony patches to the game.
 9 |     /// You should not need to modify this class.
10 |     /// </summary>
11 |     public class HarmonyPatches
12 |     {
13 |         private static Harmony instance;
14 | 
15 |         public static bool IsPatched { get; private set; }
16 |         public const string InstanceId = PluginInfo.GUID;
17 | 
18 |         internal static void ApplyHarmonyPatches()
19 |         {
20 |             if (!IsPatched)
21 |             {
22 |                 if (instance == null)
23 |                 {
24 |                     instance = new Harmony(InstanceId);
25 |                 }
26 | 
27 |                 instance.PatchAll(Assembly.GetExecutingAssembly());
28 |                 IsPatched = true;
29 |             }
30 |         }
31 | 
32 |         internal static void RemoveHarmonyPatches()
33 |         {
34 |             if (instance != null && IsPatched)
35 |             {
36 |                 instance.UnpatchSelf();
37 |                 IsPatched = false;
38 |             }
39 |         }
40 |     }
41 | }
42 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/Editor/LeanTweenDocumentationEditor.cs:
--------------------------------------------------------------------------------
 1 | using UnityEngine;
 2 | using System.Collections;
 3 | #if UNITY_EDITOR
 4 | using UnityEditor;
 5 | 
 6 | public class LeanTweenDocumentationEditor : Editor {
 7 | 
 8 | 	[MenuItem ("Help/LeanTween Documentation")]
 9 | 	static void openDocumentation()
10 | 	{
11 | 		#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3
12 | 		// Loops through all items in case the user has moved the default installation directory
13 | 		string[] guids = AssetDatabase.FindAssets ("LeanTween", null);
14 | 		string documentationPath = "";
15 | 		foreach (string guid in guids){
16 | 			string path = AssetDatabase.GUIDToAssetPath(guid);
17 | 			if(path.IndexOf("classes/LeanTween.html")>=0){
18 | 				documentationPath = path;
19 | 				break;
20 | 			}
21 | 		}
22 | 		documentationPath = documentationPath.Substring(documentationPath.IndexOf("/"));
23 | 		string browserPath = "file://" + Application.dataPath + documentationPath + "#index";
24 | 		Application.OpenURL(browserPath);
25 | 
26 | 		#else
27 | 		// assumes the default installation directory
28 | 		string documentationPath = "file://"+Application.dataPath + "/LeanTween/Documentation/classes/LeanTween.html#index";
29 | 		Application.OpenURL(documentationPath);
30 | 
31 | 		#endif
32 | 	}
33 | 
34 | 	[MenuItem ("Help/LeanTween Forum (ask questions)")]
35 | 	static void openForum()
36 | 	{
37 | 		Application.OpenURL("http://forum.unity3d.com/threads/leantween-a-tweening-engine-that-is-up-to-5x-faster-than-competing-engines.161113/");
38 | 	}
39 | 
40 | 	[MenuItem ("Help/LeanTween GitHub (contribute code)")]
41 | 	static void openGit()
42 | 	{
43 | 		Application.OpenURL("https://github.com/dentedpixel/LeanTween");
44 | 	}
45 | 
46 | 	[MenuItem ("Help/LeanTween Support (donate)")]
47 | 	static void openLTDonate()
48 | 	{
49 | 		Application.OpenURL("https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=YJPUT3RAK5VL8");	
50 | 	}
51 | 
52 | 	[MenuItem ("Help/Dented Pixel News")]
53 | 	static void openDPNews()
54 | 	{
55 | 		Application.OpenURL("http://dentedpixel.com/category/developer-diary/");
56 | 	}
57 | }
58 | 
59 | #endif


--------------------------------------------------------------------------------
/Source Code/LeanTween/Editor/LeanTweenDocumentationEditor.cs.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: 52fea17a2d56d46afa0d6cb52e2a4335
3 | MonoImporter:
4 |   serializedVersion: 2
5 |   defaultReferences: []
6 |   executionOrder: 0
7 |   icon: {instanceID: 0}
8 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LTDescr.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 381c8d6fb1acdc348870a7147bc98723
 3 | timeCreated: 1463137984
 4 | licenseType: Free
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LTDescrOptional.cs:
--------------------------------------------------------------------------------
 1 | //namespace DentedPixel{
 2 | using UnityEngine;
 3 | using System;
 4 | using System.Collections;
 5 | using System.Collections.Generic;
 6 | 
 7 | public class LTDescrOptional  {
 8 | 
 9 | 	public Transform toTrans { get; set; }
10 | 	public Vector3 point { get; set; }
11 | 	public Vector3 axis { get; set; }
12 |     public float lastVal{ get; set; }
13 | 	public Quaternion origRotation { get; set; }
14 | 	public LTBezierPath path { get; set; }
15 | 	public LTSpline spline { get; set; }
16 | 	public AnimationCurve animationCurve;
17 | 	public int initFrameCount;
18 |     public Color color;
19 | 
20 | 	public LTRect ltRect { get; set; } // maybe get rid of this eventually
21 | 
22 | 	public Action<float> onUpdateFloat { get; set; }
23 | 	public Action<float,float> onUpdateFloatRatio { get; set; }
24 | 	public Action<float,object> onUpdateFloatObject { get; set; }
25 | 	public Action<Vector2> onUpdateVector2 { get; set; }
26 | 	public Action<Vector3> onUpdateVector3 { get; set; }
27 | 	public Action<Vector3,object> onUpdateVector3Object { get; set; }
28 | 	public Action<Color> onUpdateColor { get; set; }
29 | 	public Action<Color,object> onUpdateColorObject { get; set; }
30 | 	public Action onComplete { get; set; }
31 | 	public Action<object> onCompleteObject { get; set; }
32 | 	public object onCompleteParam { get; set; }
33 | 	public object onUpdateParam { get; set; }
34 | 	public Action onStart { get; set; }
35 | 
36 | 
37 | //	#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2
38 | //	public SpriteRenderer spriteRen { get; set; }
39 | //	#endif
40 | //
41 | //	#if LEANTWEEN_1
42 | //	public Hashtable optional;
43 | //	#endif
44 | //	#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
45 | //	public RectTransform rectTransform;
46 | //	public UnityEngine.UI.Text uiText;
47 | //	public UnityEngine.UI.Image uiImage;
48 | //	public UnityEngine.Sprite[] sprites;
49 | //	#endif
50 | 
51 | 
52 | 	public void reset(){
53 | 		animationCurve = null;
54 | 
55 | 		this.onUpdateFloat = null;
56 | 		this.onUpdateFloatRatio = null;
57 | 		this.onUpdateVector2 = null;
58 | 		this.onUpdateVector3 = null;
59 | 		this.onUpdateFloatObject = null;
60 | 		this.onUpdateVector3Object = null;
61 | 		this.onUpdateColor = null;
62 | 		this.onComplete = null;
63 | 		this.onCompleteObject = null;
64 | 		this.onCompleteParam = null;
65 | 		this.onStart = null;
66 | 
67 | 		this.point = Vector3.zero;
68 | 		this.initFrameCount = 0;
69 | 	}
70 | 
71 | 	public void callOnUpdate( float val, float ratioPassed){
72 | 		if(this.onUpdateFloat!=null)
73 | 			this.onUpdateFloat(val);
74 | 
75 | 		if (this.onUpdateFloatRatio != null){
76 | 			this.onUpdateFloatRatio(val,ratioPassed);
77 | 		}else if(this.onUpdateFloatObject!=null){
78 | 			this.onUpdateFloatObject(val, this.onUpdateParam);
79 | 		}else if(this.onUpdateVector3Object!=null){
80 | 			this.onUpdateVector3Object(LTDescr.newVect, this.onUpdateParam);
81 | 		}else if(this.onUpdateVector3!=null){
82 | 			this.onUpdateVector3(LTDescr.newVect);
83 | 		}else if(this.onUpdateVector2!=null){
84 | 			this.onUpdateVector2(new Vector2(LTDescr.newVect.x,LTDescr.newVect.y));
85 | 		}
86 | 	}
87 | }
88 | 
89 | //}
90 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LTDescrOptional.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: c1ba8f1ef97134cb39b52ae26678db63
 3 | timeCreated: 1471504769
 4 | licenseType: Free
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LTSeq.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections;
  2 | using System.Collections.Generic;
  3 | using UnityEngine;
  4 | 
  5 | /**
  6 | * Internal Representation of a Sequence<br>
  7 | * <br>
  8 | * &nbsp;&nbsp;<h4>Example:</h4> 
  9 | * var seq = LeanTween.sequence();<br>
 10 | * seq.append(1f); <span style="color:gray">// delay everything one second</span><br>
 11 | * seq.append( () => { <span style="color:gray">// fire an event before start</span><br>
 12 | * &nbsp;Debug.Log("I have started");<br>
 13 | * });<br>
 14 | * seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); <span style="color:gray">// do a tween</span><br>
 15 | * seq.append( (object obj) => { <span style="color:gray">// fire event after tween</span><br>
 16 | * &nbsp;var dict = obj as Dictionary<string,string>;<br>
 17 | * &nbsp;Debug.Log("We are done now obj value:"+dict["hi"]);<br>
 18 | * }, new Dictionary<string,string>(){ {"hi","sup"} } );<br>
 19 | * @class LTSeq
 20 | * @constructor
 21 | */
 22 | public class LTSeq {
 23 | 
 24 | 	public LTSeq previous;
 25 | 
 26 | 	public LTSeq current;
 27 | 
 28 | 	public LTDescr tween;
 29 | 
 30 | 	public float totalDelay;
 31 | 
 32 | 	public float timeScale;
 33 | 
 34 | 	private int debugIter;
 35 | 
 36 | 	public uint counter;
 37 | 
 38 | 	public bool toggle = false;
 39 | 
 40 | 	private uint _id;
 41 | 
 42 | 	public int id{
 43 | 		get{ 
 44 | 			uint toId = _id | counter << 16;
 45 | 
 46 | 			/*uint backId = toId & 0xFFFF;
 47 | 			uint backCounter = toId >> 16;
 48 | 			if(_id!=backId || backCounter!=counter){
 49 | 				Debug.LogError("BAD CONVERSION toId:"+_id);
 50 | 			}*/
 51 | 
 52 | 			return (int)toId;
 53 | 		}
 54 | 	}
 55 | 
 56 | 	public void reset(){
 57 | 		previous = null;
 58 | 		tween = null;
 59 | 		totalDelay = 0f;
 60 | 	}
 61 | 
 62 | 	public void init(uint id, uint global_counter){
 63 | 		reset();
 64 | 		_id = id;
 65 | 
 66 | 		counter = global_counter;
 67 | 
 68 | 		this.current = this;
 69 | 	}
 70 | 
 71 | 	private LTSeq addOn(){
 72 | 		this.current.toggle = true;
 73 | 		LTSeq lastCurrent = this.current;
 74 | 		this.current = LeanTween.sequence(true);
 75 | 		// Debug.Log("this.current:" + this.current.id + " lastCurrent:" + lastCurrent.id);
 76 | 		this.current.previous = lastCurrent;
 77 | 		lastCurrent.toggle = false;
 78 | 		this.current.totalDelay = lastCurrent.totalDelay;
 79 | 		this.current.debugIter = lastCurrent.debugIter + 1;
 80 | 		return current;
 81 | 	}
 82 | 
 83 | 	private float addPreviousDelays(){
 84 | //		Debug.Log("delay:"+delay+" count:"+this.current.count+" this.current.totalDelay:"+this.current.totalDelay);
 85 | 
 86 | 		LTSeq prev = this.current.previous;
 87 | 
 88 | 		if (prev != null && prev.tween!=null) {
 89 |             return this.current.totalDelay + prev.tween.time;
 90 | 		}
 91 |         return this.current.totalDelay;
 92 | 	}
 93 | 
 94 | 	/**
 95 | 	* Add a time delay to the sequence
 96 | 	* @method append (delay)
 97 | 	* @param {float} delay:float amount of time to add to the sequence
 98 | 	* @return {LTSeq} LTDescr an object that distinguishes the tween
 99 | 	* var seq = LeanTween.sequence();<br>
100 | 	* seq.append(1f); // delay everything one second<br>
101 | 	* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a tween<br>
102 | 	*/
103 | 	public LTSeq append( float delay ){
104 |         this.current.totalDelay += delay;
105 | 
106 | 		return this.current;
107 | 	}
108 | 
109 | 	/**
110 | 	* Add a time delay to the sequence
111 | 	* @method append (method)
112 | 	* @param {System.Action} callback:System.Action method you want to be called
113 | 	* @return {LTSeq} LTSeq an object that you can add tweens, methods and time on to
114 | 	* @example
115 | 	* var seq = LeanTween.sequence();<br>
116 | 	* seq.append( () => { // fire an event before start<br>
117 | 	* &nbsp;Debug.Log("I have started");<br>
118 | 	* });<br>
119 | 	* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a tween<br>
120 | 	* seq.append( () => { // fire event after tween<br>
121 | 	* &nbsp;Debug.Log("We are done now");<br>
122 | 	* });;<br>
123 | 	*/
124 | 	public LTSeq append( System.Action callback ){
125 | 		LTDescr newTween = LeanTween.delayedCall(0f, callback);
126 | //		Debug.Log("newTween:" + newTween);
127 | 		return append(newTween);
128 | 	}
129 | 
130 | 	/**
131 | 	* Add a time delay to the sequence
132 | 	* @method add (method(object))
133 | 	* @param {System.Action} callback:System.Action method you want to be called
134 | 	* @return {LTSeq} LTSeq an object that you can add tweens, methods and time on to
135 | 	* @example
136 | 	* var seq = LeanTween.sequence();<br>
137 | 	* seq.append( () => { // fire an event before start<br>
138 | 	* &nbsp;Debug.Log("I have started");<br>
139 | 	* });<br>
140 | 	* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a tween<br>
141 | 	* seq.append((object obj) => { // fire event after tween
142 | 	* &nbsp;var dict = obj as Dictionary<string,string>;
143 | 	* &nbsp;Debug.Log("We are done now obj value:"+dict["hi"]);
144 | 	* &nbsp;}, new Dictionary<string,string>(){ {"hi","sup"} } );
145 | 	*/
146 | 	public LTSeq append( System.Action<object> callback, object obj ){
147 | 		append(LeanTween.delayedCall(0f, callback).setOnCompleteParam(obj));
148 | 
149 | 		return addOn();
150 | 	}
151 | 
152 | 	public LTSeq append( GameObject gameObject, System.Action callback ){
153 | 		append(LeanTween.delayedCall(gameObject, 0f, callback));
154 | 
155 | 		return addOn();
156 | 	}
157 | 
158 | 	public LTSeq append( GameObject gameObject, System.Action<object> callback, object obj ){
159 | 		append(LeanTween.delayedCall(gameObject, 0f, callback).setOnCompleteParam(obj));
160 | 
161 | 		return addOn();
162 | 	}
163 | 
164 | 	/**
165 | 	* Retrieve a sequencer object where you can easily chain together tweens and methods one after another
166 | 	* 
167 | 	* @method add (tween)
168 | 	* @return {LTSeq} LTSeq an object that you can add tweens, methods and time on to
169 | 	* @example
170 | 	* var seq = LeanTween.sequence();<br>
171 | 	* seq.append( LeanTween.move(cube1, Vector3.one * 10f, 1f) ); // do a move tween<br>
172 | 	* seq.append( LeanTween.rotateAround( avatar1, Vector3.forward, 360f, 1f ) ); // then do a rotate tween<br>
173 | 	*/
174 | 	public LTSeq append( LTDescr tween ){
175 | 		this.current.tween = tween;
176 | 
177 | //		Debug.Log("tween:" + tween + " delay:" + this.current.totalDelay);
178 | 
179 |         this.current.totalDelay = addPreviousDelays();
180 | 
181 | 		tween.setDelay( this.current.totalDelay );
182 | 
183 | 		return addOn();
184 | 	}
185 | 
186 | 	public LTSeq insert( LTDescr tween ){
187 | 		this.current.tween = tween;
188 | 
189 |         tween.setDelay( addPreviousDelays() );
190 | 
191 | 		return addOn();
192 | 	}
193 | 
194 | 
195 | 	public LTSeq setScale( float timeScale ){
196 | //		Debug.Log("this.current:" + this.current.previous.debugIter+" tween:"+this.current.previous.tween);
197 | 		setScaleRecursive(this.current, timeScale, 500);
198 | 
199 | 		return addOn();
200 | 	}
201 | 
202 | 	private void setScaleRecursive( LTSeq seq, float timeScale, int count ){
203 | 		if (count > 0) {
204 | 			this.timeScale = timeScale;
205 | 
206 | //			Debug.Log("seq.count:" + count + " seq.tween:" + seq.tween);
207 | 			seq.totalDelay *= timeScale;
208 | 			if (seq.tween != null) {
209 | //			Debug.Log("seq.tween.time * timeScale:" + seq.tween.time * timeScale + " seq.totalDelay:"+seq.totalDelay +" time:"+seq.tween.time+" seq.tween.delay:"+seq.tween.delay);
210 | 				if (seq.tween.time != 0f)
211 | 					seq.tween.setTime(seq.tween.time * timeScale);
212 | 				seq.tween.setDelay(seq.tween.delay * timeScale);
213 | 			}
214 | 
215 | 			if (seq.previous != null)
216 | 				setScaleRecursive(seq.previous, timeScale, count - 1);
217 | 		}
218 | 	}
219 | 
220 | 	public LTSeq reverse(){
221 | 
222 | 		return addOn();
223 | 	}
224 | 
225 | }
226 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LTSeq.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 6c88dbe4cdd9944f198e9796ee394c86
 3 | timeCreated: 1488665079
 4 | licenseType: Free
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanAudio.cs:
--------------------------------------------------------------------------------
  1 | 
  2 | using UnityEngine;
  3 | using System.Collections.Generic;
  4 | 
  5 | public class LeanAudioStream {
  6 | 
  7 | 	public int position = 0;
  8 | 
  9 | 	public AudioClip audioClip;
 10 | 	public float[] audioArr;
 11 | 
 12 | 	public LeanAudioStream( float[] audioArr ){
 13 | 		this.audioArr = audioArr;
 14 | 	}
 15 | 
 16 | 	public void OnAudioRead(float[] data) {
 17 |         int count = 0;
 18 |         while (count < data.Length) {
 19 |             data[count] = audioArr[this.position];
 20 |             position++;
 21 |             count++;
 22 |         }
 23 |     }
 24 | 
 25 |     public void OnAudioSetPosition(int newPosition) {
 26 |     	this.position = newPosition;   
 27 |     }
 28 | }
 29 | 
 30 | /**
 31 | * Create Audio dynamically and easily playback
 32 | *
 33 | * @class LeanAudio
 34 | * @constructor
 35 | */
 36 | public class LeanAudio : object {
 37 | 
 38 | 	public static float MIN_FREQEUNCY_PERIOD = 0.000115f;
 39 | 	public static int PROCESSING_ITERATIONS_MAX = 50000;
 40 | 	public static float[] generatedWaveDistances;
 41 | 	public static int generatedWaveDistancesCount = 0;
 42 | 
 43 | 	private static float[] longList;
 44 | 
 45 | 	public static LeanAudioOptions options(){
 46 | 		if(generatedWaveDistances==null){
 47 | 			generatedWaveDistances = new float[ PROCESSING_ITERATIONS_MAX ];
 48 | 			longList = new float[ PROCESSING_ITERATIONS_MAX ];
 49 | 		}
 50 | 		return new LeanAudioOptions();
 51 | 	}
 52 | 
 53 | 	public static LeanAudioStream createAudioStream( AnimationCurve volume, AnimationCurve frequency, LeanAudioOptions options = null ){
 54 | 		if(options==null)
 55 | 			options = new LeanAudioOptions();
 56 | 
 57 | 		options.useSetData = false;
 58 | 
 59 | 		int generatedWavePtsLength = createAudioWave( volume, frequency, options);
 60 | 		createAudioFromWave( generatedWavePtsLength, options );
 61 | 
 62 | 		return options.stream;
 63 | 	}
 64 | 
 65 | 	/**
 66 | 	* Create dynamic audio from a set of Animation Curves and other options.
 67 | 	* 
 68 | 	* @method createAudio
 69 | 	* @param {AnimationCurve} volumeCurve:AnimationCurve describing the shape of the audios volume (from 0-1). The length of the audio is dicated by the end value here.
 70 | 	* @param {AnimationCurve} frequencyCurve:AnimationCurve describing the width of the oscillations between the sound waves in seconds. Large numbers mean a lower note, while higher numbers mean a tighter frequency and therefor a higher note. Values are usually between 0.01 and 0.000001 (or smaller)
 71 | 	* @param {LeanAudioOptions} options:LeanAudioOptions You can pass any other values in here like vibrato or the frequency you would like the sound to be encoded at. See <a href="LeanAudioOptions.html">LeanAudioOptions</a> for more details.
 72 | 	* @return {AudioClip} AudioClip of the procedurally generated audio
 73 | 	* @example
 74 | 	* AnimationCurve volumeCurve = new AnimationCurve( new Keyframe(0f, 1f, 0f, -1f), new Keyframe(1f, 0f, -1f, 0f));<br>
 75 | 	* AnimationCurve frequencyCurve = new AnimationCurve( new Keyframe(0f, 0.003f, 0f, 0f), new Keyframe(1f, 0.003f, 0f, 0f));<br>
 76 | 	* AudioClip audioClip = LeanAudio.createAudio(volumeCurve, frequencyCurve, LeanAudio.options().setVibrato( new Vector3[]{ new Vector3(0.32f,0f,0f)} ));<br>
 77 | 	*/
 78 | 	public static AudioClip createAudio( AnimationCurve volume, AnimationCurve frequency, LeanAudioOptions options = null ){
 79 | 		if(options==null)
 80 | 			options = new LeanAudioOptions();
 81 | 		
 82 | 		int generatedWavePtsLength = createAudioWave( volume, frequency, options);
 83 | 		// Debug.Log("generatedWavePtsLength:"+generatedWavePtsLength);
 84 | 		return createAudioFromWave( generatedWavePtsLength, options );
 85 | 	}
 86 | 
 87 | 	private static int createAudioWave( AnimationCurve volume, AnimationCurve frequency, LeanAudioOptions options ){
 88 | 		float time = volume[ volume.length - 1 ].time;
 89 | 		int listLength = 0;
 90 | 		// List<float> list = new List<float>();
 91 | 
 92 | 		// generatedWaveDistances = new List<float>();
 93 | 		// float[] vibratoValues = new float[ vibrato.Length ];
 94 | 		float passed = 0f;
 95 | 		for(int i = 0; i < PROCESSING_ITERATIONS_MAX; i++){
 96 | 			float f = frequency.Evaluate(passed);
 97 | 			if(f<MIN_FREQEUNCY_PERIOD)
 98 | 				f = MIN_FREQEUNCY_PERIOD;
 99 | 			float height = volume.Evaluate(passed + 0.5f*f);
100 | 			if(options.vibrato!=null){
101 | 				for(int j=0; j<options.vibrato.Length; j++){
102 | 					float peakMulti = Mathf.Abs( Mathf.Sin( 1.5708f + passed * (1f/options.vibrato[j][0]) * Mathf.PI ) );
103 | 					float diff = (1f-options.vibrato[j][1]);
104 | 					peakMulti = options.vibrato[j][1] + diff*peakMulti;
105 | 					height *= peakMulti;
106 | 				}	
107 | 			}
108 | 
109 | 			
110 | 			// Debug.Log("i:"+i+" f:"+f+" passed:"+passed+" height:"+height+" time:"+time);
111 | 			if(passed + 0.5f*f>=time)
112 | 				break;
113 | 			if(listLength >= PROCESSING_ITERATIONS_MAX-1){
114 | 				Debug.LogError("LeanAudio has reached it's processing cap. To avoid this error increase the number of iterations ex: LeanAudio.PROCESSING_ITERATIONS_MAX = "+(PROCESSING_ITERATIONS_MAX*2));
115 | 				break;
116 | 			}else{
117 | 				int distPoint = listLength / 2;
118 | 				
119 | 				//generatedWaveDistances.Add( f );
120 | 				passed += f;
121 | 
122 | 				generatedWaveDistances[ distPoint ] = passed;
123 | 				//Debug.Log("distPoint:"+distPoint+" passed:"+passed);
124 | 
125 | 				//list.Add( passed );
126 | 				//list.Add( i%2==0 ? -height : height );
127 | 
128 | 				longList[ listLength ] = passed;
129 | 				longList[ listLength + 1 ] = i%2==0 ? -height : height;
130 | 			}
131 | 
132 | 			
133 | 
134 | 			listLength += 2;
135 | 			
136 | 		}
137 | 
138 | 		listLength += -2;
139 | 		generatedWaveDistancesCount = listLength / 2;
140 | 
141 | 		/*float[] wave = new float[ listLength ];
142 | 		for(int i = 0; i < wave.Length; i++){
143 | 			wave[i] = longList[i];
144 | 		}*/
145 | 		return listLength;
146 | 	}
147 | 
148 | 	private static AudioClip createAudioFromWave( int waveLength, LeanAudioOptions options ){
149 | 		float time = longList[ waveLength - 2 ];
150 | 		float[] audioArr = new float[ (int)(options.frequencyRate*time) ];
151 | 
152 | 		int waveIter = 0;
153 | 		float subWaveDiff = longList[waveIter];
154 | 		float subWaveTimeLast = 0f;
155 | 		float subWaveTime = longList[waveIter];
156 | 		float waveHeight = longList[waveIter+1];
157 | 		for(int i = 0; i < audioArr.Length; i++){
158 | 			float passedTime = (float)i / (float)options.frequencyRate;
159 | 			if(passedTime > longList[waveIter] ){
160 | 				subWaveTimeLast = longList[waveIter];
161 | 				waveIter += 2;
162 | 				subWaveDiff = longList[waveIter] - longList[waveIter-2];
163 | 				waveHeight = longList[waveIter+1];
164 | 				// Debug.Log("passed wave i:"+i);
165 | 			}
166 | 			subWaveTime = passedTime - subWaveTimeLast;
167 | 			float ratioElapsed = subWaveTime / subWaveDiff;
168 | 
169 | 			float value = Mathf.Sin( ratioElapsed * Mathf.PI );
170 | 
171 | 			if(options.waveStyle==LeanAudioOptions.LeanAudioWaveStyle.Square){
172 | 				if(value>0f)
173 | 					value = 1f;
174 | 				if(value<0f)
175 | 					value = -1f;
176 | 			}else if(options.waveStyle==LeanAudioOptions.LeanAudioWaveStyle.Sawtooth){
177 | 				float sign = value > 0f ? 1f : -1f;
178 | 				if(ratioElapsed<0.5f){
179 | 					value = (ratioElapsed*2f)*sign;
180 | 				}else{ // 0.5f - 1f
181 | 					value = (1f - ratioElapsed)*2f*sign;
182 | 				}
183 | 			}else if(options.waveStyle==LeanAudioOptions.LeanAudioWaveStyle.Noise){
184 | 				float peakMulti = (1f-options.waveNoiseInfluence) + Mathf.PerlinNoise(0f, passedTime * options.waveNoiseScale ) * options.waveNoiseInfluence;
185 | 				
186 | 				/*if(i<25){
187 | 					Debug.Log("passedTime:"+passedTime+" peakMulti:"+peakMulti+" infl:"+options.waveNoiseInfluence);
188 | 				}*/
189 | 
190 | 				value *= peakMulti;
191 | 			}
192 | 			
193 | 			//if(i<25)
194 | 			//	Debug.Log("passedTime:"+passedTime+" value:"+value+" ratioElapsed:"+ratioElapsed+" subWaveTime:"+subWaveTime+" subWaveDiff:"+subWaveDiff);
195 | 			
196 | 			value *= waveHeight;
197 | 
198 | 
199 | 			if(options.modulation!=null){
200 | 				for(int k=0; k<options.modulation.Length; k++){
201 | 					float peakMulti = Mathf.Abs( Mathf.Sin( 1.5708f + passedTime * (1f/options.modulation[k][0]) * Mathf.PI ) );
202 | 					float diff = (1f-options.modulation[k][1]);
203 | 					peakMulti = options.modulation[k][1] + diff*peakMulti;
204 | 					// if(k<10){
205 | 						// Debug.Log("k:"+k+" peakMulti:"+peakMulti+" value:"+value+" after:"+(value*peakMulti));
206 | 					// }
207 | 					value *= peakMulti;
208 | 				}	
209 | 			}
210 | 
211 | 			audioArr[i] = value;
212 | 			// Debug.Log("pt:"+pt+" i:"+i+" val:"+audioArr[i]+" len:"+audioArr.Length);
213 | 		}
214 | 
215 | 		
216 | 		int lengthSamples = audioArr.Length;
217 | 		
218 | 		#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7
219 | 		bool is3dSound = false;
220 | 		AudioClip audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, options.frequencyRate, is3dSound, false);
221 | 		#else
222 | 		AudioClip audioClip = null;
223 | 		if(options.useSetData){
224 | 			audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, options.frequencyRate, false, null, OnAudioSetPosition);
225 | 			audioClip.SetData(audioArr, 0);
226 | 		}else{
227 | 			options.stream = new LeanAudioStream(audioArr);
228 | 			// Debug.Log("len:"+audioArr.Length+" lengthSamples:"+lengthSamples+" freqRate:"+options.frequencyRate);
229 | 			audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, options.frequencyRate, false, options.stream.OnAudioRead, options.stream.OnAudioSetPosition);
230 | 			options.stream.audioClip = audioClip;
231 | 		}
232 | 		
233 | 		#endif
234 | 
235 | 		return audioClip;
236 | 	}
237 | 
238 | 	private static void OnAudioSetPosition(int newPosition) {
239 |         
240 |     }
241 | 
242 | 	public static AudioClip generateAudioFromCurve( AnimationCurve curve, int frequencyRate = 44100 ){
243 | 		float curveTime = curve[ curve.length - 1 ].time;
244 | 		float time = curveTime;
245 | 		float[] audioArr = new float[ (int)(frequencyRate*time) ];
246 | 
247 | 		// Debug.Log("curveTime:"+curveTime+" AudioSettings.outputSampleRate:"+AudioSettings.outputSampleRate);
248 | 		for(int i = 0; i < audioArr.Length; i++){
249 | 			float pt = (float)i / (float)frequencyRate;
250 | 			audioArr[i] = curve.Evaluate( pt );
251 | 			// Debug.Log("pt:"+pt+" i:"+i+" val:"+audioArr[i]+" len:"+audioArr.Length);
252 | 		}
253 | 
254 | 		int lengthSamples = audioArr.Length;//(int)( (float)frequencyRate * curveTime );
255 | 		#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2 || UNITY_4_3 || UNITY_4_5 || UNITY_4_6 || UNITY_4_7
256 | 		bool is3dSound = false;
257 | 		AudioClip audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, frequencyRate, is3dSound, false);
258 | 		#else
259 | 		AudioClip audioClip = AudioClip.Create("Generated Audio", lengthSamples, 1, frequencyRate, false);
260 | 		#endif
261 | 		audioClip.SetData(audioArr, 0);
262 | 
263 | 		return audioClip;
264 | 	}
265 | 
266 | 	public static AudioSource play( AudioClip audio, float volume ){
267 | 		AudioSource audioSource = playClipAt(audio, Vector3.zero);
268 | 		audioSource.volume = volume;
269 | 		return audioSource; 
270 | 	}
271 | 
272 | 	public static AudioSource play( AudioClip audio ){
273 | 		return playClipAt( audio, Vector3.zero ); 
274 | 	}
275 | 
276 | 	public static AudioSource play( AudioClip audio, Vector3 pos ){
277 | 		return playClipAt( audio, pos ); 
278 | 	}
279 | 
280 | 	public static AudioSource play( AudioClip audio, Vector3 pos, float volume ){
281 | 		// Debug.Log("audio length:"+audio.length);
282 | 		AudioSource audioSource = playClipAt(audio, pos);
283 | 		audioSource.minDistance = 1f;
284 | 		//audioSource.pitch = pitch;
285 | 		audioSource.volume = volume;
286 | 
287 | 		return audioSource;
288 | 	}
289 | 
290 | 	public static AudioSource playClipAt( AudioClip clip, Vector3 pos ) {
291 | 		GameObject tempGO = new GameObject(); // create the temp object
292 | 		tempGO.transform.position = pos; // set its position
293 | 		AudioSource aSource = tempGO.AddComponent<AudioSource>(); // add an audio source
294 | 		aSource.clip = clip; // define the clip
295 | 		aSource.Play(); // start the sound
296 | 		GameObject.Destroy(tempGO, clip.length); // destroy object after clip duration
297 | 		return aSource; // return the AudioSource reference
298 | 	}
299 | 
300 | 	public static void printOutAudioClip( AudioClip audioClip, ref AnimationCurve curve, float scaleX = 1f ){
301 | 		// Debug.Log("Audio channels:"+audioClip.channels+" frequency:"+audioClip.frequency+" length:"+audioClip.length+" samples:"+audioClip.samples);
302 | 		float[] samples = new float[audioClip.samples * audioClip.channels];
303 |         audioClip.GetData(samples, 0);
304 |         int i = 0;
305 | 
306 |         Keyframe[] frames = new Keyframe[samples.Length];
307 |         while (i < samples.Length) {
308 |            frames[i] = new Keyframe( (float)i * scaleX, samples[i] );
309 |            ++i;
310 |         }
311 |         curve = new AnimationCurve( frames );
312 | 	}
313 | }
314 | 
315 | 
316 | /**
317 | * Pass in options to LeanAudio
318 | *
319 | * @class LeanAudioOptions
320 | * @constructor
321 | */
322 | public class LeanAudioOptions : object {
323 | 
324 | 	public enum LeanAudioWaveStyle{
325 | 		Sine,
326 | 		Square,
327 | 		Sawtooth,
328 | 		Noise
329 | 	}
330 | 
331 | 	public LeanAudioWaveStyle waveStyle = LeanAudioWaveStyle.Sine;
332 | 	public Vector3[] vibrato;
333 | 	public Vector3[] modulation;
334 | 	public int frequencyRate = 44100;
335 | 	public float waveNoiseScale = 1000;
336 | 	public float waveNoiseInfluence = 1f;
337 | 
338 | 	public bool useSetData = true;
339 | 	public LeanAudioStream stream;
340 | 
341 | 	public LeanAudioOptions(){}
342 | 
343 | 	/**
344 | 	* Set the frequency for the audio is encoded. 44100 is CD quality, but you can usually get away with much lower (or use a lower amount to get a more 8-bit sound).
345 | 	* 
346 | 	* @method setFrequency
347 | 	* @param {int} frequencyRate:int of the frequency you wish to encode the AudioClip at
348 | 	* @return {LeanAudioOptions} LeanAudioOptions describing optional values
349 | 	* @example
350 | 	* AnimationCurve volumeCurve = new AnimationCurve( new Keyframe(0f, 1f, 0f, -1f), new Keyframe(1f, 0f, -1f, 0f));<br>
351 | 	* AnimationCurve frequencyCurve = new AnimationCurve( new Keyframe(0f, 0.003f, 0f, 0f), new Keyframe(1f, 0.003f, 0f, 0f));<br>
352 | 	* AudioClip audioClip = LeanAudio.createAudio(volumeCurve, frequencyCurve, LeanAudio.options().setVibrato( new Vector3[]{ new Vector3(0.32f,0f,0f)} ).setFrequency(12100) );<br>
353 | 	*/
354 | 	public LeanAudioOptions setFrequency( int frequencyRate ){
355 | 		this.frequencyRate = frequencyRate;
356 | 		return this;
357 | 	}
358 | 
359 | 	/**
360 | 	* Set details about the shape of the curve by adding vibrato modulations through it (alters the peak values giving it a wah-wah effect). You can add as many as you want to sculpt out more detail in the sound wave.
361 | 	* 
362 | 	* @method setVibrato
363 | 	* @param {Vector3[]} vibratoArray:Vector3[] The first value is the period in seconds that you wish to have the vibrato wave fluctuate at. The second value is the minimum height you wish the vibrato wave to dip down to (default is zero). The third is reserved for future effects.
364 | 	* @return {LeanAudioOptions} LeanAudioOptions describing optional values
365 | 	* @example
366 | 	* AnimationCurve volumeCurve = new AnimationCurve( new Keyframe(0f, 1f, 0f, -1f), new Keyframe(1f, 0f, -1f, 0f));<br>
367 | 	* AnimationCurve frequencyCurve = new AnimationCurve( new Keyframe(0f, 0.003f, 0f, 0f), new Keyframe(1f, 0.003f, 0f, 0f));<br>
368 | 	* AudioClip audioClip = LeanAudio.createAudio(volumeCurve, frequencyCurve, LeanAudio.options().setVibrato( new Vector3[]{ new Vector3(0.32f,0.3f,0f)} ).setFrequency(12100) );<br>
369 | 	*/
370 | 	public LeanAudioOptions setVibrato( Vector3[] vibrato ){
371 | 		this.vibrato = vibrato;
372 | 		return this;
373 | 	}
374 | 
375 | 	/*
376 | 	public LeanAudioOptions setModulation( Vector3[] modulation ){
377 | 		this.modulation = modulation;
378 | 		return this;
379 | 	}*/
380 | 
381 | 	public LeanAudioOptions setWaveSine(){
382 | 		this.waveStyle = LeanAudioWaveStyle.Sine;
383 | 		return this;
384 | 	}
385 | 
386 | 	public LeanAudioOptions setWaveSquare(){
387 | 		this.waveStyle = LeanAudioWaveStyle.Square;
388 | 		return this;
389 | 	}
390 | 
391 | 	public LeanAudioOptions setWaveSawtooth(){
392 | 		this.waveStyle = LeanAudioWaveStyle.Sawtooth;
393 | 		return this;
394 | 	}
395 | 
396 | 	public LeanAudioOptions setWaveNoise(){
397 | 		this.waveStyle = LeanAudioWaveStyle.Noise;
398 | 		return this;
399 | 	}
400 | 
401 | 	public LeanAudioOptions setWaveStyle( LeanAudioWaveStyle style ){
402 | 		this.waveStyle = style;
403 | 		return this;
404 | 	}
405 | 
406 | 
407 | 	public LeanAudioOptions setWaveNoiseScale( float waveScale ){
408 | 		this.waveNoiseScale = waveScale;
409 | 		return this;
410 | 	}
411 | 
412 | 	public LeanAudioOptions setWaveNoiseInfluence( float influence ){
413 | 		this.waveNoiseInfluence = influence;
414 | 		return this;
415 | 	}
416 | }
417 | 
418 | 
419 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanAudio.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 52e41e970d9353942b27458440bec9eb
 3 | timeCreated: 1427917971
 4 | licenseType: Free
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanSmooth.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections;
  2 | using System.Collections.Generic;
  3 | using UnityEngine;
  4 | 
  5 | /**
  6 | * Use these smooth methods to move one value towards another<br /><br />
  7 | * <strong>Example: </strong><br />fromY = LeanSmooth.spring(fromY, followArrow.localPosition.y, ref velocityY, 1.1f);<br />
  8 | * fromVec3 = LeanSmooth.damp(fromVec3, dude5Title.localPosition, ref velocityVec3, 1.1f);<br />
  9 | * fromColor = LeanSmooth.damp(fromColor, dude5Title.GetComponent<Renderer>().material.color, ref velocityColor, 1.1f);<br />
 10 | * Debug.Log("Smoothed y:" + fromY + " vec3:" + fromVec3 + " color:" + fromColor);<br />
 11 | *
 12 | * @class LeanSmooth
 13 | */
 14 | 
 15 | public class LeanSmooth {
 16 | 
 17 | 
 18 |     /**
 19 |     * <summary>Moves one value towards another (eases in and out to destination with no overshoot)</summary>
 20 |     * 
 21 |     * @method LeanSmooth.damp (float)
 22 |     * @param {float} current:float the current value
 23 |     * @param {float} target:float the value we are trying to reach
 24 |     * @param {float} currentVelocity:float the current velocity of the value
 25 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
 26 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
 27 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
 28 |     * @example
 29 |     * followVar = LeanSmooth.damp(followVar, destinationVar, ref followVelocity, 1.1f);\n
 30 |     * Debug.Log("current:"+followVar);
 31 |     */
 32 |     public static float damp(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f)
 33 |     {
 34 |         if (deltaTime < 0f)
 35 |             deltaTime = Time.deltaTime;
 36 | 
 37 |         smoothTime = Mathf.Max(0.0001f, smoothTime);
 38 |         float num = 2f / smoothTime;
 39 |         float num2 = num * deltaTime;
 40 |         float num3 = 1f / (1f + num2 + 0.48f * num2 * num2 + 0.235f * num2 * num2 * num2);
 41 |         float num4 = current - target;
 42 |         float num5 = target;
 43 |         if (maxSpeed > 0f)
 44 |         {
 45 |             float num6 = maxSpeed * smoothTime;
 46 |             num4 = Mathf.Clamp(num4, -num6, num6);
 47 |         }
 48 |         target = current - num4;
 49 |         float num7 = (currentVelocity + num * num4) * deltaTime;
 50 |         currentVelocity = (currentVelocity - num * num7) * num3;
 51 |         float num8 = target + (num4 + num7) * num3;
 52 |         if (num5 - current > 0f == num8 > num5)
 53 |         {
 54 |             num8 = num5;
 55 |             currentVelocity = (num8 - num5) / deltaTime;
 56 |         }
 57 |         return num8;
 58 |     }
 59 | 
 60 |     /**
 61 |     * <summary>Moves one value towards another (eases in and out to destination with no overshoot)</summary>
 62 |     * 
 63 |     * @method LeanSmooth.damp (Vector3)
 64 |     * @param {float} current:Vector3 the current value
 65 |     * @param {float} target:Vector3 the value we are trying to reach
 66 |     * @param {float} currentVelocity:Vector3 the current velocity of the value
 67 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
 68 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
 69 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
 70 |     * @example
 71 |     * transform.position = LeanSmooth.damp(transform.position, destTrans.position, ref followVelocity, 1.1f);\n
 72 |     * Debug.Log("current:"+transform.position);
 73 |     */
 74 |     public static Vector3 damp(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f)
 75 |     {
 76 |         float x = damp(current.x, target.x, ref currentVelocity.x, smoothTime, maxSpeed, deltaTime);
 77 |         float y = damp(current.y, target.y, ref currentVelocity.y, smoothTime, maxSpeed, deltaTime);
 78 |         float z = damp(current.z, target.z, ref currentVelocity.z, smoothTime, maxSpeed, deltaTime);
 79 | 
 80 |         return new Vector3(x, y, z);
 81 |     }
 82 | 
 83 |     /**
 84 |     * <summary>Moves one color value towards another color (eases in and out to destination with no overshoot)</summary>
 85 |     * 
 86 |     * @method LeanSmooth.damp (Color)
 87 |     * @param {float} current:Color the current value
 88 |     * @param {float} target:Color the value we are trying to reach
 89 |     * @param {float} currentVelocity:Color the current velocity of the value
 90 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
 91 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
 92 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
 93 |     * @example
 94 |     * fromColor = LeanSmooth.damp(fromColor, transform.GetComponent<Renderer>().material.color, ref velocityColor, 1.1f);\n
 95 |     * Debug.Log("current:"+fromColor);
 96 |     */
 97 |     public static Color damp(Color current, Color target, ref Color currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f)
 98 |     {
 99 |         float r = damp(current.r, target.r, ref currentVelocity.r, smoothTime, maxSpeed, deltaTime);
100 |         float g = damp(current.g, target.g, ref currentVelocity.g, smoothTime, maxSpeed, deltaTime);
101 |         float b = damp(current.b, target.b, ref currentVelocity.b, smoothTime, maxSpeed, deltaTime);
102 |         float a = damp(current.a, target.a, ref currentVelocity.a, smoothTime, maxSpeed, deltaTime);
103 | 
104 |         return new Color(r, g, b, a);
105 |     }
106 | 
107 |     /**
108 |     * <summary>Moves one value towards another (eases in and out to destination with possible overshoot bounciness)</summary>
109 |     * 
110 |     * @method LeanSmooth.spring (float)
111 |     * @param {float} current:float the current value
112 |     * @param {float} target:float the value we are trying to reach
113 |     * @param {float} currentVelocity:float the current velocity of the value
114 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
115 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
116 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
117 |     * @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
118 |     * @param {float} [accelRate]:float the rate it accelerates from it's initial position
119 |     * @example
120 |     * followVar = LeanSmooth.spring(followVar, destinationVar, ref followVelocity, 1.1f);\n
121 |     * Debug.Log("current:"+followVar);
122 |     */
123 |     public static float spring(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f)
124 |     {
125 |         if (deltaTime < 0f)
126 |             deltaTime = Time.deltaTime;
127 | 
128 |         float diff = target - current;
129 | 
130 |         currentVelocity += deltaTime / smoothTime * accelRate * diff;
131 | 
132 |         currentVelocity *= (1f - deltaTime * friction);
133 | 
134 |         if (maxSpeed > 0f && maxSpeed < Mathf.Abs(currentVelocity))
135 |             currentVelocity = maxSpeed * Mathf.Sign(currentVelocity);
136 | 
137 |         float returned = current + currentVelocity;
138 | 
139 |         return returned;
140 |     }
141 | 
142 |     /**
143 |     * <summary>Moves one value towards another (eases in and out to destination with possible overshoot bounciness)</summary>
144 |     * 
145 |     * @method LeanSmooth.spring (Vector3)
146 |     * @param {Vector3} current:float the current value
147 |     * @param {Vector3} target:float the value we are trying to reach
148 |     * @param {Vector3} currentVelocity:float the current velocity of the value
149 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
150 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
151 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
152 |     * @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
153 |     * @param {float} [accelRate]:float the rate it accelerates from it's initial position
154 |     * @example
155 |     * transform.position = LeanSmooth.spring(transform.position, destTrans.position, ref followVelocity, 1.1f);\n
156 |     * Debug.Log("current:"+transform.position);
157 |     */
158 |     public static Vector3 spring(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f)
159 |     {
160 |         float x = spring(current.x, target.x, ref currentVelocity.x, smoothTime, maxSpeed, deltaTime, friction, accelRate);
161 |         float y = spring(current.y, target.y, ref currentVelocity.y, smoothTime, maxSpeed, deltaTime, friction, accelRate);
162 |         float z = spring(current.z, target.z, ref currentVelocity.z, smoothTime, maxSpeed, deltaTime, friction, accelRate);
163 | 
164 |         return new Vector3(x, y, z);
165 |     }
166 | 
167 |     /**
168 |     * <summary>Moves one color towards another (eases in and out to destination with possible overshoot bounciness)</summary>
169 |     * 
170 |     * @method LeanSmooth.spring (Color)
171 |     * @param {Color} current:float the current value
172 |     * @param {Color} target:float the value we are trying to reach
173 |     * @param {Color} currentVelocity:float the current velocity of the value
174 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
175 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
176 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
177 |     * @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
178 |     * @param {float} [accelRate]:float the rate it accelerates from it's initial position
179 |     * @example
180 |     * fromColor = LeanSmooth.spring(fromColor, transform.GetComponent<Renderer>().material.color, ref velocityColor, 1.1f);\n
181 |     * Debug.Log("current:"+fromColor);
182 |     */
183 |     public static Color spring(Color current, Color target, ref Color currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f)
184 |     {
185 |         float r = spring(current.r, target.r, ref currentVelocity.r, smoothTime, maxSpeed, deltaTime, friction, accelRate);
186 |         float g = spring(current.g, target.g, ref currentVelocity.g, smoothTime, maxSpeed, deltaTime, friction, accelRate);
187 |         float b = spring(current.b, target.b, ref currentVelocity.b, smoothTime, maxSpeed, deltaTime, friction, accelRate);
188 |         float a = spring(current.a, target.a, ref currentVelocity.a, smoothTime, maxSpeed, deltaTime, friction, accelRate);
189 | 
190 |         return new Color(r, g, b, a);
191 |     }
192 | 
193 |     /**
194 |     * <summary>Moves one value towards another (at a constant speed)</summary>
195 |     * 
196 |     * @method LeanSmooth.linear (float)
197 |     * @param {float} current:float the current value
198 |     * @param {float} target:float the value we are trying to reach
199 |     * @param {float} moveSpeed:float the speed at which to move towards the target
200 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
201 |     * @example
202 |     * followVar = LeanSmooth.linear(followVar, destinationVar, 50f);\n
203 |     * Debug.Log("current:"+followVar);
204 |     */
205 |     public static float linear(float current, float target, float moveSpeed, float deltaTime = -1f)
206 |     {
207 |         if (deltaTime < 0f)
208 |             deltaTime = Time.deltaTime;
209 | 
210 |         bool targetGreater = (target > current);
211 | 
212 |         float currentVelocity = deltaTime * moveSpeed * (targetGreater ? 1f : -1f);
213 | 
214 |         float returned = current + currentVelocity;
215 | 
216 |         float returnPassed = returned - target;
217 |         if ((targetGreater && returnPassed > 0) || !targetGreater && returnPassed < 0)
218 |         { // Has passed point, return target
219 |             return target;
220 |         }
221 | 
222 |         return returned;
223 |     }
224 | 
225 |     /**
226 |     * <summary>Moves one value towards another (at a constant speed)</summary>
227 |     * 
228 |     * @method LeanSmooth.linear (Vector3)
229 |     * @param {Vector3} current:float the current value
230 |     * @param {Vector3} target:float the value we are trying to reach
231 |     * @param {float} moveSpeed:float the speed at which to move towards the target
232 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
233 |     * @example
234 |     * transform.position = LeanSmooth.linear(transform.position, followTrans.position, 50f);\n
235 |     * Debug.Log("current:"+transform.position);
236 |     */
237 |     public static Vector3 linear(Vector3 current, Vector3 target, float moveSpeed, float deltaTime = -1f)
238 |     {
239 |         float x = linear(current.x, target.x, moveSpeed, deltaTime);
240 |         float y = linear(current.y, target.y, moveSpeed, deltaTime);
241 |         float z = linear(current.z, target.z, moveSpeed, deltaTime);
242 | 
243 |         return new Vector3(x, y, z);
244 |     }
245 | 
246 |     /**
247 |     * <summary>Moves one color towards another (at a constant speed)</summary>
248 |     * 
249 |     * @method LeanSmooth.linear (Color)
250 |     * @param {Color} current:float the current value
251 |     * @param {Color} target:float the value we are trying to reach
252 |     * @param {float} moveSpeed:float the speed at which to move towards the target
253 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
254 |     * @example
255 |     * fromColor = LeanSmooth.linear(fromColor, transform.GetComponent<Renderer>().material.color, 50f);\n
256 |     * Debug.Log("current:"+fromColor);
257 |     */
258 |     public static Color linear(Color current, Color target, float moveSpeed)
259 |     {
260 |         float r = linear(current.r, target.r, moveSpeed);
261 |         float g = linear(current.g, target.g, moveSpeed);
262 |         float b = linear(current.b, target.b, moveSpeed);
263 |         float a = linear(current.a, target.a, moveSpeed);
264 | 
265 |         return new Color(r, g, b, a);
266 |     }
267 | 
268 |     /**
269 |     * <summary>Moves one value towards another (with an ease that bounces back some when it reaches it's destination)</summary>
270 |     * 
271 |     * @method LeanSmooth.bounceOut (float)
272 |     * @param {float} current:float the current value
273 |     * @param {float} target:float the value we are trying to reach
274 |     * @param {float} currentVelocity:float the current velocity of the value
275 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
276 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
277 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
278 |     * @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
279 |     * @param {float} [accelRate]:float the rate it accelerates from it's initial position
280 |     * @param {float} [hitDamping]:float the rate at which to dampen the bounciness of when it reaches it's destination
281 |     * @example
282 |     * followVar = LeanSmooth.bounceOut(followVar, destinationVar, ref followVelocity, 1.1f);\n
283 |     * Debug.Log("current:"+followVar);
284 |     */
285 |     public static float bounceOut(float current, float target, ref float currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f, float hitDamping = 0.9f)
286 |     {
287 |         if (deltaTime < 0f)
288 |             deltaTime = Time.deltaTime;
289 | 
290 |         float diff = target - current;
291 | 
292 |         currentVelocity += deltaTime / smoothTime * accelRate * diff;
293 | 
294 |         currentVelocity *= (1f - deltaTime * friction);
295 | 
296 |         if (maxSpeed > 0f && maxSpeed < Mathf.Abs(currentVelocity))
297 |             currentVelocity = maxSpeed * Mathf.Sign(currentVelocity);
298 | 
299 |         float returned = current + currentVelocity;
300 | 
301 |         bool targetGreater = (target > current);
302 |         float returnPassed = returned - target;
303 |         if ((targetGreater && returnPassed > 0) || !targetGreater && returnPassed < 0)
304 |         { // Start a bounce
305 |             currentVelocity = -currentVelocity * hitDamping;
306 |             returned = current + currentVelocity;
307 |         }
308 | 
309 |         return returned;
310 |     }
311 | 
312 |     /**
313 |     * <summary>Moves one value towards another (with an ease that bounces back some when it reaches it's destination)</summary>
314 |     * 
315 |     * @method LeanSmooth.bounceOut (Vector3)
316 |     * @param {Vector3} current:float the current value
317 |     * @param {Vector3} target:float the value we are trying to reach
318 |     * @param {Vector3} currentVelocity:float the current velocity of the value
319 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
320 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
321 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
322 |     * @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
323 |     * @param {float} [accelRate]:float the rate it accelerates from it's initial position
324 |     * @param {float} [hitDamping]:float the rate at which to dampen the bounciness of when it reaches it's destination
325 |     * @example
326 |     * transform.position = LeanSmooth.bounceOut(transform.position, followTrans.position, ref followVelocity, 1.1f);\n
327 |     * Debug.Log("current:"+transform.position);
328 |     */
329 |     public static Vector3 bounceOut(Vector3 current, Vector3 target, ref Vector3 currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f, float hitDamping = 0.9f)
330 |     {
331 |         float x = bounceOut(current.x, target.x, ref currentVelocity.x, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
332 |         float y = bounceOut(current.y, target.y, ref currentVelocity.y, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
333 |         float z = bounceOut(current.z, target.z, ref currentVelocity.z, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
334 | 
335 |         return new Vector3(x, y, z);
336 |     }
337 | 
338 |     /**
339 |     * <summary>Moves one color towards another (with an ease that bounces back some when it reaches it's destination)</summary>
340 |     * 
341 |     * @method LeanSmooth.bounceOut (Color)
342 |     * @param {Color} current:float the current value
343 |     * @param {Color} target:float the value we are trying to reach
344 |     * @param {Color} currentVelocity:float the current velocity of the value
345 |     * @param {float} smoothTime:float roughly the time it takes to reach the destination
346 |     * @param {float} maxSpeed:float the top speed you want the value to move at (defaults to unlimited -1f)
347 |     * @param {float} deltaTime:float the difference in time since the method was called (defaults to Time.deltaTime)
348 |     * @param {float} [friction]:float rate at which the spring is slowed down once it reaches it's destination
349 |     * @param {float} [accelRate]:float the rate it accelerates from it's initial position
350 |     * @param {float} [hitDamping]:float the rate at which to dampen the bounciness of when it reaches it's destination
351 |     * @example
352 |     * fromColor = LeanSmooth.bounceOut(fromColor, transform.GetComponent<Renderer>().material.color, ref followVelocity, 1.1f);\n
353 |     * Debug.Log("current:" + fromColor);
354 |     */
355 |     public static Color bounceOut(Color current, Color target, ref Color currentVelocity, float smoothTime, float maxSpeed = -1f, float deltaTime = -1f, float friction = 2f, float accelRate = 0.5f, float hitDamping = 0.9f)
356 |     {
357 |         float r = bounceOut(current.r, target.r, ref currentVelocity.r, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
358 |         float g = bounceOut(current.g, target.g, ref currentVelocity.g, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
359 |         float b = bounceOut(current.b, target.b, ref currentVelocity.b, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
360 |         float a = bounceOut(current.a, target.a, ref currentVelocity.a, smoothTime, maxSpeed, deltaTime, friction, accelRate, hitDamping);
361 | 
362 |         return new Color(r, g, b, a);
363 |     }
364 | }
365 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanSmooth.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 1ca0f285af8dd4270bd759978223faad
 3 | MonoImporter:
 4 |   externalObjects: {}
 5 |   serializedVersion: 2
 6 |   defaultReferences: []
 7 |   executionOrder: 0
 8 |   icon: {instanceID: 0}
 9 |   userData: 
10 |   assetBundleName: 
11 |   assetBundleVariant: 
12 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanTest.cs:
--------------------------------------------------------------------------------
  1 | using UnityEngine;
  2 | using System.Collections;
  3 | 
  4 | public class LeanTester : MonoBehaviour {
  5 | 	public float timeout = 15f;
  6 | 
  7 | 	#if !UNITY_3_5 && !UNITY_4_0 && !UNITY_4_0_1 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3 && !UNITY_4_5
  8 | 	public void Start(){
  9 | 		StartCoroutine( timeoutCheck() );
 10 | 	}
 11 | 
 12 | 	IEnumerator timeoutCheck(){
 13 | 		float pauseEndTime = Time.realtimeSinceStartup + timeout;
 14 | 	    while (Time.realtimeSinceStartup < pauseEndTime)
 15 | 	    {
 16 | 	        yield return 0;
 17 | 	    }
 18 | 		if(LeanTest.testsFinished==false){
 19 | 			Debug.Log(LeanTest.formatB("Tests timed out!"));
 20 | 			LeanTest.overview();
 21 | 		}
 22 | 	}
 23 | 	#endif
 24 | }
 25 | 
 26 | public class LeanTest : object {
 27 | 	public static int expected = 0;
 28 | 	private static int tests = 0;
 29 | 	private static int passes = 0;
 30 | 
 31 | 	public static float timeout = 15f;
 32 | 	public static bool timeoutStarted = false;
 33 | 	public static bool testsFinished = false;
 34 | 	
 35 | 	public static void debug( string name, bool didPass, string failExplaination = null){
 36 | 		expect( didPass, name, failExplaination);
 37 | 	}
 38 | 
 39 | 	public static void expect( bool didPass, string definition, string failExplaination = null){
 40 | 		float len = printOutLength(definition);
 41 | 		int paddingLen = 40-(int)(len*1.05f);
 42 | 		#if UNITY_FLASH
 43 | 		string padding = padRight(paddingLen);
 44 | 		#else
 45 | 		string padding = "".PadRight(paddingLen,"_"[0]);
 46 | 		#endif
 47 | 		string logName = formatB(definition) +" " + padding + " [ "+ (didPass ? formatC("pass","green") : formatC("fail","red")) +" ]";
 48 | 		if(didPass==false && failExplaination!=null)
 49 | 			logName += " - " + failExplaination;
 50 | 		Debug.Log(logName);
 51 | 		if(didPass)
 52 | 			passes++;
 53 | 		tests++;
 54 | 		
 55 | 		// Debug.Log("tests:"+tests+" expected:"+expected);
 56 | 		if(tests==expected && testsFinished==false){
 57 | 			overview();
 58 | 		}else if(tests>expected){
 59 | 			Debug.Log(formatB("Too many tests for a final report!") + " set LeanTest.expected = "+tests);
 60 | 		}
 61 | 
 62 | 		if(timeoutStarted==false){
 63 | 			timeoutStarted = true;
 64 | 			GameObject tester = new GameObject();
 65 | 			tester.name = "~LeanTest";
 66 | 			LeanTester test = tester.AddComponent(typeof(LeanTester)) as LeanTester;
 67 | 			test.timeout = timeout;
 68 | 			#if !UNITY_EDITOR
 69 | 			tester.hideFlags = HideFlags.HideAndDontSave;
 70 | 			#endif
 71 | 		}
 72 | 	}
 73 | 	
 74 | 	public static string padRight(int len){
 75 | 		string str = "";
 76 | 		for(int i = 0; i < len; i++){
 77 | 			str += "_";
 78 | 		}
 79 | 		return str;
 80 | 	}
 81 | 	
 82 | 	public static float printOutLength( string str ){
 83 | 		float len = 0.0f;
 84 | 		for(int i = 0; i < str.Length; i++){
 85 | 			if(str[i]=="I"[0]){
 86 | 				len += 0.5f;
 87 | 			}else if(str[i]=="J"[0]){
 88 | 				len += 0.85f;
 89 | 			}else{
 90 | 				len += 1.0f;
 91 | 			}
 92 | 		}
 93 | 		return len;
 94 | 	}
 95 | 	
 96 | 	public static string formatBC( string str, string color ){
 97 | 		return formatC(formatB(str),color);
 98 | 	}
 99 | 	
100 | 	public static string formatB( string str ){
101 | 		#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
102 | 		return str;
103 | 		#else
104 | 		return "<b>"+ str + "</b>";
105 | 		#endif
106 | 	}
107 | 	
108 | 	public static string formatC( string str, string color ){
109 | 		#if UNITY_3_5 || UNITY_4_0 || UNITY_4_0_1 || UNITY_4_1 || UNITY_4_2
110 | 		return str;
111 | 		#else
112 | 		return "<color="+color+">"+ str + "</color>";
113 | 		#endif
114 | 	}
115 | 	
116 | 	public static void overview(){ 
117 | 		testsFinished = true;
118 | 		int failedCnt = (expected-passes);
119 | 		string failedStr = failedCnt > 0 ? formatBC(""+failedCnt,"red") : ""+failedCnt;
120 | 		Debug.Log(formatB("Final Report:")+" _____________________ PASSED: "+formatBC(""+passes,"green")+" FAILED: "+failedStr+" ");
121 | 	}
122 | }
123 | 	


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanTest.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 82464f26ca2ba284a8f92f51248c574a
 3 | timeCreated: 1427917971
 4 | licenseType: Free
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanTween.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 9c2f4b27196f84954b44753aaac214bb
 3 | timeCreated: 1463137984
 4 | licenseType: Free
 5 | MonoImporter:
 6 |   serializedVersion: 2
 7 |   defaultReferences: []
 8 |   executionOrder: 0
 9 |   icon: {instanceID: 0}
10 |   userData: 
11 |   assetBundleName: 
12 |   assetBundleVariant: 
13 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanTween.dll.zip:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/7Seventy0/SeventysCameraSettingsMod/7e1508dd9ff57e149eb792155227099505684957/Source Code/LeanTween/LeanTween.dll.zip


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanTween.dll.zip.meta:
--------------------------------------------------------------------------------
1 | fileFormatVersion: 2
2 | guid: ffeadda6aaa064923a3f7e28ff26afb1
3 | timeCreated: 1477948563
4 | licenseType: Free
5 | DefaultImporter:
6 |   userData: 
7 |   assetBundleName: 
8 |   assetBundleVariant: 
9 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanTweenExt.cs:
--------------------------------------------------------------------------------
  1 | using System.Collections;
  2 | using System.Collections.Generic;
  3 | using UnityEngine;
  4 | using System;
  5 | 
  6 | public static class LeanTweenExt
  7 | {
  8 |     //LeanTween.addListener
  9 |     //LeanTween.alpha
 10 |     public static LTDescr LeanAlpha(this GameObject gameObject, float to, float time) { return LeanTween.alpha(gameObject, to, time); }
 11 |     //LeanTween.alphaCanvas
 12 |     public static LTDescr LeanAlphaVertex(this GameObject gameObject, float to, float time) { return LeanTween.alphaVertex(gameObject, to, time); }
 13 |     //LeanTween.alpha (RectTransform)
 14 |     public static LTDescr LeanAlpha(this RectTransform rectTransform, float to, float time) { return LeanTween.alpha(rectTransform, to, time); }
 15 |     //LeanTween.alphaCanvas
 16 |     public static LTDescr LeanAlpha(this CanvasGroup canvas, float to, float time) { return LeanTween.alphaCanvas(canvas, to, time); }
 17 |     //LeanTween.alphaText
 18 |     public static LTDescr LeanAlphaText(this RectTransform rectTransform, float to, float time) { return LeanTween.alphaText(rectTransform, to, time); }
 19 |     //LeanTween.cancel
 20 |     public static void LeanCancel(this GameObject gameObject) { LeanTween.cancel(gameObject); }
 21 |     public static void LeanCancel(this GameObject gameObject, bool callOnComplete) { LeanTween.cancel(gameObject, callOnComplete); }
 22 |     public static void LeanCancel(this GameObject gameObject, int uniqueId, bool callOnComplete = false) { LeanTween.cancel(gameObject, uniqueId, callOnComplete); }
 23 |     //LeanTween.cancel
 24 |     public static void LeanCancel(this RectTransform rectTransform) { LeanTween.cancel(rectTransform); }
 25 |     //LeanTween.cancelAll
 26 |     //LeanTween.color
 27 |     public static LTDescr LeanColor(this GameObject gameObject, Color to, float time) { return LeanTween.color(gameObject, to, time); }
 28 |     //LeanTween.colorText
 29 |     public static LTDescr LeanColorText(this RectTransform rectTransform, Color to, float time) { return LeanTween.colorText(rectTransform, to, time); }
 30 |     //LeanTween.delayedCall
 31 |     public static LTDescr LeanDelayedCall(this GameObject gameObject, float delayTime, System.Action callback) { return LeanTween.delayedCall(gameObject, delayTime, callback); }
 32 |     public static LTDescr LeanDelayedCall(this GameObject gameObject, float delayTime, System.Action<object> callback) { return LeanTween.delayedCall(gameObject, delayTime, callback); }
 33 | 
 34 |     //LeanTween.isPaused
 35 |     public static bool LeanIsPaused(this GameObject gameObject) { return LeanTween.isPaused(gameObject); }
 36 |     public static bool LeanIsPaused(this RectTransform rectTransform) { return LeanTween.isPaused(rectTransform); }
 37 | 
 38 |     //LeanTween.isTweening
 39 |     public static bool LeanIsTweening(this GameObject gameObject) { return LeanTween.isTweening(gameObject); }
 40 |     //LeanTween.isTweening
 41 |     //LeanTween.move
 42 |     public static LTDescr LeanMove(this GameObject gameObject, Vector3 to, float time) { return LeanTween.move(gameObject, to, time); }
 43 |     public static LTDescr LeanMove(this Transform transform, Vector3 to, float time) { return LeanTween.move(transform.gameObject, to, time); }
 44 |     public static LTDescr LeanMove(this RectTransform rectTransform, Vector3 to, float time) { return LeanTween.move(rectTransform, to, time); }
 45 |     //LeanTween.move
 46 |     public static LTDescr LeanMove(this GameObject gameObject, Vector2 to, float time) { return LeanTween.move(gameObject, to, time); }
 47 |     public static LTDescr LeanMove(this Transform transform, Vector2 to, float time) { return LeanTween.move(transform.gameObject, to, time); }
 48 |     //LeanTween.move
 49 |     public static LTDescr LeanMove(this GameObject gameObject, Vector3[] to, float time) { return LeanTween.move(gameObject, to, time); }
 50 |     public static LTDescr LeanMove(this GameObject gameObject, LTBezierPath to, float time) { return LeanTween.move(gameObject, to, time); }
 51 |     public static LTDescr LeanMove(this GameObject gameObject, LTSpline to, float time) { return LeanTween.move(gameObject, to, time); }
 52 |     public static LTDescr LeanMove(this Transform transform, Vector3[] to, float time) { return LeanTween.move(transform.gameObject, to, time); }
 53 |     public static LTDescr LeanMove(this Transform transform, LTBezierPath to, float time) { return LeanTween.move(transform.gameObject, to, time); }
 54 |     public static LTDescr LeanMove(this Transform transform, LTSpline to, float time) { return LeanTween.move(transform.gameObject, to, time); }
 55 |     //LeanTween.moveLocal
 56 |     public static LTDescr LeanMoveLocal(this GameObject gameObject, Vector3 to, float time) { return LeanTween.moveLocal(gameObject, to, time); }
 57 |     public static LTDescr LeanMoveLocal(this GameObject gameObject, LTBezierPath to, float time) { return LeanTween.moveLocal(gameObject, to, time); }
 58 |     public static LTDescr LeanMoveLocal(this GameObject gameObject, LTSpline to, float time) { return LeanTween.moveLocal(gameObject, to, time); }
 59 |     public static LTDescr LeanMoveLocal(this Transform transform, Vector3 to, float time) { return LeanTween.moveLocal(transform.gameObject, to, time); }
 60 |     public static LTDescr LeanMoveLocal(this Transform transform, LTBezierPath to, float time) { return LeanTween.moveLocal(transform.gameObject, to, time); }
 61 |     public static LTDescr LeanMoveLocal(this Transform transform, LTSpline to, float time) { return LeanTween.moveLocal(transform.gameObject, to, time); }
 62 |     //LeanTween.moveLocal
 63 |     public static LTDescr LeanMoveLocalX(this GameObject gameObject, float to, float time) { return LeanTween.moveLocalX(gameObject, to, time); }
 64 |     public static LTDescr LeanMoveLocalY(this GameObject gameObject, float to, float time) { return LeanTween.moveLocalY(gameObject, to, time); }
 65 |     public static LTDescr LeanMoveLocalZ(this GameObject gameObject, float to, float time) { return LeanTween.moveLocalZ(gameObject, to, time); }
 66 |     public static LTDescr LeanMoveLocalX(this Transform transform, float to, float time) { return LeanTween.moveLocalX(transform.gameObject, to, time); }
 67 |     public static LTDescr LeanMoveLocalY(this Transform transform, float to, float time) { return LeanTween.moveLocalY(transform.gameObject, to, time); }
 68 |     public static LTDescr LeanMoveLocalZ(this Transform transform, float to, float time) { return LeanTween.moveLocalZ(transform.gameObject, to, time); }
 69 |     //LeanTween.moveSpline
 70 |     public static LTDescr LeanMoveSpline(this GameObject gameObject, Vector3[] to, float time) { return LeanTween.moveSpline(gameObject, to, time); }
 71 |     public static LTDescr LeanMoveSpline(this GameObject gameObject, LTSpline to, float time) { return LeanTween.moveSpline(gameObject, to, time); }
 72 |     public static LTDescr LeanMoveSpline(this Transform transform, Vector3[] to, float time) { return LeanTween.moveSpline(transform.gameObject, to, time); }
 73 |     public static LTDescr LeanMoveSpline(this Transform transform, LTSpline to, float time) { return LeanTween.moveSpline(transform.gameObject, to, time); }
 74 |     //LeanTween.moveSplineLocal
 75 |     public static LTDescr LeanMoveSplineLocal(this GameObject gameObject, Vector3[] to, float time) { return LeanTween.moveSplineLocal(gameObject, to, time); }
 76 |     public static LTDescr LeanMoveSplineLocal(this Transform transform, Vector3[] to, float time) { return LeanTween.moveSplineLocal(transform.gameObject, to, time); }
 77 |     //LeanTween.moveX
 78 |     public static LTDescr LeanMoveX(this GameObject gameObject, float to, float time) { return LeanTween.moveX(gameObject, to, time); }
 79 |     public static LTDescr LeanMoveX(this Transform transform, float to, float time) { return LeanTween.moveX(transform.gameObject, to, time); }
 80 |     //LeanTween.moveX (RectTransform)
 81 |     public static LTDescr LeanMoveX(this RectTransform rectTransform, float to, float time) { return LeanTween.moveX(rectTransform, to, time); }
 82 |     //LeanTween.moveY
 83 |     public static LTDescr LeanMoveY(this GameObject gameObject, float to, float time) { return LeanTween.moveY(gameObject, to, time); }
 84 |     public static LTDescr LeanMoveY(this Transform transform, float to, float time) { return LeanTween.moveY(transform.gameObject, to, time); }
 85 |     //LeanTween.moveY (RectTransform)
 86 |     public static LTDescr LeanMoveY(this RectTransform rectTransform, float to, float time) { return LeanTween.moveY(rectTransform, to, time); }
 87 |     //LeanTween.moveZ
 88 |     public static LTDescr LeanMoveZ(this GameObject gameObject, float to, float time) { return LeanTween.moveZ(gameObject, to, time); }
 89 |     public static LTDescr LeanMoveZ(this Transform transform, float to, float time) { return LeanTween.moveZ(transform.gameObject, to, time); }
 90 |     //LeanTween.moveZ (RectTransform)
 91 |     public static LTDescr LeanMoveZ(this RectTransform rectTransform, float to, float time) { return LeanTween.moveZ(rectTransform, to, time); }
 92 |     //LeanTween.pause
 93 |     public static void LeanPause(this GameObject gameObject) { LeanTween.pause(gameObject); }
 94 |     //LeanTween.play
 95 |     public static LTDescr LeanPlay(this RectTransform rectTransform, UnityEngine.Sprite[] sprites) { return LeanTween.play(rectTransform, sprites); }
 96 |     //LeanTween.removeListener
 97 |     //LeanTween.resume
 98 |     public static void LeanResume(this GameObject gameObject) { LeanTween.resume(gameObject); }
 99 |     //LeanTween.resumeAll
100 |     //LeanTween.rotate 
101 |     public static LTDescr LeanRotate(this GameObject gameObject, Vector3 to, float time) { return LeanTween.rotate(gameObject, to, time); }
102 |     public static LTDescr LeanRotate(this Transform transform, Vector3 to, float time) { return LeanTween.rotate(transform.gameObject, to, time); }
103 |     //LeanTween.rotate
104 |     //LeanTween.rotate (RectTransform)
105 |     public static LTDescr LeanRotate(this RectTransform rectTransform, Vector3 to, float time) { return LeanTween.rotate(rectTransform, to, time); }
106 |     //LeanTween.rotateAround
107 |     public static LTDescr LeanRotateAround(this GameObject gameObject, Vector3 axis, float add, float time) { return LeanTween.rotateAround(gameObject, axis, add, time); }
108 |     public static LTDescr LeanRotateAround(this Transform transform, Vector3 axis, float add, float time) { return LeanTween.rotateAround(transform.gameObject, axis, add, time); }
109 |     //LeanTween.rotateAround (RectTransform)
110 |     public static LTDescr LeanRotateAround(this RectTransform rectTransform, Vector3 axis, float add, float time) { return LeanTween.rotateAround(rectTransform, axis, add, time); }
111 |     //LeanTween.rotateAroundLocal
112 |     public static LTDescr LeanRotateAroundLocal(this GameObject gameObject, Vector3 axis, float add, float time) { return LeanTween.rotateAroundLocal(gameObject, axis, add, time); }
113 |     public static LTDescr LeanRotateAroundLocal(this Transform transform, Vector3 axis, float add, float time) { return LeanTween.rotateAroundLocal(transform.gameObject, axis, add, time); }
114 |     //LeanTween.rotateAround (RectTransform)
115 |     public static LTDescr LeanRotateAroundLocal(this RectTransform rectTransform, Vector3 axis, float add, float time) { return LeanTween.rotateAroundLocal(rectTransform, axis, add, time); }
116 |     //LeanTween.rotateLocal
117 |     //LeanTween.rotateX
118 |     public static LTDescr LeanRotateX(this GameObject gameObject, float to, float time) { return LeanTween.rotateX(gameObject, to, time); }
119 |     public static LTDescr LeanRotateX(this Transform transform, float to, float time) { return LeanTween.rotateX(transform.gameObject, to, time); }
120 |     //LeanTween.rotateY
121 |     public static LTDescr LeanRotateY(this GameObject gameObject, float to, float time) { return LeanTween.rotateY(gameObject, to, time); }
122 |     public static LTDescr LeanRotateY(this Transform transform, float to, float time) { return LeanTween.rotateY(transform.gameObject, to, time); }
123 |     //LeanTween.rotateZ
124 |     public static LTDescr LeanRotateZ(this GameObject gameObject, float to, float time) { return LeanTween.rotateZ(gameObject, to, time); }
125 |     public static LTDescr LeanRotateZ(this Transform transform, float to, float time) { return LeanTween.rotateZ(transform.gameObject, to, time); }
126 |     //LeanTween.scale
127 |     public static LTDescr LeanScale(this GameObject gameObject, Vector3 to, float time) { return LeanTween.scale(gameObject, to, time); }
128 |     public static LTDescr LeanScale(this Transform transform, Vector3 to, float time) { return LeanTween.scale(transform.gameObject, to, time); }
129 |     //LeanTween.scale (GUI)
130 |     //LeanTween.scale (RectTransform)
131 |     public static LTDescr LeanScale(this RectTransform rectTransform, Vector3 to, float time) { return LeanTween.scale(rectTransform, to, time); }
132 |     //LeanTween.scaleX
133 |     public static LTDescr LeanScaleX(this GameObject gameObject, float to, float time) { return LeanTween.scaleX(gameObject, to, time); }
134 |     public static LTDescr LeanScaleX(this Transform transform, float to, float time) { return LeanTween.scaleX(transform.gameObject, to, time); }
135 |     //LeanTween.scaleY
136 |     public static LTDescr LeanScaleY(this GameObject gameObject, float to, float time) { return LeanTween.scaleY(gameObject, to, time); }
137 |     public static LTDescr LeanScaleY(this Transform transform, float to, float time) { return LeanTween.scaleY(transform.gameObject, to, time); }
138 |     //LeanTween.scaleZ
139 |     public static LTDescr LeanScaleZ(this GameObject gameObject, float to, float time) { return LeanTween.scaleZ(gameObject, to, time); }
140 |     public static LTDescr LeanScaleZ(this Transform transform, float to, float time) { return LeanTween.scaleZ(transform.gameObject, to, time); }
141 |     //LeanTween.sequence
142 |     //LeanTween.size (RectTransform)
143 |     public static LTDescr LeanSize(this RectTransform rectTransform, Vector2 to, float time) { return LeanTween.size(rectTransform, to, time); }
144 |     //LeanTween.tweensRunning
145 |     //LeanTween.value (Color)
146 |     public static LTDescr LeanValue(this GameObject gameObject, Color from, Color to, float time) { return LeanTween.value(gameObject, from, to, time); }
147 |     //LeanTween.value (Color)
148 |     //LeanTween.value (float)
149 |     public static LTDescr LeanValue(this GameObject gameObject, float from, float to, float time) { return LeanTween.value(gameObject, from, to, time); }
150 |     public static LTDescr LeanValue(this GameObject gameObject, Vector2 from, Vector2 to, float time) { return LeanTween.value(gameObject, from, to, time); }
151 |     public static LTDescr LeanValue(this GameObject gameObject, Vector3 from, Vector3 to, float time) { return LeanTween.value(gameObject, from, to, time); }
152 |     //LeanTween.value (float)
153 |     public static LTDescr LeanValue(this GameObject gameObject, Action<float> callOnUpdate, float from, float to, float time) { return LeanTween.value(gameObject, callOnUpdate, from, to, time); }
154 |     public static LTDescr LeanValue(this GameObject gameObject, Action<float, float> callOnUpdate, float from, float to, float time) { return LeanTween.value(gameObject, callOnUpdate, from, to, time); }
155 |     public static LTDescr LeanValue(this GameObject gameObject, Action<float, object> callOnUpdate, float from, float to, float time) { return LeanTween.value(gameObject, callOnUpdate, from, to, time); }
156 |     public static LTDescr LeanValue(this GameObject gameObject, Action<Color> callOnUpdate, Color from, Color to, float time) { return LeanTween.value(gameObject, callOnUpdate, from, to, time); }
157 |     public static LTDescr LeanValue(this GameObject gameObject, Action<Vector2> callOnUpdate, Vector2 from, Vector2 to, float time) { return LeanTween.value(gameObject, callOnUpdate, from, to, time); }
158 |     public static LTDescr LeanValue(this GameObject gameObject, Action<Vector3> callOnUpdate, Vector3 from, Vector3 to, float time) { return LeanTween.value(gameObject, callOnUpdate, from, to, time); }
159 | 
160 |     public static void LeanSetPosX(this Transform transform, float val){
161 |         transform.position = new Vector3(val, transform.position.y, transform.position.z);
162 |     }
163 |     public static void LeanSetPosY(this Transform transform, float val) {
164 |         transform.position = new Vector3(transform.position.x, val, transform.position.z);
165 |     }
166 |     public static void LeanSetPosZ(this Transform transform, float val) {
167 |         transform.position = new Vector3(transform.position.x, transform.position.y, val);
168 |     }
169 | 
170 |     public static void LeanSetLocalPosX(this Transform transform, float val)
171 |     {
172 |         transform.localPosition = new Vector3(val, transform.localPosition.y, transform.localPosition.z);
173 |     }
174 |     public static void LeanSetLocalPosY(this Transform transform, float val)
175 |     {
176 |         transform.localPosition = new Vector3(transform.localPosition.x, val, transform.localPosition.z);
177 |     }
178 |     public static void LeanSetLocalPosZ(this Transform transform, float val)
179 |     {
180 |         transform.localPosition = new Vector3(transform.localPosition.x, transform.localPosition.y, val);
181 |     }
182 | 
183 |     public static Color LeanColor(this Transform transform)
184 |     {
185 |         return transform.GetComponent<Renderer>().material.color;
186 |     }
187 | }
188 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/LeanTweenExt.cs.meta:
--------------------------------------------------------------------------------
 1 | fileFormatVersion: 2
 2 | guid: 5dbe851e9c0814f1d8f514ecf70f675d
 3 | timeCreated: 1533842565
 4 | licenseType: Pro
 5 | MonoImporter:
 6 |   externalObjects: {}
 7 |   serializedVersion: 2
 8 |   defaultReferences: []
 9 |   executionOrder: 0
10 |   icon: {instanceID: 0}
11 |   userData: 
12 |   assetBundleName: 
13 |   assetBundleVariant: 
14 | 


--------------------------------------------------------------------------------
/Source Code/LeanTween/camerabundlegamer:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/7Seventy0/SeventysCameraSettingsMod/7e1508dd9ff57e149eb792155227099505684957/Source Code/LeanTween/camerabundlegamer


--------------------------------------------------------------------------------
/Source Code/Plugin.cs:
--------------------------------------------------------------------------------
  1 | using BepInEx;
  2 | using System;
  3 | using System.Reflection;
  4 | using UnityEngine;
  5 | using UnityEngine.InputSystem;
  6 | using Utilla;
  7 | using System.Collections;
  8 | using HarmonyLib;
  9 | 
 10 | namespace SeventysCameraSettingsMod
 11 | {
 12 |     /// <summary>
 13 |     /// This is your mod's main class.
 14 |     /// </summary>
 15 | 
 16 |     /* This attribute tells Utilla to look for [ModdedGameJoin] and [ModdedGameLeave] */
 17 |     [ModdedGamemode]
 18 |     [BepInDependency("org.legoandmars.gorillatag.utilla", "1.5.0")]
 19 |     [BepInPlugin(PluginInfo.GUID, PluginInfo.Name, PluginInfo.Version)]
 20 | 
 21 |     public class Plugin : BaseUnityPlugin
 22 |     {
 23 |         bool inRoom;
 24 |     
 25 |         void OnEnable()
 26 |         {
 27 |             /* Set up your mod here */
 28 |             /* Code here runs at the start and whenever your mod is enabled*/
 29 | 
 30 |             HarmonyPatches.ApplyHarmonyPatches();
 31 |             Utilla.Events.GameInitialized += OnGameInitialized;
 32 |         }
 33 |         IEnumerator VerySlowUpdate()
 34 |         {
 35 |             yield return new WaitForSeconds(5);
 36 |             if (shoulderCam.GetComponent<FlyCamera>() == null)
 37 |             {
 38 |                 shoulderCam.AddComponent<FlyCamera>();
 39 |             }
 40 |         }
 41 |         void OnDisable()
 42 |         {
 43 |             /* Undo mod setup here */
 44 |             /* This provides support for toggling mods with ComputerInterface, please implement it :) */
 45 |             /* Code here runs whenever your mod is disabled (including if it disabled on startup)*/
 46 | 
 47 |             HarmonyPatches.RemoveHarmonyPatches();
 48 |             Utilla.Events.GameInitialized -= OnGameInitialized;
 49 |         }
 50 | 
 51 |         GameObject model;
 52 |         GameObject modelInstance;
 53 | 
 54 |         GameObject customNameTag;
 55 |         GameObject shoulderCam;
 56 | 
 57 |         Camera shoulderCamera;
 58 |         float fov;
 59 |         float cameraMovementSpeed;
 60 |         float cameraRotationSpeed;
 61 |         Vector3 pos;
 62 |         Vector3 rot;
 63 |         bool isFPSview;
 64 | 
 65 |       IEnumerator SeventysStart()
 66 |         {
 67 | 
 68 |             
 69 |             var fileStream = Assembly.GetExecutingAssembly().GetManifestResourceStream("SeventysCameraSettingsMod.Assets.scsm");
 70 |             var bundleLoadRequest = AssetBundle.LoadFromStreamAsync(fileStream);
 71 |             yield return bundleLoadRequest;
 72 | 
 73 |             var myLoadedAssetBundle = bundleLoadRequest.assetBundle;
 74 |             if (myLoadedAssetBundle == null)
 75 |             {
 76 |                 Debug.Log("Failed to load AssetBundle!");
 77 |                 yield break;
 78 |             }
 79 | 
 80 |             var assetLoadRequest = myLoadedAssetBundle.LoadAssetAsync<GameObject>("SeventysCameraSettingsUI");
 81 |             yield return assetLoadRequest;
 82 | 
 83 |             GameObject uiCanvas = assetLoadRequest.asset as GameObject;
 84 |             Instantiate(uiCanvas).AddComponent<UItag>();
 85 | 
 86 |             assetLoadRequest = myLoadedAssetBundle.LoadAssetAsync<GameObject>("GorilaSpectator");
 87 |             yield return assetLoadRequest;
 88 | 
 89 |             model = assetLoadRequest.asset as GameObject;
 90 |             modelInstance = Instantiate(model);
 91 | 
 92 |             assetLoadRequest = myLoadedAssetBundle.LoadAssetAsync<GameObject>("CustomNameTag");
 93 |             yield return assetLoadRequest;
 94 | 
 95 |             customNameTag = assetLoadRequest.asset as GameObject;
 96 |             Instantiate(customNameTag);
 97 | 
 98 | 
 99 | 
100 |             /////////////////////////////////////////////////////////////////////////////////////////////////////////
101 | 
102 |             yield return new WaitForSeconds(1);
103 | 
104 |             modelInstance.transform.SetParent(shoulderCam.transform,false);
105 | 
106 |             modelInstance.transform.localPosition = Vector3.zero;
107 |             modelInstance.transform.localScale = new Vector3(0.2f, 0.2f, 0.2f);
108 |             shoulderCam.GetComponent<FlyCamera>().model = modelInstance;
109 | 
110 |             InvokeRepeating("SuperSlowUpdate", 0, 1);
111 |         }
112 | 
113 |         void SuperSlowUpdate()
114 |         {
115 |             if(FindObjectsOfType<CustomNameTag>() != null)
116 |             {
117 |                 foreach (CustomNameTag nameTag in FindObjectsOfType<CustomNameTag>())
118 |                 {
119 |                     if (nameTag.nametag == null)
120 |                     {
121 |                         nameTag.nametag = customNameTag;
122 | 
123 |                     }
124 | 
125 |                 }
126 |             }
127 | 
128 |         }
129 | 
130 | 
131 |         void OnGameInitialized(object sender, EventArgs e)
132 |         {
133 |             StartCoroutine(SeventysStart());    
134 |             cameraMovementSpeed = 0.7f;
135 |             cameraRotationSpeed = 20;
136 |             /* Code here runs after the game initializes (i.e. GorillaLocomotion.Player.Instance != null) */
137 |             shoulderCam = GameObject.Find("Shoulder Camera");
138 |             shoulderCam.transform.SetParent(Camera.main.transform);
139 |             pos = shoulderCam.transform.localPosition;
140 |             GameObject.Find("CM vcam1").SetActive(false);
141 |             shoulderCamera = shoulderCam.GetComponent<Camera>();
142 |             shoulderCam.AddComponent<FlyCamera>();
143 |             
144 |             
145 |             
146 |         }
147 | 
148 |         void Update()
149 |         {
150 |             
151 |             //if (Keyboard.current.upArrowKey.isPressed)
152 |             //{
153 |             //    fov += 0.5f;
154 |             //    shoulderCamera.fieldOfView = fov;
155 |             //}
156 |             //if (Keyboard.current.downArrowKey.isPressed)
157 |             //{
158 |             //    fov -= 0.5f;
159 |             //    shoulderCamera.fieldOfView = fov;
160 |             //}
161 | 
162 |             //if (Keyboard.current.enterKey.isPressed)
163 |             //{
164 |             //    isFPSview = true;
165 | 
166 |             //}
167 |             //if (Keyboard.current.backspaceKey.isPressed)
168 |             //{
169 |             //    isFPSview = false;
170 |             //}
171 | 
172 |             //if (isFPSview)
173 |             //{
174 |             //    shoulderCam.transform.position = Camera.main.transform.position;
175 |             //}
176 | 
177 |             //if (!isFPSview)
178 |             //{
179 | 
180 |             //    if (Keyboard.current.wKey.isPressed)
181 |             //    {
182 |             //        pos.z += cameraMovementSpeed * Time.deltaTime;
183 |             //        shoulderCam.transform.localPosition = pos;
184 |             //    }
185 |             //    if (Keyboard.current.sKey.isPressed)
186 |             //    {
187 |             //        pos.z -= cameraMovementSpeed * Time.deltaTime;
188 |             //        shoulderCam.transform.localPosition = pos;
189 |             //    }
190 |             //    if (Keyboard.current.aKey.isPressed)
191 |             //    {
192 |             //        pos.x -= cameraMovementSpeed * Time.deltaTime;
193 |             //        shoulderCam.transform.localPosition = pos;
194 |             //    }
195 |             //    if (Keyboard.current.dKey.isPressed)
196 |             //    {
197 |             //        pos.x += cameraMovementSpeed * Time.deltaTime;
198 |             //        shoulderCam.transform.localPosition = pos;
199 |             //    }
200 |             //    if (Keyboard.current.spaceKey.isPressed)
201 |             //    {
202 |             //        pos.y += cameraMovementSpeed * Time.deltaTime;
203 |             //        shoulderCam.transform.localPosition = pos;
204 |             //    }
205 |             //    if (Keyboard.current.leftCtrlKey.isPressed)
206 |             //    {
207 |             //        pos.y -= cameraMovementSpeed * Time.deltaTime;
208 |             //        shoulderCam.transform.localPosition = pos;
209 |             //    }
210 | 
211 | 
212 |             //}
213 |             //if (Keyboard.current.eKey.isPressed)
214 |             //{
215 |             //    rot.y -= cameraRotationSpeed * Time.deltaTime;
216 |             //    shoulderCam.transform.localEulerAngles = rot;
217 |             //}
218 |             //if (Keyboard.current.qKey.isPressed)
219 |             //{
220 |             //    rot.y += cameraRotationSpeed * Time.deltaTime;
221 |             //    shoulderCam.transform.localEulerAngles = rot;
222 | 
223 |             //}
224 |             //if (Keyboard.current.rKey.isPressed)
225 |             //{
226 |             //    rot.x -= cameraRotationSpeed * Time.deltaTime;
227 |             //    shoulderCam.transform.localEulerAngles = rot;
228 | 
229 |             //}
230 |             //if (Keyboard.current.fKey.isPressed)
231 |             //{
232 |             //    rot.x += cameraRotationSpeed * Time.deltaTime;
233 |             //    shoulderCam.transform.localEulerAngles = rot;
234 | 
235 |             //}
236 | 
237 |         }
238 | 
239 |         /* This attribute tells Utilla to call this method when a modded room is joined */
240 |         [ModdedGamemodeJoin]
241 |         public void OnJoin(string gamemode)
242 |         {
243 |             /* Activate your mod here */
244 |             /* This code will run regardless of if the mod is enabled*/
245 | 
246 |             inRoom = true;
247 |         }
248 | 
249 |         /* This attribute tells Utilla to call this method when a modded room is left */
250 |         [ModdedGamemodeLeave]
251 |         public void OnLeave(string gamemode)
252 |         {
253 |             /* Deactivate your mod here */
254 |             /* This code will run regardless of if the mod is enabled*/
255 | 
256 |             inRoom = false;
257 |         }
258 |     }
259 |     namespace SolidMonkeys.Patches
260 |     {
261 |         [HarmonyPatch(typeof(VRRig))]
262 |         [HarmonyPatch("Start", MethodType.Normal)]
263 |         internal class VRRigColliderPatch
264 |         {
265 |             public static bool ModEnabled { get; set; }
266 | 
267 |             private static void Postfix(VRRig __instance)
268 |             {
269 |                 if (__instance.isOfflineVRRig)
270 |                     return;
271 | 
272 |                 Photon.Pun.PhotonView photView = __instance.photonView;
273 |                 if (photView != null && photView.IsMine)
274 |                     return;
275 | 
276 |                // __instance.gameObject.AddComponent<CustomNameTag>();
277 | 
278 |                 
279 | 
280 |                 // Debug.Log("Thank you Haunted! if you see this check this out : https://www.youtube.com/watch?v=dQw4w9WgXcQ :) youll like it");
281 |             }
282 |         }
283 |     }
284 | }
285 | 


--------------------------------------------------------------------------------
/Source Code/PluginInfo.cs:
--------------------------------------------------------------------------------
 1 | namespace SeventysCameraSettingsMod
 2 | {
 3 |     /// <summary>
 4 |     /// This class is used to provide information about your mod to BepInEx.
 5 |     /// </summary>
 6 |     internal class PluginInfo
 7 |     {
 8 |         public const string GUID = "com.seventy.gorillatag.seventyscamerasettingsmod";
 9 |         public const string Name = "SeventysCameraSettingsMod";
10 |         public const string Version = "1.0.2";
11 |     }
12 | }
13 | 


--------------------------------------------------------------------------------
/Source Code/SeventysCameraSettingsMod.csproj:
--------------------------------------------------------------------------------
  1 | <Project Sdk="Microsoft.NET.Sdk">
  2 | 
  3 |   <PropertyGroup>
  4 | 	  <TargetFramework>netstandard2.0</TargetFramework>
  5 |   </PropertyGroup>
  6 | 
  7 |   <ItemGroup>
  8 |     <None Remove="Assets\camerabundlegamer" />
  9 |     <None Remove="Assets\scsm" />
 10 |   </ItemGroup>
 11 | 
 12 |   <ItemGroup>
 13 |     <ApplicationDefinition Include="Assets\camerabundle" />
 14 |   </ItemGroup>
 15 | 
 16 |   <ItemGroup>
 17 |     <EmbeddedResource Include="Assets\scsm" />
 18 |   </ItemGroup>
 19 | 
 20 |   <ItemGroup>
 21 |     <PackageReference Include="UniverseLib.Mono" Version="1.4.2" />
 22 |   </ItemGroup>
 23 | 
 24 |   <ItemGroup>
 25 |     <Reference Include="0Harmony">
 26 |       <HintPath>$(BepInExAssemblyPath)\0Harmony.dll</HintPath>
 27 |     </Reference>
 28 |     <Reference Include="Assembly-CSharp">
 29 |       <HintPath>$(GameAssemblyPath)\Assembly-CSharp.dll</HintPath>
 30 |     </Reference>
 31 |     <Reference Include="Assembly-CSharp-firstpass">
 32 |       <HintPath>$(GameAssemblyPath)\Assembly-CSharp-firstpass.dll</HintPath>
 33 |     </Reference>
 34 |     <Reference Include="BakeryRuntimeAssembly">
 35 |       <HintPath>$(GameAssemblyPath)\BakeryRuntimeAssembly.dll</HintPath>
 36 |     </Reference>
 37 |     <Reference Include="BepInEx">
 38 |       <HintPath>$(BepInExAssemblyPath)\BepInEx.dll</HintPath>
 39 |     </Reference>
 40 |     <Reference Include="BepInEx.Harmony">
 41 |       <HintPath>$(BepInExAssemblyPath)\BepInEx.Harmony.dll</HintPath>
 42 |     </Reference>
 43 |     <Reference Include="Cinemachine">
 44 |       <HintPath>$(GameAssemblyPath)\Cinemachine.dll</HintPath>
 45 |     </Reference>
 46 |     <Reference Include="clipper_library">
 47 |       <HintPath>$(GameAssemblyPath)\clipper_library.dll</HintPath>
 48 |     </Reference>
 49 |     <Reference Include="Mono.Security">
 50 |       <HintPath>$(GameAssemblyPath)\Mono.Security.dll</HintPath>
 51 |     </Reference>
 52 |     <Reference Include="Oculus.Platform">
 53 |       <HintPath>$(GameAssemblyPath)\Oculus.Platform.dll</HintPath>
 54 |     </Reference>
 55 |     <Reference Include="Oculus.VR">
 56 |       <HintPath>$(GameAssemblyPath)\Oculus.VR.dll</HintPath>
 57 |     </Reference>
 58 |     <Reference Include="Photon3Unity3D">
 59 |       <HintPath>$(GameAssemblyPath)\Photon3Unity3D.dll</HintPath>
 60 |     </Reference>
 61 |     <Reference Include="PhotonRealtime">
 62 |       <HintPath>$(GameAssemblyPath)\PhotonRealtime.dll</HintPath>
 63 |     </Reference>
 64 |     <Reference Include="PhotonUnityNetworking">
 65 |       <HintPath>$(GameAssemblyPath)\PhotonUnityNetworking.dll</HintPath>
 66 |     </Reference>
 67 |     <Reference Include="PhotonUnityNetworking.Utilities">
 68 |       <HintPath>$(GameAssemblyPath)\PhotonUnityNetworking.Utilities.dll</HintPath>
 69 |     </Reference>
 70 |     <Reference Include="PhotonVoice">
 71 |       <HintPath>$(GameAssemblyPath)\PhotonVoice.dll</HintPath>
 72 |     </Reference>
 73 |     <Reference Include="PhotonVoice.API">
 74 |       <HintPath>$(GameAssemblyPath)\PhotonVoice.API.dll</HintPath>
 75 |     </Reference>
 76 |     <Reference Include="PhotonVoice.PUN">
 77 |       <HintPath>$(GameAssemblyPath)\PhotonVoice.PUN.dll</HintPath>
 78 |     </Reference>
 79 |     <Reference Include="PlayFab">
 80 |       <HintPath>$(GameAssemblyPath)\PlayFab.dll</HintPath>
 81 |     </Reference>
 82 |     <Reference Include="System.EnterpriseServices">
 83 |       <HintPath>$(GameAssemblyPath)\System.EnterpriseServices.dll</HintPath>
 84 |     </Reference>
 85 |     <Reference Include="System.ServiceModel.Internals">
 86 |       <HintPath>$(GameAssemblyPath)\System.ServiceModel.Internals.dll</HintPath>
 87 |     </Reference>
 88 |     <Reference Include="TMPLoader">
 89 |       <HintPath>..\..\..\..\..\..\Program Files (x86)\Steam\steamapps\common\Gorilla Tag\BepInEx\plugins\TMPLoader\TMPLoader.dll</HintPath>
 90 |     </Reference>
 91 |     <Reference Include="Unity.Animation.Rigging">
 92 |       <HintPath>$(GameAssemblyPath)\Unity.Animation.Rigging.dll</HintPath>
 93 |     </Reference>
 94 |     <Reference Include="Unity.Burst">
 95 |       <HintPath>$(GameAssemblyPath)\Unity.Burst.dll</HintPath>
 96 |     </Reference>
 97 |     <Reference Include="Unity.Burst.Unsafe">
 98 |       <HintPath>$(GameAssemblyPath)\Unity.Burst.Unsafe.dll</HintPath>
 99 |     </Reference>
100 |     <Reference Include="Unity.InputSystem">
101 |       <HintPath>$(GameAssemblyPath)\Unity.InputSystem.dll</HintPath>
102 |     </Reference>
103 |     <Reference Include="Unity.Mathematics">
104 |       <HintPath>$(GameAssemblyPath)\Unity.Mathematics.dll</HintPath>
105 |     </Reference>
106 |     <Reference Include="Unity.TextMeshPro">
107 |       <HintPath>..\..\..\..\..\..\Program Files (x86)\Steam\steamapps\common\Gorilla Tag\BepInEx\plugins\TMPLoader\Unity.TextMeshPro.dll</HintPath>
108 |     </Reference>
109 |     <Reference Include="Unity.Timeline">
110 |       <HintPath>$(GameAssemblyPath)\Unity.Timeline.dll</HintPath>
111 |     </Reference>
112 |     <Reference Include="Unity.XR.Interaction.Toolkit">
113 |       <HintPath>$(GameAssemblyPath)\Unity.XR.Interaction.Toolkit.dll</HintPath>
114 |     </Reference>
115 |     <Reference Include="UnityEngine">
116 |       <HintPath>$(GameAssemblyPath)\UnityEngine.dll</HintPath>
117 |     </Reference>
118 |     <Reference Include="UnityEngine.AccessibilityModule">
119 |       <HintPath>$(GameAssemblyPath)\UnityEngine.AccessibilityModule.dll</HintPath>
120 |     </Reference>
121 |     <Reference Include="UnityEngine.AIModule">
122 |       <HintPath>$(GameAssemblyPath)\UnityEngine.AIModule.dll</HintPath>
123 |     </Reference>
124 |     <Reference Include="UnityEngine.AndroidJNIModule">
125 |       <HintPath>$(GameAssemblyPath)\UnityEngine.AndroidJNIModule.dll</HintPath>
126 |     </Reference>
127 |     <Reference Include="UnityEngine.AnimationModule">
128 |       <HintPath>$(GameAssemblyPath)\UnityEngine.AnimationModule.dll</HintPath>
129 |     </Reference>
130 |     <Reference Include="UnityEngine.ARModule">
131 |       <HintPath>$(GameAssemblyPath)\UnityEngine.ARModule.dll</HintPath>
132 |     </Reference>
133 |     <Reference Include="UnityEngine.AssetBundleModule">
134 |       <HintPath>$(GameAssemblyPath)\UnityEngine.AssetBundleModule.dll</HintPath>
135 |     </Reference>
136 |     <Reference Include="UnityEngine.AudioModule">
137 |       <HintPath>$(GameAssemblyPath)\UnityEngine.AudioModule.dll</HintPath>
138 |     </Reference>
139 |     <Reference Include="UnityEngine.ClothModule">
140 |       <HintPath>$(GameAssemblyPath)\UnityEngine.ClothModule.dll</HintPath>
141 |     </Reference>
142 |     <Reference Include="UnityEngine.ClusterInputModule">
143 |       <HintPath>$(GameAssemblyPath)\UnityEngine.ClusterInputModule.dll</HintPath>
144 |     </Reference>
145 |     <Reference Include="UnityEngine.ClusterRendererModule">
146 |       <HintPath>$(GameAssemblyPath)\UnityEngine.ClusterRendererModule.dll</HintPath>
147 |     </Reference>
148 |     <Reference Include="UnityEngine.CoreModule">
149 |       <HintPath>$(GameAssemblyPath)\UnityEngine.CoreModule.dll</HintPath>
150 |     </Reference>
151 |     <Reference Include="UnityEngine.CrashReportingModule">
152 |       <HintPath>$(GameAssemblyPath)\UnityEngine.CrashReportingModule.dll</HintPath>
153 |     </Reference>
154 |     <Reference Include="UnityEngine.DirectorModule">
155 |       <HintPath>$(GameAssemblyPath)\UnityEngine.DirectorModule.dll</HintPath>
156 |     </Reference>
157 |     <Reference Include="UnityEngine.DSPGraphModule">
158 |       <HintPath>$(GameAssemblyPath)\UnityEngine.DSPGraphModule.dll</HintPath>
159 |     </Reference>
160 |     <Reference Include="UnityEngine.GameCenterModule">
161 |       <HintPath>$(GameAssemblyPath)\UnityEngine.GameCenterModule.dll</HintPath>
162 |     </Reference>
163 |     <Reference Include="UnityEngine.GridModule">
164 |       <HintPath>$(GameAssemblyPath)\UnityEngine.GridModule.dll</HintPath>
165 |     </Reference>
166 |     <Reference Include="UnityEngine.HotReloadModule">
167 |       <HintPath>$(GameAssemblyPath)\UnityEngine.HotReloadModule.dll</HintPath>
168 |     </Reference>
169 |     <Reference Include="UnityEngine.ImageConversionModule">
170 |       <HintPath>$(GameAssemblyPath)\UnityEngine.ImageConversionModule.dll</HintPath>
171 |     </Reference>
172 |     <Reference Include="UnityEngine.IMGUIModule">
173 |       <HintPath>$(GameAssemblyPath)\UnityEngine.IMGUIModule.dll</HintPath>
174 |     </Reference>
175 |     <Reference Include="UnityEngine.InputLegacyModule">
176 |       <HintPath>$(GameAssemblyPath)\UnityEngine.InputLegacyModule.dll</HintPath>
177 |     </Reference>
178 |     <Reference Include="UnityEngine.InputModule">
179 |       <HintPath>$(GameAssemblyPath)\UnityEngine.InputModule.dll</HintPath>
180 |     </Reference>
181 |     <Reference Include="UnityEngine.JSONSerializeModule">
182 |       <HintPath>$(GameAssemblyPath)\UnityEngine.JSONSerializeModule.dll</HintPath>
183 |     </Reference>
184 |     <Reference Include="UnityEngine.LocalizationModule">
185 |       <HintPath>$(GameAssemblyPath)\UnityEngine.LocalizationModule.dll</HintPath>
186 |     </Reference>
187 |     <Reference Include="UnityEngine.ParticleSystemModule">
188 |       <HintPath>$(GameAssemblyPath)\UnityEngine.ParticleSystemModule.dll</HintPath>
189 |     </Reference>
190 |     <Reference Include="UnityEngine.PerformanceReportingModule">
191 |       <HintPath>$(GameAssemblyPath)\UnityEngine.PerformanceReportingModule.dll</HintPath>
192 |     </Reference>
193 |     <Reference Include="UnityEngine.Physics2DModule">
194 |       <HintPath>$(GameAssemblyPath)\UnityEngine.Physics2DModule.dll</HintPath>
195 |     </Reference>
196 |     <Reference Include="UnityEngine.PhysicsModule">
197 |       <HintPath>$(GameAssemblyPath)\UnityEngine.PhysicsModule.dll</HintPath>
198 |     </Reference>
199 |     <Reference Include="UnityEngine.ProfilerModule">
200 |       <HintPath>$(GameAssemblyPath)\UnityEngine.ProfilerModule.dll</HintPath>
201 |     </Reference>
202 |     <Reference Include="UnityEngine.ScreenCaptureModule">
203 |       <HintPath>$(GameAssemblyPath)\UnityEngine.ScreenCaptureModule.dll</HintPath>
204 |     </Reference>
205 |     <Reference Include="UnityEngine.SharedInternalsModule">
206 |       <HintPath>$(GameAssemblyPath)\UnityEngine.SharedInternalsModule.dll</HintPath>
207 |     </Reference>
208 |     <Reference Include="UnityEngine.SpatialTracking">
209 |       <HintPath>$(GameAssemblyPath)\UnityEngine.SpatialTracking.dll</HintPath>
210 |     </Reference>
211 |     <Reference Include="UnityEngine.SpriteMaskModule">
212 |       <HintPath>$(GameAssemblyPath)\UnityEngine.SpriteMaskModule.dll</HintPath>
213 |     </Reference>
214 |     <Reference Include="UnityEngine.SpriteShapeModule">
215 |       <HintPath>$(GameAssemblyPath)\UnityEngine.SpriteShapeModule.dll</HintPath>
216 |     </Reference>
217 |     <Reference Include="UnityEngine.StreamingModule">
218 |       <HintPath>$(GameAssemblyPath)\UnityEngine.StreamingModule.dll</HintPath>
219 |     </Reference>
220 |     <Reference Include="UnityEngine.SubstanceModule">
221 |       <HintPath>$(GameAssemblyPath)\UnityEngine.SubstanceModule.dll</HintPath>
222 |     </Reference>
223 |     <Reference Include="UnityEngine.SubsystemsModule">
224 |       <HintPath>$(GameAssemblyPath)\UnityEngine.SubsystemsModule.dll</HintPath>
225 |     </Reference>
226 |     <Reference Include="UnityEngine.TerrainModule">
227 |       <HintPath>$(GameAssemblyPath)\UnityEngine.TerrainModule.dll</HintPath>
228 |     </Reference>
229 |     <Reference Include="UnityEngine.TerrainPhysicsModule">
230 |       <HintPath>$(GameAssemblyPath)\UnityEngine.TerrainPhysicsModule.dll</HintPath>
231 |     </Reference>
232 |     <Reference Include="UnityEngine.TextCoreModule">
233 |       <HintPath>$(GameAssemblyPath)\UnityEngine.TextCoreModule.dll</HintPath>
234 |     </Reference>
235 |     <Reference Include="UnityEngine.TextRenderingModule">
236 |       <HintPath>$(GameAssemblyPath)\UnityEngine.TextRenderingModule.dll</HintPath>
237 |     </Reference>
238 |     <Reference Include="UnityEngine.TilemapModule">
239 |       <HintPath>$(GameAssemblyPath)\UnityEngine.TilemapModule.dll</HintPath>
240 |     </Reference>
241 |     <Reference Include="UnityEngine.TLSModule">
242 |       <HintPath>$(GameAssemblyPath)\UnityEngine.TLSModule.dll</HintPath>
243 |     </Reference>
244 |     <Reference Include="UnityEngine.UI">
245 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UI.dll</HintPath>
246 |     </Reference>
247 |     <Reference Include="UnityEngine.UIElementsModule">
248 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UIElementsModule.dll</HintPath>
249 |     </Reference>
250 |     <Reference Include="UnityEngine.UIModule">
251 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UIModule.dll</HintPath>
252 |     </Reference>
253 |     <Reference Include="UnityEngine.UmbraModule">
254 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UmbraModule.dll</HintPath>
255 |     </Reference>
256 |     <Reference Include="UnityEngine.UNETModule">
257 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UNETModule.dll</HintPath>
258 |     </Reference>
259 |     <Reference Include="UnityEngine.UnityAnalyticsModule">
260 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UnityAnalyticsModule.dll</HintPath>
261 |     </Reference>
262 |     <Reference Include="UnityEngine.UnityConnectModule">
263 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UnityConnectModule.dll</HintPath>
264 |     </Reference>
265 |     <Reference Include="UnityEngine.UnityTestProtocolModule">
266 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UnityTestProtocolModule.dll</HintPath>
267 |     </Reference>
268 |     <Reference Include="UnityEngine.UnityWebRequestAssetBundleModule">
269 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UnityWebRequestAssetBundleModule.dll</HintPath>
270 |     </Reference>
271 |     <Reference Include="UnityEngine.UnityWebRequestAudioModule">
272 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UnityWebRequestAudioModule.dll</HintPath>
273 |     </Reference>
274 |     <Reference Include="UnityEngine.UnityWebRequestModule">
275 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UnityWebRequestModule.dll</HintPath>
276 |     </Reference>
277 |     <Reference Include="UnityEngine.UnityWebRequestTextureModule">
278 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UnityWebRequestTextureModule.dll</HintPath>
279 |     </Reference>
280 |     <Reference Include="UnityEngine.UnityWebRequestWWWModule">
281 |       <HintPath>$(GameAssemblyPath)\UnityEngine.UnityWebRequestWWWModule.dll</HintPath>
282 |     </Reference>
283 |     <Reference Include="UnityEngine.VehiclesModule">
284 |       <HintPath>$(GameAssemblyPath)\UnityEngine.VehiclesModule.dll</HintPath>
285 |     </Reference>
286 |     <Reference Include="UnityEngine.VFXModule">
287 |       <HintPath>$(GameAssemblyPath)\UnityEngine.VFXModule.dll</HintPath>
288 |     </Reference>
289 |     <Reference Include="UnityEngine.VideoModule">
290 |       <HintPath>$(GameAssemblyPath)\UnityEngine.VideoModule.dll</HintPath>
291 |     </Reference>
292 |     <Reference Include="UnityEngine.VRModule">
293 |       <HintPath>$(GameAssemblyPath)\UnityEngine.VRModule.dll</HintPath>
294 |     </Reference>
295 |     <Reference Include="UnityEngine.WindModule">
296 |       <HintPath>$(GameAssemblyPath)\UnityEngine.WindModule.dll</HintPath>
297 |     </Reference>
298 |     <Reference Include="UnityEngine.XR.LegacyInputHelpers">
299 |       <HintPath>$(GameAssemblyPath)\UnityEngine.XR.LegacyInputHelpers.dll</HintPath>
300 |     </Reference>
301 |     <Reference Include="UnityEngine.XRModule">
302 |       <HintPath>$(GameAssemblyPath)\UnityEngine.XRModule.dll</HintPath>
303 |     </Reference>
304 |     <Reference Include="Utilla">
305 |       <HintPath>$(PluginsPath)\Utilla\utilla.dll</HintPath>
306 |     </Reference>
307 |     <Reference Include="websocket-sharp">
308 |       <HintPath>$(GameAssemblyPath)\websocket-sharp.dll</HintPath>
309 |     </Reference>
310 |   </ItemGroup>
311 | </Project>
312 | 


--------------------------------------------------------------------------------