--- /dev/null
+fileFormatVersion: 2
+guid: e6ba56ede2604dd4082ed2d0b4f435dd
+folderAsset: yes
+DefaultImporter:
+ userData:
--- /dev/null
+fileFormatVersion: 2
+guid: 21a42390d25252341a66bc19a8addaea
+folderAsset: yes
+DefaultImporter:
+ userData:
--- /dev/null
+fileFormatVersion: 2
+guid: 902c84bf971339c459ce4b757e333a55
+DefaultImporter:
+ userData:
--- /dev/null
+using UnityEngine;
+using System.Collections;
+
+public class DynamicBoneDemo1 : MonoBehaviour
+{
+ public GameObject m_Player;
+ float m_weight = 1;
+
+ void Update()
+ {
+ m_Player.transform.Rotate(new Vector3(0, Input.GetAxis("Horizontal") * Time.deltaTime * 200, 0));
+ m_Player.transform.Translate(transform.forward * Input.GetAxis("Vertical") * Time.deltaTime * 4);
+ }
+
+ void OnGUI()
+ {
+ GUI.Label(new Rect(50, 50, 200, 24), "Press arrow key to move");
+ Animation a = m_Player.GetComponentInChildren<Animation>();
+ a.enabled = GUI.Toggle(new Rect(50, 70, 200, 24), a.enabled, "Play Animation");
+
+ DynamicBone[] dbs = m_Player.GetComponents<DynamicBone>();
+ GUI.Label(new Rect(50, 100, 200, 24), "Choose dynamic bone:");
+ dbs[0].enabled = dbs[1].enabled = GUI.Toggle(new Rect(50, 120, 100, 24), dbs[0].enabled, "Breasts");
+ dbs[2].enabled = GUI.Toggle(new Rect(50, 140, 100, 24), dbs[2].enabled, "Tail");
+
+ GUI.Label(new Rect(50, 160, 200, 24), "Weight");
+ m_weight = GUI.HorizontalSlider(new Rect(100, 160, 100, 24), m_weight, 0, 1);
+ foreach (var db in dbs)
+ db.SetWeight(m_weight);
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 178320cedf292cb4f8d6c0b737b35953
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
--- /dev/null
+fileFormatVersion: 2
+guid: ba128457d0ea5e3439dbe4a53b9d1273
+ModelImporter:
+ serializedVersion: 16
+ fileIDToRecycleName:
+ 100000: abdomen
+ 100002: abdomen2
+ 100004: //RootNode
+ 100006: chest
+ 100008: Genesis2Female
+ 100010: Genesis2Female.Shape
+ 100012: head
+ 100014: hip
+ 100016: lBigToe
+ 100018: lCarpal1
+ 100020: lCarpal2
+ 100022: lCollar
+ 100024: lEye
+ 100026: lFoot
+ 100028: lForeArm
+ 100030: lHand
+ 100032: lIndex1
+ 100034: lIndex2
+ 100036: lIndex3
+ 100038: lMid1
+ 100040: lMid2
+ 100042: lMid3
+ 100044: lowerJaw
+ 100046: lPectoral
+ 100048: lPinky1
+ 100050: lPinky2
+ 100052: lPinky3
+ 100054: lRing1
+ 100056: lRing2
+ 100058: lRing3
+ 100060: lShin
+ 100062: lShldr
+ 100064: lSmallToe1
+ 100066: lSmallToe2
+ 100068: lSmallToe3
+ 100070: lSmallToe4
+ 100072: lThigh
+ 100074: lThumb1
+ 100076: lThumb2
+ 100078: lThumb3
+ 100080: lToe
+ 100082: neck
+ 100084: pelvis
+ 100086: rBigToe
+ 100088: rCarpal1
+ 100090: rCarpal2
+ 100092: rCollar
+ 100094: rEye
+ 100096: rFoot
+ 100098: rForeArm
+ 100100: rHand
+ 100102: rIndex1
+ 100104: rIndex2
+ 100106: rIndex3
+ 100108: rMid1
+ 100110: rMid2
+ 100112: rMid3
+ 100114: rPectoral
+ 100116: rPinky1
+ 100118: rPinky2
+ 100120: rPinky3
+ 100122: rRing1
+ 100124: rRing2
+ 100126: rRing3
+ 100128: rShin
+ 100130: rShldr
+ 100132: rSmallToe1
+ 100134: rSmallToe2
+ 100136: rSmallToe3
+ 100138: rSmallToe4
+ 100140: rThigh
+ 100142: rThumb1
+ 100144: rThumb2
+ 100146: rThumb3
+ 100148: rToe
+ 100150: tongue01
+ 100152: tongue02
+ 100154: tongue03
+ 100156: tongue04
+ 100158: tongue05
+ 100160: tongueBase
+ 100162: tongueTip
+ 100164: upperJaw
+ 400000: abdomen
+ 400002: abdomen2
+ 400004: //RootNode
+ 400006: chest
+ 400008: Genesis2Female
+ 400010: Genesis2Female.Shape
+ 400012: head
+ 400014: hip
+ 400016: lBigToe
+ 400018: lCarpal1
+ 400020: lCarpal2
+ 400022: lCollar
+ 400024: lEye
+ 400026: lFoot
+ 400028: lForeArm
+ 400030: lHand
+ 400032: lIndex1
+ 400034: lIndex2
+ 400036: lIndex3
+ 400038: lMid1
+ 400040: lMid2
+ 400042: lMid3
+ 400044: lowerJaw
+ 400046: lPectoral
+ 400048: lPinky1
+ 400050: lPinky2
+ 400052: lPinky3
+ 400054: lRing1
+ 400056: lRing2
+ 400058: lRing3
+ 400060: lShin
+ 400062: lShldr
+ 400064: lSmallToe1
+ 400066: lSmallToe2
+ 400068: lSmallToe3
+ 400070: lSmallToe4
+ 400072: lThigh
+ 400074: lThumb1
+ 400076: lThumb2
+ 400078: lThumb3
+ 400080: lToe
+ 400082: neck
+ 400084: pelvis
+ 400086: rBigToe
+ 400088: rCarpal1
+ 400090: rCarpal2
+ 400092: rCollar
+ 400094: rEye
+ 400096: rFoot
+ 400098: rForeArm
+ 400100: rHand
+ 400102: rIndex1
+ 400104: rIndex2
+ 400106: rIndex3
+ 400108: rMid1
+ 400110: rMid2
+ 400112: rMid3
+ 400114: rPectoral
+ 400116: rPinky1
+ 400118: rPinky2
+ 400120: rPinky3
+ 400122: rRing1
+ 400124: rRing2
+ 400126: rRing3
+ 400128: rShin
+ 400130: rShldr
+ 400132: rSmallToe1
+ 400134: rSmallToe2
+ 400136: rSmallToe3
+ 400138: rSmallToe4
+ 400140: rThigh
+ 400142: rThumb1
+ 400144: rThumb2
+ 400146: rThumb3
+ 400148: rToe
+ 400150: tongue01
+ 400152: tongue02
+ 400154: tongue03
+ 400156: tongue04
+ 400158: tongue05
+ 400160: tongueBase
+ 400162: tongueTip
+ 400164: upperJaw
+ 4300000: Genesis2Female.Shape
+ 7400000: Animation
+ 9500000: //RootNode
+ 11100000: //RootNode
+ 13700000: Genesis2Female.Shape
+ materials:
+ importMaterials: 0
+ materialName: 0
+ materialSearch: 1
+ animations:
+ legacyGenerateAnimations: 4
+ bakeSimulation: 0
+ optimizeGameObjects: 0
+ animationCompression: 2
+ animationRotationError: .5
+ animationPositionError: .5
+ animationScaleError: .5
+ animationWrapMode: 0
+ extraExposedTransformPaths: []
+ clipAnimations:
+ - serializedVersion: 16
+ name: Animation
+ takeName: Animation
+ firstFrame: 0
+ lastFrame: 206
+ wrapMode: 2
+ orientationOffsetY: 0
+ level: 0
+ cycleOffset: 0
+ loop: 0
+ loopTime: 0
+ loopBlend: 0
+ loopBlendOrientation: 0
+ loopBlendPositionY: 0
+ loopBlendPositionXZ: 0
+ keepOriginalOrientation: 0
+ keepOriginalPositionY: 1
+ keepOriginalPositionXZ: 0
+ heightFromFeet: 0
+ mirror: 0
+ bodyMask: 01000000010000000100000001000000010000000100000001000000010000000100000001000000010000000100000001000000
+ curves: []
+ events: []
+ transformMask:
+ - path:
+ weight: 1
+ - path: Genesis2Female
+ weight: 1
+ - path: Genesis2Female/Genesis2Female.Shape
+ weight: 1
+ - path: Genesis2Female/hip
+ weight: 1
+ - path: Genesis2Female/hip/abdomen
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal1/lIndex1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal1/lIndex1/lIndex2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal1/lIndex1/lIndex2/lIndex3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal1/lMid1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal1/lMid1/lMid2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal1/lMid1/lMid2/lMid3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal2/lPinky1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal2/lPinky1/lPinky2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal2/lPinky1/lPinky2/lPinky3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal2/lRing1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal2/lRing1/lRing2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lCarpal2/lRing1/lRing2/lRing3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lThumb1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lThumb1/lThumb2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lCollar/lShldr/lForeArm/lHand/lThumb1/lThumb2/lThumb3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/lPectoral
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lEye
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lowerJaw
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lowerJaw/tongueBase
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lowerJaw/tongueBase/tongue01
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lowerJaw/tongueBase/tongue01/tongue02
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lowerJaw/tongueBase/tongue01/tongue02/tongue03
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lowerJaw/tongueBase/tongue01/tongue02/tongue03/tongue04
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lowerJaw/tongueBase/tongue01/tongue02/tongue03/tongue04/tongue05
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/lowerJaw/tongueBase/tongue01/tongue02/tongue03/tongue04/tongue05/tongueTip
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/rEye
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/neck/head/upperJaw
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal1/rIndex1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal1/rIndex1/rIndex2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal1/rIndex1/rIndex2/rIndex3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal1/rMid1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal1/rMid1/rMid2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal1/rMid1/rMid2/rMid3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal2/rPinky1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal2/rPinky1/rPinky2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal2/rPinky1/rPinky2/rPinky3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal2/rRing1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal2/rRing1/rRing2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rCarpal2/rRing1/rRing2/rRing3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rThumb1
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rThumb1/rThumb2
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rCollar/rShldr/rForeArm/rHand/rThumb1/rThumb2/rThumb3
+ weight: 1
+ - path: Genesis2Female/hip/abdomen/abdomen2/chest/rPectoral
+ weight: 1
+ - path: Genesis2Female/hip/pelvis
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh/lShin
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh/lShin/lFoot
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh/lShin/lFoot/lToe
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh/lShin/lFoot/lToe/lBigToe
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh/lShin/lFoot/lToe/lSmallToe1
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh/lShin/lFoot/lToe/lSmallToe2
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh/lShin/lFoot/lToe/lSmallToe3
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/lThigh/lShin/lFoot/lToe/lSmallToe4
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh/rShin
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh/rShin/rFoot
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh/rShin/rFoot/rToe
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh/rShin/rFoot/rToe/rBigToe
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh/rShin/rFoot/rToe/rSmallToe1
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh/rShin/rFoot/rToe/rSmallToe2
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh/rShin/rFoot/rToe/rSmallToe3
+ weight: 1
+ - path: Genesis2Female/hip/pelvis/rThigh/rShin/rFoot/rToe/rSmallToe4
+ weight: 1
+ maskType: 0
+ maskSource: {instanceID: 0}
+ isReadable: 0
+ meshes:
+ lODScreenPercentages: []
+ globalScale: .00999999978
+ meshCompression: 0
+ addColliders: 0
+ importBlendShapes: 0
+ swapUVChannels: 0
+ generateSecondaryUV: 0
+ useFileUnits: 1
+ optimizeMeshForGPU: 1
+ weldVertices: 1
+ secondaryUVAngleDistortion: 8
+ secondaryUVAreaDistortion: 15.000001
+ secondaryUVHardAngle: 88
+ secondaryUVPackMargin: 4
+ tangentSpace:
+ normalSmoothAngle: 60
+ splitTangentsAcrossUV: 1
+ normalImportMode: 0
+ tangentImportMode: 2
+ importAnimation: 1
+ copyAvatar: 0
+ humanDescription:
+ human: []
+ skeleton: []
+ armTwist: .5
+ foreArmTwist: .5
+ upperLegTwist: .5
+ legTwist: .5
+ armStretch: .0500000007
+ legStretch: .0500000007
+ feetSpacing: 0
+ rootMotionBoneName:
+ lastHumanDescriptionAvatarSource: {instanceID: 0}
+ animationType: 1
+ additionalBone: 0
+ userData:
--- /dev/null
+fileFormatVersion: 2
+guid: 19015a5957bbaa745a61cba005220542
+ModelImporter:
+ serializedVersion: 16
+ fileIDToRecycleName:
+ 100000: Bone01
+ 100002: Bone02
+ 100004: Bone03
+ 100006: Bone04
+ 100008: Bone05
+ 100010: Bone06
+ 100012: Bone07
+ 100014: Bone08
+ 100016: //RootNode
+ 100018: tail
+ 100020: tail1
+ 100022: tail2
+ 100024: tail3
+ 100026: tail4
+ 100028: tail5
+ 100030: tail6
+ 100032: tail7
+ 100034: tail8
+ 400000: Bone01
+ 400002: Bone02
+ 400004: Bone03
+ 400006: Bone04
+ 400008: Bone05
+ 400010: Bone06
+ 400012: Bone07
+ 400014: Bone08
+ 400016: //RootNode
+ 400018: tail
+ 400020: tail1
+ 400022: tail2
+ 400024: tail3
+ 400026: tail4
+ 400028: tail5
+ 400030: tail6
+ 400032: tail7
+ 400034: tail8
+ 4300000: tail
+ 9500000: //RootNode
+ 11100000: //RootNode
+ 13700000: tail
+ materials:
+ importMaterials: 0
+ materialName: 0
+ materialSearch: 1
+ animations:
+ legacyGenerateAnimations: 4
+ bakeSimulation: 0
+ optimizeGameObjects: 0
+ animationCompression: 1
+ animationRotationError: .5
+ animationPositionError: .5
+ animationScaleError: .5
+ animationWrapMode: 0
+ extraExposedTransformPaths: []
+ clipAnimations: []
+ isReadable: 0
+ meshes:
+ lODScreenPercentages: []
+ globalScale: .00999999978
+ meshCompression: 0
+ addColliders: 0
+ importBlendShapes: 0
+ swapUVChannels: 0
+ generateSecondaryUV: 0
+ useFileUnits: 1
+ optimizeMeshForGPU: 1
+ weldVertices: 1
+ secondaryUVAngleDistortion: 8
+ secondaryUVAreaDistortion: 15.000001
+ secondaryUVHardAngle: 88
+ secondaryUVPackMargin: 4
+ tangentSpace:
+ normalSmoothAngle: 60
+ splitTangentsAcrossUV: 1
+ normalImportMode: 0
+ tangentImportMode: 2
+ importAnimation: 0
+ copyAvatar: 0
+ humanDescription:
+ human: []
+ skeleton: []
+ armTwist: .5
+ foreArmTwist: .5
+ upperLegTwist: .5
+ legTwist: .5
+ armStretch: .0500000007
+ legStretch: .0500000007
+ feetSpacing: 0
+ rootMotionBoneName:
+ lastHumanDescriptionAvatarSource: {instanceID: 0}
+ animationType: 1
+ additionalBone: 0
+ userData:
--- /dev/null
+Dynamic Bone apply physics to character's bones or joints.
+With simple setup, your character's hair, cloth, breasts or any part will move realistically.
+
+Open Assets/DynamicBone/Demo/Demo1 to see how it works.
+If you have any questions or suggestions, please contact willhongcom@gmail.com.
+
+
+-------------------------------------------------------------------------
+Basic setup:
+
+1. Prepare a properly setup character, both Mecanim and legacy rigs are supported.
+2. Select the game object you want to apply Dynamic Bone.
+3. In the component menu, select Dynamic Bone -> Dynamic Bone.
+4. In the inspector, select root object.
+5. Adjust dynamic bone parameters (see detail descriptions in the following section).
+
+
+You can add collider objects if required:
+
+1. Select game object the collider will attached.
+2. In the component menu, select Dynamic Bone -> Dynamic Bone Collider.
+3. Adjust position and size of the collider.
+4. In Dynamic Bone component, increase size of colliders and append corresponding object.
+
+
+-------------------------------------------------------------------------
+Dynamic Bone component description:
+
+- Root
+ The root of the transform hierarchy to apply physics.
+
+- Update Rate
+ Internal physics simulation rate, measures in frames per seconds.
+
+- UpdateMode
+ Normal: Normal update.
+ AnimatePhysics: Updates during the physic loop in order to synchronized with the physics engine.
+ UnscaledTime: Updates independently of Time.timeScale.
+
+- Damping
+ How much the bones slowed down.
+
+- Elasticity
+ How much the force applied to return each bone to original orientation.
+
+- Stiffness
+ How much bone's original orientation are preserved.
+
+- Inert
+ How much character's position change is ignored in physics simulation.
+
+- Friction
+ How much the bones slowed down when collide.
+
+- Radius
+ Each bone can be a sphere to collide with colliders. Radius describe sphere's size.
+
+- Damping Distrib, Elasticity Distrib, Stiffness Distrib, Inert Distrib, Radius Distrib
+ How parameters change over hierarchy chain. Curve values are multiplied to corresponding parameters.
+
+- End Length
+ If End Length is not zero, an extra bone is generated at the end of transform hierarchy,
+ length is multiplied by last two bone's distance.
+
+- End Offset
+ If End Offset is not zero, an extra bone is generated at the end of transform hierarchy,
+ offset is in character's local space.
+
+- Gravity
+ The force apply to bones, in world space. Partial force apply to character's initial pose is cancelled out.
+
+- Force
+ The force apply to bones, in world space.
+
+- Colliders
+ Collider objects interact with the bones.
+
+- Exclusions
+ Bones exclude from physics simulation.
+
+- Freeze Axis
+ Constrain bones to move on specified plane.
+
+- Distant Disable, Reference Object, Distance To Object
+ Disable physics simulation automatically if character is far from camera or player.
+ If there is no reference object, default main camera is used.
+
+
+Dynamic Bone Collider component description:
+
+- Center
+ The center of the sphere or capsule, in the object's local space.
+
+- Radius
+ The radius of the sphere or capsule, will be scaled by the transform's scale.
+
+- Height
+ The height of the capsule, including two half-spheres, will be scaled by the transform's scale.
+
+- Direction
+ The axis of the capsule's height.
+
+- Bound
+ Constrain bones to outside bound or inside bound.
+
+-------------------------------------------------------------------------
+Dynamic Bone script reference:
+
+- public void SetWeight(float w);
+ Control how physics blend with existing animation.
+
+- public void UpdateParameters();
+ Update parameters at runtime, call this funtion after modifing parameters.
+
+-------------------------------------------------------------------------
+Version History
+
+1.0.1 Initial release.
+1.0.2 Improve inspector UI.
+1.0.3 Fix inert unstable when enabled / disabled.
+1.1.0 Use curve to setup parameters over hierarchy chain.
+ Collider can configured to constrain bones inside bound.
+1.1.1 Add exclusion setting.
+1.1.2 Deal with negative scale problem.
+1.1.3 Fix bug with bones contain scale.
+1.1.4 Add freeze axis.
+ Fix bug when added via script.
+1.1.5 Add distant disable.
+ Reduce GC alloc.
+1.1.6 Fix capsule collider bug.
+1.1.7 Unity 5 support.
+1.1.8 Fix problems caused by negative scale.
+1.1.9 Improve detecting negative scale.
+ Fix bug if collider is set as inside.
+ Add UpdateMode setting.
+1.1.10 Fix problems caused by negative scale after Unity 5.4.
+1.2.0 Add tool tips.
+ Add plane collider.
+ Add function to update parameters at runtime.
+1.2.1 Add friction parameter.
+ Update UNITY_5 to compatible with newer version.
--- /dev/null
+fileFormatVersion: 2
+guid: bdbe6feeda2a62b45ad9a4e311031478
+TextScriptImporter:
+ userData:
--- /dev/null
+fileFormatVersion: 2
+guid: 993edbffbda2d3e4abd24f1bf074c5f2
+folderAsset: yes
+DefaultImporter:
+ userData:
--- /dev/null
+using UnityEngine;
+using System.Collections.Generic;
+
+[AddComponentMenu("Dynamic Bone/Dynamic Bone")]
+public class DynamicBone : MonoBehaviour
+{
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("The root of the transform hierarchy to apply physics.")]
+#endif
+ public Transform m_Root = null;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("Internal physics simulation rate.")]
+#endif
+ public float m_UpdateRate = 60.0f;
+
+ public enum UpdateMode
+ {
+ Normal,
+ AnimatePhysics,
+ UnscaledTime
+ }
+ public UpdateMode m_UpdateMode = UpdateMode.Normal;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("How much the bones slowed down.")]
+#endif
+ [Range(0, 1)]
+ public float m_Damping = 0.1f;
+ public AnimationCurve m_DampingDistrib = null;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("How much the force applied to return each bone to original orientation.")]
+#endif
+ [Range(0, 1)]
+ public float m_Elasticity = 0.1f;
+ public AnimationCurve m_ElasticityDistrib = null;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("How much bone's original orientation are preserved.")]
+#endif
+ [Range(0, 1)]
+ public float m_Stiffness = 0.1f;
+ public AnimationCurve m_StiffnessDistrib = null;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("How much character's position change is ignored in physics simulation.")]
+#endif
+ [Range(0, 1)]
+ public float m_Inert = 0;
+ public AnimationCurve m_InertDistrib = null;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("How much the bones slowed down when collide.")]
+#endif
+ public float m_Friction = 0;
+ public AnimationCurve m_FrictionDistrib = null;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("Each bone can be a sphere to collide with colliders. Radius describe sphere's size.")]
+#endif
+ public float m_Radius = 0;
+ public AnimationCurve m_RadiusDistrib = null;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("If End Length is not zero, an extra bone is generated at the end of transform hierarchy.")]
+#endif
+ public float m_EndLength = 0;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("If End Offset is not zero, an extra bone is generated at the end of transform hierarchy.")]
+#endif
+ public Vector3 m_EndOffset = Vector3.zero;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("The force apply to bones. Partial force apply to character's initial pose is cancelled out.")]
+#endif
+ public Vector3 m_Gravity = Vector3.zero;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("The force apply to bones.")]
+#endif
+ public Vector3 m_Force = Vector3.zero;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("Collider objects interact with the bones.")]
+#endif
+ public List<DynamicBoneColliderBase> m_Colliders = null;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("Bones exclude from physics simulation.")]
+#endif
+ public List<Transform> m_Exclusions = null;
+
+
+ public enum FreezeAxis
+ {
+ None, X, Y, Z
+ }
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("Constrain bones to move on specified plane.")]
+#endif
+ public FreezeAxis m_FreezeAxis = FreezeAxis.None;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("Disable physics simulation automatically if character is far from camera or player.")]
+#endif
+ public bool m_DistantDisable = false;
+ public Transform m_ReferenceObject = null;
+ public float m_DistanceToObject = 20;
+
+ Vector3 m_LocalGravity = Vector3.zero;
+ Vector3 m_ObjectMove = Vector3.zero;
+ Vector3 m_ObjectPrevPosition = Vector3.zero;
+ float m_BoneTotalLength = 0;
+ float m_ObjectScale = 1.0f;
+ float m_Time = 0;
+ float m_Weight = 1.0f;
+ bool m_DistantDisabled = false;
+
+ class Particle
+ {
+ public Transform m_Transform = null;
+ public int m_ParentIndex = -1;
+ public float m_Damping = 0;
+ public float m_Elasticity = 0;
+ public float m_Stiffness = 0;
+ public float m_Inert = 0;
+ public float m_Friction = 0;
+ public float m_Radius = 0;
+ public float m_BoneLength = 0;
+ public bool m_isCollide = false;
+
+ public Vector3 m_Position = Vector3.zero;
+ public Vector3 m_PrevPosition = Vector3.zero;
+ public Vector3 m_EndOffset = Vector3.zero;
+ public Vector3 m_InitLocalPosition = Vector3.zero;
+ public Quaternion m_InitLocalRotation = Quaternion.identity;
+ }
+
+ List<Particle> m_Particles = new List<Particle>();
+
+ void Start()
+ {
+ SetupParticles();
+ }
+
+ void FixedUpdate()
+ {
+ if (m_UpdateMode == UpdateMode.AnimatePhysics)
+ PreUpdate();
+ }
+
+ void Update()
+ {
+ if (m_UpdateMode != UpdateMode.AnimatePhysics)
+ PreUpdate();
+ }
+
+ void LateUpdate()
+ {
+ if (m_DistantDisable)
+ CheckDistance();
+
+ if (m_Weight > 0 && !(m_DistantDisable && m_DistantDisabled))
+ {
+#if UNITY_5_3_OR_NEWER
+ float dt = m_UpdateMode == UpdateMode.UnscaledTime ? Time.unscaledDeltaTime : Time.deltaTime;
+#else
+ float dt = Time.deltaTime;
+#endif
+ UpdateDynamicBones(dt);
+ }
+ }
+
+ void PreUpdate()
+ {
+ if (m_Weight > 0 && !(m_DistantDisable && m_DistantDisabled))
+ InitTransforms();
+ }
+
+ void CheckDistance()
+ {
+ Transform rt = m_ReferenceObject;
+ if (rt == null && Camera.main != null)
+ rt = Camera.main.transform;
+ if (rt != null)
+ {
+ float d = (rt.position - transform.position).sqrMagnitude;
+ bool disable = d > m_DistanceToObject * m_DistanceToObject;
+ if (disable != m_DistantDisabled)
+ {
+ if (!disable)
+ ResetParticlesPosition();
+ m_DistantDisabled = disable;
+ }
+ }
+ }
+
+ void OnEnable()
+ {
+ ResetParticlesPosition();
+ }
+
+ void OnDisable()
+ {
+ InitTransforms();
+ }
+
+ void OnValidate()
+ {
+ m_UpdateRate = Mathf.Max(m_UpdateRate, 0);
+ m_Damping = Mathf.Clamp01(m_Damping);
+ m_Elasticity = Mathf.Clamp01(m_Elasticity);
+ m_Stiffness = Mathf.Clamp01(m_Stiffness);
+ m_Inert = Mathf.Clamp01(m_Inert);
+ m_Friction = Mathf.Clamp01(m_Friction);
+ m_Radius = Mathf.Max(m_Radius, 0);
+
+ if (Application.isEditor && Application.isPlaying)
+ {
+ InitTransforms();
+ SetupParticles();
+ }
+ }
+
+ void OnDrawGizmosSelected()
+ {
+ if (!enabled || m_Root == null)
+ return;
+
+ if (Application.isEditor && !Application.isPlaying && transform.hasChanged)
+ {
+ InitTransforms();
+ SetupParticles();
+ }
+
+ Gizmos.color = Color.white;
+ for (int i = 0; i < m_Particles.Count; ++i)
+ {
+ Particle p = m_Particles[i];
+ if (p.m_ParentIndex >= 0)
+ {
+ Particle p0 = m_Particles[p.m_ParentIndex];
+ Gizmos.DrawLine(p.m_Position, p0.m_Position);
+ }
+ if (p.m_Radius > 0)
+ Gizmos.DrawWireSphere(p.m_Position, p.m_Radius * m_ObjectScale);
+ }
+ }
+
+ public void SetWeight(float w)
+ {
+ if (m_Weight != w)
+ {
+ if (w == 0)
+ InitTransforms();
+ else if (m_Weight == 0)
+ ResetParticlesPosition();
+ m_Weight = w;
+ }
+ }
+
+ public float GetWeight()
+ {
+ return m_Weight;
+ }
+
+ void UpdateDynamicBones(float t)
+ {
+ if (m_Root == null)
+ return;
+
+ m_ObjectScale = Mathf.Abs(transform.lossyScale.x);
+ m_ObjectMove = transform.position - m_ObjectPrevPosition;
+ m_ObjectPrevPosition = transform.position;
+
+ int loop = 1;
+ if (m_UpdateRate > 0)
+ {
+ float dt = 1.0f / m_UpdateRate;
+ m_Time += t;
+ loop = 0;
+
+ while (m_Time >= dt)
+ {
+ m_Time -= dt;
+ if (++loop >= 3)
+ {
+ m_Time = 0;
+ break;
+ }
+ }
+ }
+
+ if (loop > 0)
+ {
+ for (int i = 0; i < loop; ++i)
+ {
+ UpdateParticles1();
+ UpdateParticles2();
+ m_ObjectMove = Vector3.zero;
+ }
+ }
+ else
+ {
+ SkipUpdateParticles();
+ }
+
+ ApplyParticlesToTransforms();
+ }
+
+ void SetupParticles()
+ {
+ m_Particles.Clear();
+ if (m_Root == null)
+ return;
+
+ m_LocalGravity = m_Root.InverseTransformDirection(m_Gravity);
+ m_ObjectScale = Mathf.Abs(transform.lossyScale.x);
+ m_ObjectPrevPosition = transform.position;
+ m_ObjectMove = Vector3.zero;
+ m_BoneTotalLength = 0;
+ AppendParticles(m_Root, -1, 0);
+ UpdateParameters();
+ }
+
+ void AppendParticles(Transform b, int parentIndex, float boneLength)
+ {
+ Particle p = new Particle();
+ p.m_Transform = b;
+ p.m_ParentIndex = parentIndex;
+ if (b != null)
+ {
+ p.m_Position = p.m_PrevPosition = b.position;
+ p.m_InitLocalPosition = b.localPosition;
+ p.m_InitLocalRotation = b.localRotation;
+ }
+ else // end bone
+ {
+ Transform pb = m_Particles[parentIndex].m_Transform;
+ if (m_EndLength > 0)
+ {
+ Transform ppb = pb.parent;
+ if (ppb != null)
+ p.m_EndOffset = pb.InverseTransformPoint((pb.position * 2 - ppb.position)) * m_EndLength;
+ else
+ p.m_EndOffset = new Vector3(m_EndLength, 0, 0);
+ }
+ else
+ {
+ p.m_EndOffset = pb.InverseTransformPoint(transform.TransformDirection(m_EndOffset) + pb.position);
+ }
+ p.m_Position = p.m_PrevPosition = pb.TransformPoint(p.m_EndOffset);
+ }
+
+ if (parentIndex >= 0)
+ {
+ boneLength += (m_Particles[parentIndex].m_Transform.position - p.m_Position).magnitude;
+ p.m_BoneLength = boneLength;
+ m_BoneTotalLength = Mathf.Max(m_BoneTotalLength, boneLength);
+ }
+
+ int index = m_Particles.Count;
+ m_Particles.Add(p);
+
+ if (b != null)
+ {
+ for (int i = 0; i < b.childCount; ++i)
+ {
+ bool exclude = false;
+ if (m_Exclusions != null)
+ {
+ for (int j = 0; j < m_Exclusions.Count; ++j)
+ {
+ Transform e = m_Exclusions[j];
+ if (e == b.GetChild(i))
+ {
+ exclude = true;
+ break;
+ }
+ }
+ }
+ if (!exclude)
+ AppendParticles(b.GetChild(i), index, boneLength);
+ else if (m_EndLength > 0 || m_EndOffset != Vector3.zero)
+ AppendParticles(null, index, boneLength);
+ }
+
+ if (b.childCount == 0 && (m_EndLength > 0 || m_EndOffset != Vector3.zero))
+ AppendParticles(null, index, boneLength);
+ }
+ }
+
+ public void UpdateParameters()
+ {
+ if (m_Root == null)
+ return;
+
+ m_LocalGravity = m_Root.InverseTransformDirection(m_Gravity);
+
+ for (int i = 0; i < m_Particles.Count; ++i)
+ {
+ Particle p = m_Particles[i];
+ p.m_Damping = m_Damping;
+ p.m_Elasticity = m_Elasticity;
+ p.m_Stiffness = m_Stiffness;
+ p.m_Inert = m_Inert;
+ p.m_Friction = m_Friction;
+ p.m_Radius = m_Radius;
+
+ if (m_BoneTotalLength > 0)
+ {
+ float a = p.m_BoneLength / m_BoneTotalLength;
+ if (m_DampingDistrib != null && m_DampingDistrib.keys.Length > 0)
+ p.m_Damping *= m_DampingDistrib.Evaluate(a);
+ if (m_ElasticityDistrib != null && m_ElasticityDistrib.keys.Length > 0)
+ p.m_Elasticity *= m_ElasticityDistrib.Evaluate(a);
+ if (m_StiffnessDistrib != null && m_StiffnessDistrib.keys.Length > 0)
+ p.m_Stiffness *= m_StiffnessDistrib.Evaluate(a);
+ if (m_InertDistrib != null && m_InertDistrib.keys.Length > 0)
+ p.m_Inert *= m_InertDistrib.Evaluate(a);
+ if (m_FrictionDistrib != null && m_FrictionDistrib.keys.Length > 0)
+ p.m_Friction *= m_FrictionDistrib.Evaluate(a);
+ if (m_RadiusDistrib != null && m_RadiusDistrib.keys.Length > 0)
+ p.m_Radius *= m_RadiusDistrib.Evaluate(a);
+ }
+
+ p.m_Damping = Mathf.Clamp01(p.m_Damping);
+ p.m_Elasticity = Mathf.Clamp01(p.m_Elasticity);
+ p.m_Stiffness = Mathf.Clamp01(p.m_Stiffness);
+ p.m_Inert = Mathf.Clamp01(p.m_Inert);
+ p.m_Friction = Mathf.Clamp01(p.m_Friction);
+ p.m_Radius = Mathf.Max(p.m_Radius, 0);
+ }
+ }
+
+ void InitTransforms()
+ {
+ for (int i = 0; i < m_Particles.Count; ++i)
+ {
+ Particle p = m_Particles[i];
+ if (p.m_Transform != null)
+ {
+ p.m_Transform.localPosition = p.m_InitLocalPosition;
+ p.m_Transform.localRotation = p.m_InitLocalRotation;
+ }
+ }
+ }
+
+ void ResetParticlesPosition()
+ {
+ for (int i = 0; i < m_Particles.Count; ++i)
+ {
+ Particle p = m_Particles[i];
+ if (p.m_Transform != null)
+ {
+ p.m_Position = p.m_PrevPosition = p.m_Transform.position;
+ }
+ else // end bone
+ {
+ Transform pb = m_Particles[p.m_ParentIndex].m_Transform;
+ p.m_Position = p.m_PrevPosition = pb.TransformPoint(p.m_EndOffset);
+ }
+ p.m_isCollide = false;
+ }
+ m_ObjectPrevPosition = transform.position;
+ }
+
+ void UpdateParticles1()
+ {
+ Vector3 force = m_Gravity;
+ Vector3 fdir = m_Gravity.normalized;
+ Vector3 rf = m_Root.TransformDirection(m_LocalGravity);
+ Vector3 pf = fdir * Mathf.Max(Vector3.Dot(rf, fdir), 0); // project current gravity to rest gravity
+ force -= pf; // remove projected gravity
+ force = (force + m_Force) * m_ObjectScale;
+
+ for (int i = 0; i < m_Particles.Count; ++i)
+ {
+ Particle p = m_Particles[i];
+ if (p.m_ParentIndex >= 0)
+ {
+ // verlet integration
+ Vector3 v = p.m_Position - p.m_PrevPosition;
+ Vector3 rmove = m_ObjectMove * p.m_Inert;
+ p.m_PrevPosition = p.m_Position + rmove;
+ float damping = p.m_Damping;
+ if (p.m_isCollide)
+ {
+ damping += p.m_Friction;
+ if (damping > 1)
+ damping = 1;
+ p.m_isCollide = false;
+ }
+ p.m_Position += v * (1 - damping) + force + rmove;
+ }
+ else
+ {
+ p.m_PrevPosition = p.m_Position;
+ p.m_Position = p.m_Transform.position;
+ }
+ }
+ }
+
+ void UpdateParticles2()
+ {
+ Plane movePlane = new Plane();
+
+ for (int i = 1; i < m_Particles.Count; ++i)
+ {
+ Particle p = m_Particles[i];
+ Particle p0 = m_Particles[p.m_ParentIndex];
+
+ float restLen;
+ if (p.m_Transform != null)
+ restLen = (p0.m_Transform.position - p.m_Transform.position).magnitude;
+ else
+ restLen = p0.m_Transform.localToWorldMatrix.MultiplyVector(p.m_EndOffset).magnitude;
+
+ // keep shape
+ float stiffness = Mathf.Lerp(1.0f, p.m_Stiffness, m_Weight);
+ if (stiffness > 0 || p.m_Elasticity > 0)
+ {
+ Matrix4x4 m0 = p0.m_Transform.localToWorldMatrix;
+ m0.SetColumn(3, p0.m_Position);
+ Vector3 restPos;
+ if (p.m_Transform != null)
+ restPos = m0.MultiplyPoint3x4(p.m_Transform.localPosition);
+ else
+ restPos = m0.MultiplyPoint3x4(p.m_EndOffset);
+
+ Vector3 d = restPos - p.m_Position;
+ p.m_Position += d * p.m_Elasticity;
+
+ if (stiffness > 0)
+ {
+ d = restPos - p.m_Position;
+ float len = d.magnitude;
+ float maxlen = restLen * (1 - stiffness) * 2;
+ if (len > maxlen)
+ p.m_Position += d * ((len - maxlen) / len);
+ }
+ }
+
+ // collide
+ if (m_Colliders != null)
+ {
+ float particleRadius = p.m_Radius * m_ObjectScale;
+ for (int j = 0; j < m_Colliders.Count; ++j)
+ {
+ DynamicBoneColliderBase c = m_Colliders[j];
+ if (c != null && c.enabled)
+ p.m_isCollide |= c.Collide(ref p.m_Position, particleRadius);
+ }
+ }
+
+ // freeze axis, project to plane
+ if (m_FreezeAxis != FreezeAxis.None)
+ {
+ switch (m_FreezeAxis)
+ {
+ case FreezeAxis.X:
+ movePlane.SetNormalAndPosition(p0.m_Transform.right, p0.m_Position);
+ break;
+ case FreezeAxis.Y:
+ movePlane.SetNormalAndPosition(p0.m_Transform.up, p0.m_Position);
+ break;
+ case FreezeAxis.Z:
+ movePlane.SetNormalAndPosition(p0.m_Transform.forward, p0.m_Position);
+ break;
+ }
+ p.m_Position -= movePlane.normal * movePlane.GetDistanceToPoint(p.m_Position);
+ }
+
+ // keep length
+ Vector3 dd = p0.m_Position - p.m_Position;
+ float leng = dd.magnitude;
+ if (leng > 0)
+ p.m_Position += dd * ((leng - restLen) / leng);
+ }
+ }
+
+ // only update stiffness and keep bone length
+ void SkipUpdateParticles()
+ {
+ for (int i = 0; i < m_Particles.Count; ++i)
+ {
+ Particle p = m_Particles[i];
+ if (p.m_ParentIndex >= 0)
+ {
+ p.m_PrevPosition += m_ObjectMove;
+ p.m_Position += m_ObjectMove;
+
+ Particle p0 = m_Particles[p.m_ParentIndex];
+
+ float restLen;
+ if (p.m_Transform != null)
+ restLen = (p0.m_Transform.position - p.m_Transform.position).magnitude;
+ else
+ restLen = p0.m_Transform.localToWorldMatrix.MultiplyVector(p.m_EndOffset).magnitude;
+
+ // keep shape
+ float stiffness = Mathf.Lerp(1.0f, p.m_Stiffness, m_Weight);
+ if (stiffness > 0)
+ {
+ Matrix4x4 m0 = p0.m_Transform.localToWorldMatrix;
+ m0.SetColumn(3, p0.m_Position);
+ Vector3 restPos;
+ if (p.m_Transform != null)
+ restPos = m0.MultiplyPoint3x4(p.m_Transform.localPosition);
+ else
+ restPos = m0.MultiplyPoint3x4(p.m_EndOffset);
+
+ Vector3 d = restPos - p.m_Position;
+ float len = d.magnitude;
+ float maxlen = restLen * (1 - stiffness) * 2;
+ if (len > maxlen)
+ p.m_Position += d * ((len - maxlen) / len);
+ }
+
+ // keep length
+ Vector3 dd = p0.m_Position - p.m_Position;
+ float leng = dd.magnitude;
+ if (leng > 0)
+ p.m_Position += dd * ((leng - restLen) / leng);
+ }
+ else
+ {
+ p.m_PrevPosition = p.m_Position;
+ p.m_Position = p.m_Transform.position;
+ }
+ }
+ }
+
+ static Vector3 MirrorVector(Vector3 v, Vector3 axis)
+ {
+ return v - axis * (Vector3.Dot(v, axis) * 2);
+ }
+
+ void ApplyParticlesToTransforms()
+ {
+#if !UNITY_5_4_OR_NEWER
+ // detect negative scale
+ Vector3 ax = Vector3.right;
+ Vector3 ay = Vector3.up;
+ Vector3 az = Vector3.forward;
+ bool nx = false, ny = false, nz = false;
+
+ Vector3 loosyScale = transform.lossyScale;
+ if (loosyScale.x < 0 || loosyScale.y < 0 || loosyScale.z < 0)
+ {
+ Transform mirrorObject = transform;
+ do
+ {
+ Vector3 ls = mirrorObject.localScale;
+ nx = ls.x < 0;
+ if (nx)
+ ax = mirrorObject.right;
+ ny = ls.y < 0;
+ if (ny)
+ ay = mirrorObject.up;
+ nz = ls.z < 0;
+ if (nz)
+ az = mirrorObject.forward;
+ if (nx || ny || nz)
+ break;
+
+ mirrorObject = mirrorObject.parent;
+ }
+ while (mirrorObject != null);
+ }
+#endif
+
+ for (int i = 1; i < m_Particles.Count; ++i)
+ {
+ Particle p = m_Particles[i];
+ Particle p0 = m_Particles[p.m_ParentIndex];
+
+ if (p0.m_Transform.childCount <= 1) // do not modify bone orientation if has more then one child
+ {
+ Vector3 v;
+ if (p.m_Transform != null)
+ v = p.m_Transform.localPosition;
+ else
+ v = p.m_EndOffset;
+ Vector3 v2 = p.m_Position - p0.m_Position;
+#if !UNITY_5_4_OR_NEWER
+ if (nx)
+ v2 = MirrorVector(v2, ax);
+ if (ny)
+ v2 = MirrorVector(v2, ay);
+ if (nz)
+ v2 = MirrorVector(v2, az);
+#endif
+ Quaternion rot = Quaternion.FromToRotation(p0.m_Transform.TransformDirection(v), v2);
+ p0.m_Transform.rotation = rot * p0.m_Transform.rotation;
+ }
+
+ if (p.m_Transform != null)
+ p.m_Transform.position = p.m_Position;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: f9ac8d30c6a0d9642a11e5be4c440740
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
--- /dev/null
+using UnityEngine;
+
+[AddComponentMenu("Dynamic Bone/Dynamic Bone Collider")]
+public class DynamicBoneCollider : DynamicBoneColliderBase
+{
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("The radius of the sphere or capsule.")]
+#endif
+ public float m_Radius = 0.5f;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("The height of the capsule.")]
+#endif
+ public float m_Height = 0;
+
+ void OnValidate()
+ {
+ m_Radius = Mathf.Max(m_Radius, 0);
+ m_Height = Mathf.Max(m_Height, 0);
+ }
+
+ public override bool Collide(ref Vector3 particlePosition, float particleRadius)
+ {
+ float radius = m_Radius * Mathf.Abs(transform.lossyScale.x);
+ float h = m_Height * 0.5f - m_Radius;
+ if (h <= 0)
+ {
+ if (m_Bound == Bound.Outside)
+ return OutsideSphere(ref particlePosition, particleRadius, transform.TransformPoint(m_Center), radius);
+ else
+ return InsideSphere(ref particlePosition, particleRadius, transform.TransformPoint(m_Center), radius);
+ }
+ else
+ {
+ Vector3 c0 = m_Center;
+ Vector3 c1 = m_Center;
+
+ switch (m_Direction)
+ {
+ case Direction.X:
+ c0.x -= h;
+ c1.x += h;
+ break;
+ case Direction.Y:
+ c0.y -= h;
+ c1.y += h;
+ break;
+ case Direction.Z:
+ c0.z -= h;
+ c1.z += h;
+ break;
+ }
+ if (m_Bound == Bound.Outside)
+ return OutsideCapsule(ref particlePosition, particleRadius, transform.TransformPoint(c0), transform.TransformPoint(c1), radius);
+ else
+ return InsideCapsule(ref particlePosition, particleRadius, transform.TransformPoint(c0), transform.TransformPoint(c1), radius);
+ }
+ }
+
+ static bool OutsideSphere(ref Vector3 particlePosition, float particleRadius, Vector3 sphereCenter, float sphereRadius)
+ {
+ float r = sphereRadius + particleRadius;
+ float r2 = r * r;
+ Vector3 d = particlePosition - sphereCenter;
+ float len2 = d.sqrMagnitude;
+
+ // if is inside sphere, project onto sphere surface
+ if (len2 > 0 && len2 < r2)
+ {
+ float len = Mathf.Sqrt(len2);
+ particlePosition = sphereCenter + d * (r / len);
+ return true;
+ }
+ return false;
+ }
+
+ static bool InsideSphere(ref Vector3 particlePosition, float particleRadius, Vector3 sphereCenter, float sphereRadius)
+ {
+ float r = sphereRadius - particleRadius;
+ float r2 = r * r;
+ Vector3 d = particlePosition - sphereCenter;
+ float len2 = d.sqrMagnitude;
+
+ // if is outside sphere, project onto sphere surface
+ if (len2 > r2)
+ {
+ float len = Mathf.Sqrt(len2);
+ particlePosition = sphereCenter + d * (r / len);
+ return true;
+ }
+ return false;
+ }
+
+ static bool OutsideCapsule(ref Vector3 particlePosition, float particleRadius, Vector3 capsuleP0, Vector3 capsuleP1, float capsuleRadius)
+ {
+ float r = capsuleRadius + particleRadius;
+ float r2 = r * r;
+ Vector3 dir = capsuleP1 - capsuleP0;
+ Vector3 d = particlePosition - capsuleP0;
+ float t = Vector3.Dot(d, dir);
+
+ if (t <= 0)
+ {
+ // check sphere1
+ float len2 = d.sqrMagnitude;
+ if (len2 > 0 && len2 < r2)
+ {
+ float len = Mathf.Sqrt(len2);
+ particlePosition = capsuleP0 + d * (r / len);
+ return true;
+ }
+ }
+ else
+ {
+ float dl = dir.sqrMagnitude;
+ if (t >= dl)
+ {
+ // check sphere2
+ d = particlePosition - capsuleP1;
+ float len2 = d.sqrMagnitude;
+ if (len2 > 0 && len2 < r2)
+ {
+ float len = Mathf.Sqrt(len2);
+ particlePosition = capsuleP1 + d * (r / len);
+ return true;
+ }
+ }
+ else if (dl > 0)
+ {
+ // check cylinder
+ t /= dl;
+ d -= dir * t;
+ float len2 = d.sqrMagnitude;
+ if (len2 > 0 && len2 < r2)
+ {
+ float len = Mathf.Sqrt(len2);
+ particlePosition += d * ((r - len) / len);
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ static bool InsideCapsule(ref Vector3 particlePosition, float particleRadius, Vector3 capsuleP0, Vector3 capsuleP1, float capsuleRadius)
+ {
+ float r = capsuleRadius - particleRadius;
+ float r2 = r * r;
+ Vector3 dir = capsuleP1 - capsuleP0;
+ Vector3 d = particlePosition - capsuleP0;
+ float t = Vector3.Dot(d, dir);
+
+ if (t <= 0)
+ {
+ // check sphere1
+ float len2 = d.sqrMagnitude;
+ if (len2 > r2)
+ {
+ float len = Mathf.Sqrt(len2);
+ particlePosition = capsuleP0 + d * (r / len);
+ return true;
+ }
+ }
+ else
+ {
+ float dl = dir.sqrMagnitude;
+ if (t >= dl)
+ {
+ // check sphere2
+ d = particlePosition - capsuleP1;
+ float len2 = d.sqrMagnitude;
+ if (len2 > r2)
+ {
+ float len = Mathf.Sqrt(len2);
+ particlePosition = capsuleP1 + d * (r / len);
+ return true;
+ }
+ }
+ else if (dl > 0)
+ {
+ // check cylinder
+ t /= dl;
+ d -= dir * t;
+ float len2 = d.sqrMagnitude;
+ if (len2 > r2)
+ {
+ float len = Mathf.Sqrt(len2);
+ particlePosition += d * ((r - len) / len);
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ void OnDrawGizmosSelected()
+ {
+ if (!enabled)
+ return;
+
+ if (m_Bound == Bound.Outside)
+ Gizmos.color = Color.yellow;
+ else
+ Gizmos.color = Color.magenta;
+ float radius = m_Radius * Mathf.Abs(transform.lossyScale.x);
+ float h = m_Height * 0.5f - m_Radius;
+ if (h <= 0)
+ {
+ Gizmos.DrawWireSphere(transform.TransformPoint(m_Center), radius);
+ }
+ else
+ {
+ Vector3 c0 = m_Center;
+ Vector3 c1 = m_Center;
+
+ switch (m_Direction)
+ {
+ case Direction.X:
+ c0.x -= h;
+ c1.x += h;
+ break;
+ case Direction.Y:
+ c0.y -= h;
+ c1.y += h;
+ break;
+ case Direction.Z:
+ c0.z -= h;
+ c1.z += h;
+ break;
+ }
+ Gizmos.DrawWireSphere(transform.TransformPoint(c0), radius);
+ Gizmos.DrawWireSphere(transform.TransformPoint(c1), radius);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: baedd976e12657241bf7ff2d1c685342
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
--- /dev/null
+using UnityEngine;
+
+public class DynamicBoneColliderBase : MonoBehaviour
+{
+ public enum Direction
+ {
+ X, Y, Z
+ }
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("The axis of the capsule's height.")]
+#endif
+ public Direction m_Direction = Direction.Y;
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("The center of the sphere or capsule, in the object's local space.")]
+#endif
+ public Vector3 m_Center = Vector3.zero;
+
+ public enum Bound
+ {
+ Outside,
+ Inside
+ }
+
+#if UNITY_5_3_OR_NEWER
+ [Tooltip("Constrain bones to outside bound or inside bound.")]
+#endif
+ public Bound m_Bound = Bound.Outside;
+
+ public virtual bool Collide(ref Vector3 particlePosition, float particleRadius)
+ {
+ return false;
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 04878769c08021a41bc2d2375e23ec0b
+timeCreated: 1482666371
+licenseType: Store
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+[AddComponentMenu("Dynamic Bone/Dynamic Bone Plane Collider")]
+public class DynamicBonePlaneCollider : DynamicBoneColliderBase
+{
+ void OnValidate()
+ {
+ }
+
+ public override bool Collide(ref Vector3 particlePosition, float particleRadius)
+ {
+ Vector3 normal = Vector3.up;
+ switch (m_Direction)
+ {
+ case Direction.X:
+ normal = transform.right;
+ break;
+ case Direction.Y:
+ normal = transform.up;
+ break;
+ case Direction.Z:
+ normal = transform.forward;
+ break;
+ }
+
+ Vector3 p = transform.TransformPoint(m_Center);
+ Plane plane = new Plane(normal, p);
+ float d = plane.GetDistanceToPoint(particlePosition);
+
+ if (m_Bound == Bound.Outside)
+ {
+ if (d < 0)
+ {
+ particlePosition -= normal * d;
+ return true;
+ }
+ }
+ else
+ {
+ if (d > 0)
+ {
+ particlePosition -= normal * d;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ void OnDrawGizmosSelected()
+ {
+ if (!enabled)
+ return;
+
+ if (m_Bound == Bound.Outside)
+ Gizmos.color = Color.yellow;
+ else
+ Gizmos.color = Color.magenta;
+
+ Vector3 normal = Vector3.up;
+ switch (m_Direction)
+ {
+ case Direction.X:
+ normal = transform.right;
+ break;
+ case Direction.Y:
+ normal = transform.up;
+ break;
+ case Direction.Z:
+ normal = transform.forward;
+ break;
+ }
+
+ Vector3 p = transform.TransformPoint(m_Center);
+ Gizmos.DrawLine(p, p + normal);
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 4e535bdf3689369408cc4d078260ef6a
+timeCreated: 1482666461
+licenseType: Store
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
-5;0;4;0;0
\ No newline at end of file
+19;0;4;0;0
\ No newline at end of file
m_ShowMode: 4
m_Title:
m_RootView: {fileID: 6}
- m_MinSize: {x: 950, y: 300}
+ m_MinSize: {x: 950, y: 544}
m_MaxSize: {x: 10000, y: 10000}
--- !u!114 &2
MonoBehaviour:
y: 30
width: 1904
height: 912
- m_MinSize: {x: 883, y: 494}
+ m_MinSize: {x: 683, y: 494}
m_MaxSize: {x: 14004, y: 14044}
vertical: 0
- controlID: 29
+ controlID: 32
--- !u!114 &3
MonoBehaviour:
m_ObjectHideFlags: 52
y: 0
width: 1904
height: 962
- m_MinSize: {x: 950, y: 300}
+ m_MinSize: {x: 950, y: 544}
m_MaxSize: {x: 10000, y: 10000}
--- !u!114 &7
MonoBehaviour:
y: 0
width: 1517
height: 912
- m_MinSize: {x: 606, y: 494}
+ m_MinSize: {x: 406, y: 494}
m_MaxSize: {x: 10002, y: 14044}
vertical: 1
- controlID: 30
+ controlID: 33
--- !u!114 &10
MonoBehaviour:
m_ObjectHideFlags: 52
y: 0
width: 1517
height: 550
- m_MinSize: {x: 606, y: 222}
- m_MaxSize: {x: 6054, y: 4022}
+ m_MinSize: {x: 406, y: 222}
+ m_MaxSize: {x: 8006, y: 4022}
vertical: 0
- controlID: 31
+ controlID: 34
--- !u!114 &11
MonoBehaviour:
m_ObjectHideFlags: 52
y: 0
width: 1142
height: 550
- m_MinSize: {x: 404, y: 122}
- m_MaxSize: {x: 2052, y: 2070}
- m_ActualView: {fileID: 13}
+ m_MinSize: {x: 204, y: 222}
+ m_MaxSize: {x: 4004, y: 4022}
+ m_ActualView: {fileID: 17}
m_Panes:
- {fileID: 17}
- {fileID: 18}
- {fileID: 13}
- m_Selected: 2
- m_LastSelected: 0
+ m_Selected: 0
+ m_LastSelected: 2
--- !u!114 &12
MonoBehaviour:
m_ObjectHideFlags: 52
m_IsLocked: 0
m_FolderTreeState:
scrollPos: {x: 0, y: 73}
- m_SelectedIDs: 2c320000
- m_LastClickedID: 12844
- m_ExpandedIDs: 000000002c3200005a45000000ca9a3b
+ m_SelectedIDs: 68320000
+ m_LastClickedID: 12904
+ m_ExpandedIDs: 000000006832000000ca9a3b
m_RenameOverlay:
m_UserAcceptedRename: 0
m_Name:
scrollPos: {x: 0, y: 0}
m_SelectedIDs:
m_LastClickedID: 0
- m_ExpandedIDs: 000000002c320000
+ m_ExpandedIDs: 0000000068320000
m_RenameOverlay:
m_UserAcceptedRename: 0
m_Name:
scrollPos: {x: 0, y: 0}
m_SelectedIDs:
m_LastClickedID: 0
- m_ExpandedIDs: aefaffff
+ m_ExpandedIDs: 78fbffff
m_RenameOverlay:
m_UserAcceptedRename: 0
m_Name:
--- /dev/null
+{"m_ScriptingRuntimeVersion":1,"m_DefineSymbols":[],"m_AllowUnsafeCode":false}
\ No newline at end of file
--- /dev/null
+# Auto detect text files and perform LF normalization
+* text=auto
+
+# Custom for Visual Studio
+*.cs eol=lf
+
+# Standard to msysgit
+*.doc diff=astextplain
+*.DOC diff=astextplain
+*.docx diff=astextplain
+*.DOCX diff=astextplain
+*.dot diff=astextplain
+*.DOT diff=astextplain
+*.pdf diff=astextplain
+*.PDF diff=astextplain
+*.rtf diff=astextplain
+*.RTF diff=astextplain
--- /dev/null
+test_editors:
+ - version: 2019.1
+ - version: 2019.2
+ - version: trunk
+test_platforms:
+ - name: win
+ type: Unity::VM
+ image: package-ci/win10:stable
+ flavor: m1.large
+ - name: mac
+ type: Unity::VM::osx
+ image: buildfarm/mac:stable
+ flavor: m1.mac
+---
+pack:
+ name: Pack
+ agent:
+ type: Unity::VM
+ image: package-ci/win10:stable
+ flavor: m1.large
+ commands:
+ - npm install upm-ci-utils@stable -g --registry https://api.bintray.com/npm/unity/unity-npm
+ - upm-ci package pack
+ artifacts:
+ packages:
+ paths:
+ - "upm-ci~/packages/**/*"
+
+{% for editor in test_editors %}
+{% for platform in test_platforms %}
+test_{{ platform.name }}_{{ editor.version }}:
+ name : Test {{ editor.version }} on {{ platform.name }}
+ agent:
+ type: {{ platform.type }}
+ image: {{ platform.image }}
+ flavor: {{ platform.flavor}}
+ commands:
+ - npm install upm-ci-utils@stable -g --registry https://api.bintray.com/npm/unity/unity-npm
+ - upm-ci package test -u {{ editor.version }}
+ artifacts:
+ logs:
+ paths:
+ - "upm-ci~/test-results/**/*"
+ dependencies:
+ - .yamato/upm-ci.yml#pack
+{% endfor %}
+{% endfor %}
+
+test_trigger:
+ name: Tests Trigger
+ agent:
+ type: Unity::VM
+ image: package-ci/win10:stable
+ flavor: m1.large
+ commands:
+ - dir
+ artifacts:
+ logs:
+ paths:
+ - "upm-ci~/test-results/**/*"
+ packages:
+ paths:
+ - "upm-ci~/packages/**/*"
+ dependencies:
+ - .yamato/upm-ci.yml#pack
+ {% for editor in test_editors %}
+ {% for platform in test_platforms %}
+ - .yamato/upm-ci.yml#test_{{platform.name}}_{{editor.version}}
+ {% endfor %}
+ {% endfor %}
--- /dev/null
+# Changelog
+All notable changes to this package will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
+
+## [2.3.4] - 2019-05-22
+### PostProcessing V3 and bugfixes
+- Added support for PostProcessing V3 - now called CinemachineVolumeSttings
+- Added CinemachineCore.GetBlendOverride delegate to allow applications to override any vcam blend when it happens
+- When a blend is cancelled by the opposite blend, reduce the blend time
+- Orthographic cameras allow a Near Clip of 0
+- Timeline won't auto-create CM brains when something dragged onto it
+- Confiner: Improvement in automatic path invalidation when number of path points path changes
+- Added CinemachineInpuitAxisDriver utility for overriding the default AxisState behaviour
+- CinemachineCameraOffset: added customizable stage for when to apply the offset
+- Added Loop option to BlendList Camera
+- Improved Lookahead: does not automatically recenter
+- Brain no longer applies time scaling to fixed delta
+- Added dependency on Unity.ugui (2019.2 and up)
+- Bugfix: potential endless loop when using Ignore tag in Collider
+- Bugfix: Allow externally-driven FeeLook XAxis to work properly with SimpleFollow
+- Bugfix: vcams with noise would sometimes show one noiseless frame when they were activated and standby update was not Always
+- Bugfix: Generate a cut event if cutting to a blend-in-progess (fogbugz 1150847)
+- Bugfix: reset lens shift if not physical camera
+- Bugfix: Collider must consider actual target position, not lookahead position
+- Bugfix: FreeLook heading RecenterNow was not working
+- Bugfix: lookahead now takes the overridden Up into account
+- Bugfix: screen composer guides drawn in wrong place for picture-in-picture
+- Bugfix: FreeLook now draws only 1 active composer guide at a time (fogbugz 1138263)
+- Bugfix: cameras sometimes snapped when interrupting blends
+- Bugfix: Path handles no longer scale with the path object
+- Bugfix: Framing Transposer Center on Activate was not working properly (fogbugz 1129824)
+- Bugfix: FreeLook inherit position
+- Bugfix: collider was pushing camera too far if there were multiple overlapping obstacles
+- Bugfix: use IsAssignableFrom instead of IsSubclass in several places
+- Bugfix: when interrupting a blend in progress, Cut was not respected
+- Bugfix: collider minimum occlusion time and smoothing time interaction
+- Bugfix: TargetGroup.RemoveMember error (fogbugz 1119028)
+- Bugfix: TargetGroup member lerping jerk when member weight near 0
+- Bugfix: Transposer angular damping should be 0 only if binding mode not LockToTarget
+
+## [2.3.3] - 2019-01-08
+### Temporary patch to get around a Unity bug in conditional dependencies
+- Removed Cinemachine.Timeline namespace, as a workaround for fogbugz 1115321
+
+## [2.3.1] - 2019-01-07
+### Bugfixes
+- Added timeline dependency
+- OnTargetObjectWarped no longer generates garbage
+
+## [2.3.0] - 2018-12-20
+### Support for Unity 2019.1
+- Added dependency on new unity.timeline
+- Added conditional dependence on PostProcessingV2
+- No copying CM gizmo into assets folder
+- FreeLook: if inherit position from similar FreeLooks, bypass damping
+- Timeline: improve handling when vcam values are tweaked inside shot inspector (fogbugz 1109024)
+
+## [2.2.8] - 2018-12-10
+### Bugfixes, optimizations, and some experimental stuff
+- Transposer: added Angular Damping Mode, to support quaternion calculations in gimbal-lock situations
+- Framing Transposer and Group Transposer: group composing bugfixes, respect min/max limits
+- Added ConemachineCameraOffset extension, to offset the camera a fixed distance at the end of the pipeline
+- Dolly Cart: added support for LateUpdate
+- State-driven-camera: added [NoSaveDuringPlay] to Animated Target and Layer Index
+- Added AxisState.Recentering.RecenterNow() API call to skip wait time and start recentering now (if enabled)
+- Added NoLens blend hint, to leave camera Lens settings alone
+- Updated documentation (corrections, and relocation to prevent importing)
+- Upgrade: added support for nested prefabs in Unity 2018.3 (fogbugz 1077395)
+- Optimization: position predictor is more efficient
+- Optimization: Composer caches some calculations
+- Optimization: Fix editor slowdown when Lens Presets asset is missing
+- Experimental: Optional new damping algorithm: attempt to reduce sensitivity to variable framerate
+- Experimental: Optional new extra-efficient versions of vcam and FreeLook (not back-compatible)
+- Timeline: play/pause doesn't kick out the timeline vcam
+- Path editor: make sure game view gets updated when a path waypoint is dragged in the scene view
+- Composer guides are shown even if Camera is attached to a renderTexture
+- Bugfix: allow impulse definition to be a non-public field (property drawer was complaining)
+- Bugfix: added null check for when there is no active virtual camera
+- Bugfix: CollisionImpulseSource typo in detection of 2D collider
+- Bugfix: PasteComponentValues to prefab vcams and FreeLooks were corrupting scene and prefabs
+- Bugfix: Timeline mixer was glitching for single frames at the end of blends
+- Bugfix: Added OnTransitionFromCamera() to POV and OrbitalTransposer, to transition axes intelligently
+- Regression fix: if no active vcam, don't set the Camera's transform
+
+## [2.2.7] - 2018-07-24
+### Mostly bugfixes
+- Bugfix: fogbugz case 1053595: Cinemachine Collider leaves hidden collider at origin that interferes with scene objects
+- Bugfix: fogbugz case 1063754: empty target group produces console messages
+- Bugfix: FreeLook Paste Component Values now pastes the CM subcomponents as well
+- Bugfix: added extra null checks to support cases where current vcam is dynamically deleted
+- Bugfix: reset BlendList when enabled
+- Regression fix: FreeLook axis values get transferred when similar vcams transition
+- Bugfix: cutting to BlendList vcam sometimes produced a few bad frames
+- Bugfix: smart update tracks the targets more efficiently and correctly, and supports RigidBody interpolation (2018.2 and up)
+- Enhancement: POV component interprets POV as relative to parent transform if there is one
+- API change: OnCameraLive and CameraActivated events take outgoing vcam also as parameter (may be null)
+
+## [2.2.0] - 2018-06-18
+### Impulse Module and More
+- New Cinemachine Impulse module for event-driven camera shakes
+- New Event Helper script CinemachineTriggerAction takes action on Collider and Collider2D enter/exit events, and exposes them as UnityEvents
+- New performance-tuning feature: Standby Update. Controls how often to update the vcam when it's in Standby.
+- New NoiseSettings editor with signal preview
+- Added Focal Length or Named FOV presets for Camera Lens
+- Added support for Physical Camera: focal length and Lens Offset
+- New improved Group framing algorithm: tighter group framing in GroupComposer and FramingTransposer
+- Collider: now returns TargetIsObscured if the target is offscreen (great for cameras with fixed aim)
+- Collider: added Minimum Occlusion Time setting, to ignore fleeting obstructions
+- Collider: added Transparent Layers mask, to specify solid objects that don't obstruct view
+- Collider: damping will no longer take the camera through obstacles
+- Collider: Added separate damping setting for when target is being occluded vs when camera is being returned to its normal position
+- Collider: added Smoothing setting, to reduce camera jumpiness in environements with lots of obstacles
+- NoiseSettings: added checkbox for pure sine-wave instead of Perlin wave
+- If no LookAt target, PostProcessing FocusTracksTarget offset is relative to camera
+- TrackedDolly: Default up mode sets Up to World Up
+- Virtual Camera: New Transitions section in inspector that gives more control over blending:
+ - Blend Hint provides some control over how the position and rotation are interpolated
+ - Inherit Position checkbox to ensure smooth positional handoff from outgoing camera
+ - OnCameraLive event gets fired when the camera activates. Useful for custom handlers.
+- Added ScreenSpaceAimWhenTargetsDiffer as a vcam blend hint. This influences what happens when blending between vcams with different LookAt targets
+- Increased stability of vcams with very small FOVs
+- Framing Transposer no longer requires LookAt to be null
+- LensSettings Aspect, Orthographic, IsPhysicalCamera, SensorSize properties no longer internal
+- Noise Profiles: don't magically create assets. Prompt user for filename and location of new or cloned profiles
+- Refactored interaction between timeline and CM brain, to improve handling of edge cases (fogbugz case 1048497)
+- Bugfix: StateDrivenCamera Editor was not finding states if target was OverrideController
+- Bugfix when dragging orbital transposer transform: take bias into account
+- Bugfix: SaveDuringPlay was not handling asset fields correctly - was sometimes crushing assets
+- Bugfix: SimpleFollow transposers were not initilizing their position correctly at game start
+- Bugfix: Timeline with CM shot was causing jitter in some FixedUpdate situations
+- Bugfix: Multiple brains with heterogeneous update methods were not behaving correctly. CM will now support this, but you must make sure that the brains have different layer masks.
+- Example scenes now include use of CinemachineTriggerAction script.
+
+## [2.1.13] - 2018-05-09
+### Removed dependency on nonexistant Timeline package, minor bugfixes
+- Bugfix: Custom Blends "Any to Any" was not working (regression)
+- Bugfix: Composer was sometimes getting wrong aspect if multiple brains with different aspect ratios
+- Bugfix: could not drag vcam transforms if multiple inspectors and one is hidden
+- Bugfix: Framing Transposer initializes in the wrong place - noticeable if dead zone
+
+## [2.1.12] - 2018-02-26
+### Storyboard, Bugfixes and other enhancements. Also some restructuring for Package Manager
+- Project restructure: Removed Base, Timeline, and PostFX folders from project root. PostProcessing code must now be manually imported from Cinemachine menu. No more dependencies on scripting defines.
+- New Storyboard extension, to display images over the vcams. Comes with a Waveform monitor window for color grading
+- New option to specify vcam position blend style: linear, spherical, or cylindrical, based on LookAt target
+- Added API to support seamless position warping of target objects: OnTargetObjectWarped().
+- Added support for custom blend curves
+- Lookahead: added Ignore Y Axis Movement option
+- Added support for cascading blends (i.e. blending from mid-blend looks better)
+- POV/Orbital/FreeLook axis: exposed Min, Max, and Wrap in the UI, for customized axis range
+- FreeLook: added Y Axis recentering
+- POV: Added recentering feature to both axes
+- Path: Added Normalized Path units option: 0 is start of path, 1 is end.
+- Path: added length display in inspector
+- Timeline Clip Editor: vcam sections are now collapsible
+- API enhancement: added Finalize to Pipeline stages, called even for manager-style vcams
+- Bugfix: PostProcessing V2 DoF blending works better
+- Bugfix: OrbitalTransposer works better with WorldUp overrides
+- Bugfix: Remove StateDrivenCamera "not playing a controller" warning
+- Bugfix: Handle exceptions thrown by assemblies that don't want to be introspected
+- Bugfix: vcams following physics objects incorrectly snapped to origin after exiting play mode
+- Bugfix: predictor now supports time pause
+- Bugfix: Moved StartCoroutine in Brain to OnEnable()
+- Bugfix: Collider was causing problems in Physics on Android platforms
+- Bugfix: dragging a vcam's position updtaes prefabs properly
+- Bugfix: All extension now respect the "enabled" checkbox
+- Bugfix: Undo for Extasion add will no longer generate null references
+
+## [2.1.10] - 2017-11-28
+### This is the first UPM release of *Unity Package Cinemachine*.
+- New Aim component: Same As Follow Target simply uses the same orientation as the Follow target
+- Perlin Noise component: added inspector UI to clone or locate existing Noise profiles, and to create new ones
+- Noise Presets were moved outside of the Examples folder
+- Example Assets are now included as embedded package, not imported by default
+- Bugfix: FreeLook with PositionDelta was not properly updating the heading
+- Bugfix: Transitioning between FreeLooks simetimes caused a short camera freeze
+- Bugfix: Added some null checks to FreeLook, to prevent error messages at build time
+
+## [2.1.9] - 2017-11-17
+### Initial version.
+*Version 2.1.9 cloned from private development repository, corresponding to package released on the asset store*
--- /dev/null
+fileFormatVersion: 2
+guid: 806a217c43cf53b4c9c731285489f52a
+TextScriptImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+# 2D graphics
+
+Cinemachine supports orthographic cameras. When you set the Unity camera's projection to Orthographic, Cinemachine adjusts to accommodate it. In Virtual Camera properties for __Lens__, __FOV__ is replaced by __Orthographic Size__. Note that settings related to FOV and certain FOV-oriented behaviors such as [Follow Zoom](CinemachineFollowZoom.html) have no effect if the camera is orthographic.
+
+In orthographic environments, it doesn’t usually make sense to rotate the camera. Accordingly, Cinemachine offers the [Framing Transposer](CinemachineBodyFramingTransposer.html) to handle framing and composition without rotating the camera.
+
--- /dev/null
+# Composer
+
+This Virtual Camera __Aim__ algorithm rotates the camera to face the __Look At__ target. It also applies offsets, damping, and composition rules. Examples of targets for aiming: the upper spine or head bone of a character, vehicles, or dummy objects which are controlled or animated programmatically.
+
+## Properties:
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Tracked Object Offset__ | Offset from the center of the Look At target, in target-local space. Fine-tune the tracking target position when the desired area is not the tracked object’s center. |
+| __Lookahead Time__ | Adjust the offset based on the motion of the Look At target. The algorithm estimates the point that the target will be this many seconds into the future. This feature is sensitive to noisy animation. It can amplify the noise, resulting in undesirable camera jitter. If the camera jitters unacceptably when the target is in motion, turn down this property or animate the target more smoothly. |
+| __Lookahead Smoothing__ | Controls the smoothness of the lookahead algorithm. Larger values smooth out jittery predictions and increase prediction lag. |
+| __Lookahead Ignore Y__ | Toggle to ignore movement along the Y axis for lookahead calculations. |
+| __Horizontal Damping__ | How responsively the camera follows the target in the screen-horizontal direction. Use small numbers for more responsive, rapid rotation of the camera to keep the target in the dead zone. Use larger numbers for a more heavy, slowly-responding camera. |
+| __Vertical Damping__ | How responsively the camera follows the target in the screen-vertical direction. Use different vertical and horizontal settings to give a wide range of camera behaviors. |
+| __Screen X__ | Horizontal screen position for the center of the dead zone. The camera rotates so that the target appears here. |
+| __Screen Y__ | Vertical screen position for target, The camera rotates so that the target appears here. |
+| __Dead Zone Width__ | The width of the screen region within which the camera ignores any movement of the target. If the target is positioned anywhere within this region, the Virtual Camera does not update its rotation. This is useful for ignoring minor target movement. |
+| __Dead Zone Height__ | The height of the screen region within which the camera ignores any movement of the target. If the target is positioned anywhere within this region, the Virtual Camera does not update its rotation. This is useful for ignoring minor target movement. |
+| __Soft Zone Width__ | The width of the soft zone. If the target appears in this region of the screen, the camera will rotate to push it back out to the dead zone, in the time specified by the Horizontal Damping setting. |
+| __Soft Zone Height__ | The height of the soft zone. If the target appears in this region of the screen, the camera will rotate to push it back out to the dead zone, in the time specified by the Vertical Damping setting. |
+| __Bias X__ | Positions the soft zone horizontally, relative to the dead zone. |
+| __Bias Y__ | Positions the soft zone vertically, relative to the dead zone. |
+
--- /dev/null
+# Do Nothing
+
+This Virtual Camera __Aim__ algorithm does not aim the Virtual Camera. Choose this algorithm for static shots or for animating the rotation directly with custom scripts.
+
--- /dev/null
+# Group Composer
+
+This Virtual Camera __Aim__ algorithm aims the camera at multiple GameObjects. Otherwise, it behaves identically to the Composer and has the same settings. If the Look At target is a [Cinemachine Target Group](CinemachineTargetGroup.html), the algorithm adjusts the FOV and the camera distance to ensure that the group of targets is framed properly.
+
--- /dev/null
+# Hard Look At
+
+This Virtual Camera __Aim__ algorithm rotates the Virtual Camera to keep the __Look At__ target in the center of the camera frame.
+
--- /dev/null
+# POV
+
+This Virtual Camera __Aim__ algorithm aims the camera in response to the user’s input.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Vertical Axis__ || Controls the vertical orientation of the Virtual Camera’s aim. |
+| | _Value_ | The current value of the axis to aim the camera at, in degrees. Accepted values are -90 to 90. |
+| | _Value Range_ | The minimum and maximum values for the vertrial axis of the Virtual Camera. |
+| | _Wrap_ | If checked, the axis wraps around the Value Range values, forming a loop. |
+| | _Max Speed_ | The maximum speed of this axis in degrees/second. |
+| | _Accel Time_ | The amount of time in seconds it takes to accelerate to Max Speed with the supplied axis at its maximum value. |
+| | _Decel Time_| The amount of time in seconds it takes to decelerate the axis to zero if the supplied axis is in a neutral position. |
+| | _Input Axis Name_ | The name of this axis as specified in Unity Input Manager. To disable the automatic updating of this axis, set this property to an empty string. |
+| | _Input Axis Value_ | The value of the input axis. A value of 0 means no input. You can drive this directly from a custom input system, or you can set the Input Axis Name and have the value driven by the Unity Input Manager. |
+| | _Invert_ | Check to invert the raw value of the input axis before it is used. |
+| __Vertical Recentering__ || Controls automatic vertical recentering when the player gives no input. |
+| | _Enabled_ | Check to enable automatic vertical recentering. |
+| | _Wait Time_ | If no user input has been detected on the vertical axis, the camera waits this long in seconds before recentering. |
+| | _Recentering Time_ | Maximum angular speed of recentering. Accelerates into and decelerates out of this. |
+| __Horizontal Axis__ || Controls the horizontal orientation. |
+| | _Value_ | The current value of the axis, in degrees. Accepted values are -180 to 180. |
+| | _Value Range_ | The minimum and maximum values for the axis. |
+| | _Wrap_ | If checked, the axis wraps around the Value Range values, forming a loop. |
+| | _Max Speed_ | The maximum speed of this axis in degrees per second. |
+| | _Accel Time_ | The amount of time in seconds it takes to accelerate to Max Speed with the supplied Axis at its maximum value. |
+| | _Decel Time_ | The amount of time in seconds it takes to decelerate the axis to zero if the supplied axis is in a neutral position. |
+| | _Input Axis Name_ | The name of this axis as specified in the Unity Input Manager. Set this property to an empty string to disable automatic update of this axis. |
+| | _Input Axis Value_ | The value of the input axis. A value of 0 means no input. You can drive this directly from a custom input system, or you can set the Input Axis Name and have the value driven by the Unity Input Manager. |
+| | _Invert_ | Check to invert the raw value of the input axis before it is used. |
+| __Horizontal Recentering__ || Controls automatic vertical recentering when the player gives no input. |
+| | _Enabled_ | Check to enable automatic vertical recentering. |
+| | _Wait Time_ | If no user input has been detected on the vertical axis, the camera waits this long in seconds before recentering. |
+| | _Recentering Time_ | Maximum angular speed of recentering. Accelerates into and decelerates out of this. |
+
--- /dev/null
+# Same As Follow Target
+
+This Virtual Camera __Aim__ algorithm matches the orientation of the __Follow__ target. When used with the __Hard Lock to Target__ algorithm in the __Body__ properties, this algorithm makes the Virtual Camera match the path and rotation of a control GameObject.
+
--- /dev/null
+# Cinemachine Blend List Camera
+
+The __Cinemachine Blend List Camera__ component executes a sequence of blends or cuts among its child Virtual Cameras.
+
+When the Blend List camera is activated, it executes its list of instructions, activating the first child Virtual Camera in the list, holding for a designated time, then cutting or blending to the next child, and so on. The Blend List camera holds the last Virtual Camera until Cinemachine Brain or Timeline deactivates the Blend List camera.
+
+**Tip**: Use a Blend List Camera instead of [Timeline](CinemachineTimeline.html) for simpler, automatic sequences.
+
+## Properties:
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Solo__ | Toggles whether or not the Blend List camera is temporarily live. Use this property to get immediate visual feedback in the [Game view](https://docs.unity3d.com/Manual/GameView.html) to adjust the Virtual Camera. |
+| __Game Window Guides__ | Toggles the visibility of compositional guides in the Game view. This property applies to all Virtual Cameras. |
+| __Save During Play__ | Check to [apply the changes while in Play mode](CinemachineSavingDuringPlay.html). Use this feature to fine-tune a Virtual Camera without having to remember which properties to copy and paste. This property applies to all Virtual Cameras. |
+| __Priority__ | The importance of this Blend List camera for choosing the next shot. A higher value indicates a higher priority. Cinemachine Brain chooses the next live Virtual Camera from all Virtual Cameras that are activated and have the same or higher priority as the current live Virtual Camera. This property has no effect when using a Virtual Camera with Timeline. |
+| __Look At__ | The default target GameObject that the children Virtual Camera move with. The Blend List camera uses this target when the child does not specify this target. May be empty if all of the children define targets of their own. |
+| __Follow__ | The default target GameObject to aim the Unity camera at. The Blend List camera uses this target when the child does not specify this target. May be empty if all of the children define targets of their own. |
+| __Show Debug Text__ | Check to display a textual summary of the live Virtual Camera and blend in the view. |
+| __Enable All Child Cameras__ | Check to activate all child cameras. This is useful if animating them in Timeline, but consumes extra resources. |
+| __Instructions__ | The set of instructions for enabling child cameras. |
--- /dev/null
+# Blending between Virtual Cameras
+
+Use blending properties to specify how the Cinemachine Brain component performs a blend between virtual cameras.
+
+A Cinemachine blend is not a fade, wipe, or dissolve. Rather, Cinemachine Brain performs a smooth animation of the position, rotation, and other settings of the Unity camera from one Virtual Camera to the next.
+
+For blends between specific Virtual Cameras, use the __Custom Blends__ list in the Cinemachine Brain component. Use the __Default Blend__ property in Cinemachine Brain to specify blends between Virtual Cameras that do not have custom blends.
+
+
+
+The __From__ and __To__ settings are name-based, not references. This means that Cinemachine finds cameras by matching their names to the settings. They are not linked to specific GameObjects.
+
+Use the name \*\*ANY CAMERA\*\* to blend from or to any Virtual Camera.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __From__ || The name of the Virtual Camera to blend from. Use the name \*\*ANY CAMERA\*\* to blend from any Virtual Camera. This property is available only for custom blends. |
+| __To__ || The name of the Virtual Camera to blend to. Use the name \*\*ANY CAMERA\*\* to blend to any Virtual Camera. This property is available only for custom blends. |
+| __Style Default Blend__ || Shape of the blend curve. |
+| | _Cut_ | Zero-length blend. |
+| | _Ease In Out_ | S-shaped curve, giving a gentle and smooth transition. |
+| | _Ease In_ | Linear out of the outgoing Virtual Camera, and ease into the incoming Virtual Camera. |
+| | _Ease Out_ | Ease out of the outgoing Virtual Camera, and blend linearly into the incoming Virtual Camera. |
+| | _Hard In_ | Ease out of the outgoing Virtual Camera, and accelerate into the incoming Virtual Camera. |
+| | _Hard Out_ | Accelerate out of the outgoing Virtual Camera, and ease into the incoming Virtual Camera. |
+| | _Linear_ | Linear blend. mechanical-looking. |
+| | _Custom_ | Custom blend curve. Allows you to draw a custom blend curve. |
+| __Time__ || Duration (in seconds) of the blend. |
+
+
--- /dev/null
+# Do Nothing
+
+This Virtual Camera __Body__ algorithm does not move the Virtual Camera; it does not modify its position. Choose this algorithm for static shots or for animating the camera position directly with your custom scripts.
+
--- /dev/null
+# Framing Transposer
+
+This Virtual Camera __Body__ algorithm moves the camera in a fixed screen-space relationship to the __Follow__ target. You can also specify offsets, damping, and composition rules. __Framing Transposer__ only changes the camera’s position in space. It does not re-orient or otherwise aim the camera.
+
+__Framing Transposer__ is designed for 2D and orthographic cameras. But it works equally well with perspective cameras and 3D environments.
+
+This algorithm first moves the camera along the camera Z axis until the __Follow__ target is at the desired distance from the camera’s X-Y plane. It then moves the camera in its X-Y plane until the __Follow__ target is at the desired point on the camera’s screen.
+
+**Note**: To use __Framing Transposer__, the __Look At__ property must be empty.
+
+If the __Follow__ target is a [Target Group](CinemachineTargetGroup.html), then additional properties are available to frame the entire group.
+
+## Properties
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Lookahead Time__ || Adjusts the offset of the Virtual Camera from the Follow target based on the motion of the target. Cinemachine estimates the point where the target will be this many seconds into the future. This feature is sensitive to noisy animation and can amplify the noise, resulting in undesirable camera jitter. If the camera jitters unacceptably when the target is in motion, turn down this property, or animate the target more smoothly. |
+| __Lookahead Smoothing__ || The smoothness of the lookahead algorithm. Larger values smooth out jittery predictions and increase prediction lag. |
+| __Lookahead Ignore Y__ || If checked, ignore movement along the Y axis for lookahead calculations. |
+| __X Damping__ || How responsively the camera tries to maintain the offset in the x-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. Using different settings per axis can yield a wide range of camera behaviors. |
+| __Y Damping__ || How responsively the camera tries to maintain the offset in the y-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Z Damping__ || How responsively the camera tries to maintain the offset in the z-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Screen X__ || Horizontal screen position for target. The camera moves to position the tracked object here. |
+| __Screen Y__ || Vertical screen position for target, The camera moves to position the tracked object here. |
+| __Camera Distance__ || The distance to maintain along the camera axis from the Follow target. |
+| __Dead Zone Width__ || Do not move the camera horizontally when the target is within this range of the position. |
+| __Dead Zone Height__ || Do not move the camera vertically if the target is within this range of the position. |
+| __Dead Zone Depth__ || Do not move the camera along its z-axis if the Follow target is within this distance of the specified camera distance. |
+| __Unlimited Soft Zone__ || If checked, then the soft zone is unlimited in size. |
+| __Soft Zone Width__ || When the target is in this range, move the camera horizontally to frame the target in the dead zone. The Damping properties affect the rate of the camera movement. |
+| __Soft Zone Height__ || When the target is in this range, move the camera vertically to frame the target in the dead zone. The Damping properties affect the rate of the camera movement. |
+| __Bias X__ || Moves the target position horizontally away from the center of the soft zone. |
+| __Bias Y__ || Moves the target position vertically away from the center of the soft zone. |
+| __Group Framing Mode__ || Available when Follow specifies a [Target Group](CinemachineTargetGroup.html). Specifies the screen dimensions to consider when framing. |
+| | _Horizontal_ | Consider only the horizontal dimension. Ignore vertical framing. |
+| | _Vertical_ | Consider only the vertical dimension. Ignore horizontal framing. |
+| | _Horizontal And Vertical_ | Use the larger of the horizontal and vertical dimensions to get the best fit. |
+| | _None_ | Don’t do any framing adjustment. |
+| __Adjustment Mode__ || How to adjust the camera to get the desired framing. You can zoom, dolly in or out, or do both. Available when Follow specifies a Target Group. |
+| | _Zoom Only_ | Don’t move the camera, only adjust the FOV. |
+| | _Dolly Only_ | Move the camera, don’t change the FOV. |
+| | _Dolly Then Zoom_ | Move the camera as much as permitted by the ranges, then adjust the FOV if necessary to make the shot. |
+| __Group Framing Size__ || The bounding box that the targets should occupy. Use 1 to fill the whole screen, 0.5 to fill half the screen, and so on. Available when Follow specifies a Target Group. |
+| __Max Dolly In__ || The maximum distance toward the target to move the camera. Available when Follow specifies a Target Group. |
+| __Max Dolly Out__ || The maximum distance away from the target to move the camera. Available when Follow specifies a Target Group. |
+| __Minimum Distance__ || Set this to limit how close to the target the camera can get. Available when Follow specifies a Target Group. |
+| __Maximum Distance__ || Set this to limit how far from the target the camera can get. Available when Follow specifies a Target Group. |
+| __Minimum FOV__ || If adjusting FOV, do not set the FOV lower than this. Available when Follow specifies a Target Group. |
+| __Maximum FOV__ || If adjusting FOV, do not set the FOV higher than this. Available when Follow specifies a Target Group. |
+| __Minimum Ortho Size__ || If adjusting Orthographic Size, do not set it lower than this. Available when Follow specifies a Target Group. |
+| __Maximum Ortho Size__ || If adjusting Orthographic Size, do not set it higher than this. Available when Follow specifies a Target Group. |
+
+
+
--- /dev/null
+# Hard Lock to Target
+
+This Virtual Camera __Body__ algorithm uses the same position at the __Follow__ target. In other words, the target acts as a mounting point for the Virtual Camera.
+
--- /dev/null
+# Orbital Transposer
+
+This Virtual Camera __Body__ algorithm moves the Unity camera in a variable relationship to the Virtual Camera’s __Follow__ target. It optionally accepts [player input](https://docs.unity3d.com/Manual/ConventionalGameInput.html), which allows the player to dynamically control the position of the camera relative to the target.
+
+The __Orbital Transposer__ introduces the concept of __heading__, which is the direction in which the target is moving or facing. Orbital Transposer attempts to position the camera so that it points in the same direction as the heading direction. By default, this position is directly behind the target. Control this relationship by adjusting the __Heading Bias__ property.
+
+If you attach an input controller to the __Orbital Transposer__, then the player can also control the camera. This allows the player to move the camera to any spot on an orbit around the target. Configure the __Orbital Transposer__ to take its input from any axis that you set up in the [Input Manager](https://docs.unity3d.com/Manual/class-InputManager.html). Or control the value directly using a custom input system.
+
+__Orbital Transposer __optionally automatically re-centers the camera. When __Recenter To Target Heading__ is checked, Orbital Transposer automatically moves the camera back to the target heading. You can specify the length of time to wait after it has detected no user input and the speed of the recentering.
+
+
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Binding Mode__ || The coordinate space to use when interpreting the offset of the Virtual Camera from the Follow target. |
+| | _Lock To Target On Assign_ | The target’s local frame at the moment when the Virtual Camera was activated, or when the target was assigned. |
+| | _Lock To Target With World Up_ | The target’s local frame, with the tilt and roll reset to zero. |
+| | _Lock To Target No Roll_ | The target’s local frame, with the roll reset to zero. |
+| | _Lock To Target_ | The target’s local frame. |
+| | _World Space_ | World space offset. |
+| | _Simple Follow With World Up_ | Relative to the target, using camera-local axes. |
+| __Follow Offset__ || The position offset to attempt to maintain from the Follow target. |
+| __X Damping__ || How responsively the camera tries to maintain the offset in the x-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. Using different settings per axis can yield a wide range of camera behaviors. Not available when Binding Mode is Simple Follow With World Up. |
+| __Y Damping__ || How responsively the camera tries to maintain the offset in the y-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Z Damping__ || How responsively the camera tries to maintain the offset in the z-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Yaw Damping__ || How responsively the camera tries to track the target rotation’s y angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. Available when Binding Mode is Lock to Target With World Up, Lock to Target No Roll, or Lock to Target. |
+| __Pitch Damping__ || How responsively the camera tries to track the target rotation’s x angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. Available when Binding Mode is Lock to Target No Roll or Lock to Target. |
+| __Roll Damping__ || How responsively the camera tries to track the target rotation’s z angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. Available when Binding Mode is Lock to Target. |
+| __Heading__ || Specifies how to calculate the heading of the Follow target. |
+| | _Definition_ | Choose Position Delta to calculate heading based on the difference in the position of the target from the last update and the current frame. Choose Velocity to use the velocity of the [Rigidbody](https://docs.unity3d.com/Manual/class-Rigidbody.html) of the target. If the target has no Rigidbody component, reverts to Position Delta. Choose Target Forward to use the target's local Forward axis as the heading. Choose World Forward to use a constant world-space Forward as heading. |
+| | _Velocity Filter Strength_ | Controls the smoothing of the velocity when using Position Delta or Velocity in Definition. |
+| | _Bias_ | Angular offset in the orbit to place the camera, relative to the heading. Measured in degrees. An axis value of 0 will put the camera here. |
+| __Recenter To Target Heading__ || Controls automatic recentering when the player gives no input. |
+| | _Enabled_ | Check to enable automatic recentering. |
+| | _Wait Time_ | If no user input has been detected on the axis, the camera waits this long in seconds before recentering. |
+| | _Recentering Time_ | Maximum angular speed of recentering. Accelerates into and decelerates out of this. |
+| __X Axis__ || Heading Control. The settings here control the behaviour of the camera in response to the player’s input. |
+| | _Value_ | The current value of the axis, in degrees. |
+| | _Min Value_ | The minimum value for the axis. |
+| | _Max Value_ | The maximum value for the axis. |
+| | _Wrap_ | If checked, then the axis wraps around at the Min and Max values, forming a loop. |
+| | _Max Speed_ | The maximum speed of this axis in units/second. |
+| | _Accel Time_ | The amount of time in seconds to accelerate to MaxSpeed with the supplied axis at its maximum value. |
+| | _Decel Time_ | The amount of time in seconds o decelerate the axis to zero if the supplied axis is in a neutral position. |
+| | _Input Axis Name_ | The name of this axis as specified in the Unity Input manager. Set to an empty string to disable the automatic updating of this axis. |
+| | _Input Axis Value_ | The value of the input axis. A value of 0 means no input. Drive this directly from a custom input system, or set the Input Axis Name to drive the value by the Unity Input Manager. |
+| | _Invert_ | Check to invert the raw value of the input axis before it is used. |
+
+
--- /dev/null
+# Tracked Dolly
+
+This Virtual Camera __Body__ algorithm restricts the Virtual Camera to move along a predefined [path](CinemachineDolly.html). Use the __Path Position__ property to specify where to put the Virtual Camera on the path.
+
+Use __Auto-Dolly__ mode to move the Virtual Camera to a position on the path that is closest to the __Follow__ target. When enabled, __Auto-Dolly__ automatically animates the position of the Virtual Camera to the position on the path that’s closest to the target.
+
+**Tip**: Choose your path shapes with care when using Auto-Dolly mode. This becomes problematic on paths that form an arc around some point. As an extreme example, consider a perfectly circular path with the __Follow__ target at the center. The closest point on the path becomes unstable because all points on the circular path are equally close to the target. In this situation, moving the __Follow__ target small distances can cause the camera to move large distances on the track.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Path__ || The path that the camera moves along. This property must refer to a [Cinemachine Path](CinemachinePath.html) or [Cinemachine Smooth Path](CinemachineSmoothPath.html). |
+| __Path Position__ || The position along the path to place the camera. Animate this property directly or enable Auto-Dolly. The value is in the units specified by Position Units. |
+| __Position Units__ || The unit of measure for Path Position. |
+| | _Path Units_ | Use waypoints along the path. The value 0 represents the first waypoint on the path, 1 is the second waypoint, and so on. |
+| | _Distance_ | Use distance along the path. The path is sampled according to the Resolution property of the path. Cinemachine creates a distance lookup table, which it stores in an internal cache. |
+| | _Normalized_ | Use the beginning and end of the path. The value 0 represents the beginning of the path, 1 is the end of the path. |
+| __Path Offset__ || The position of the camera relative to the path. X is perpendicular to the path, Y is up, and Z is parallel to the path. Use this property to offset the camera from the path itself. |
+| __X Damping__ || How responsively the camera tries to maintain its position in a direction perpendicular to the path. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. Using different settings per axis can yield a wide range of camera behaviors. |
+| __Y Damping__ || How responsively the camera tries to maintain its position in the path-local up direction. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Z Damping__ || How responsively the camera tries to maintain its position in a direction parallel to the path. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Camera Up__ || How to set the up vector for the Virtual Camera. This affects the screen composition because the camera Aim algorithms try to respect the up direction. |
+| | _Default_ | Do not modify the up direction of the Virtual Camera. Instead, use the World Up Override property in Cinemachine Brain. |
+| | _Path_ | Use the path’s up vector at the current point. |
+| | _Path No Roll_ | Use the path’s up vector at the current point, but with the roll set to zero. |
+| | _Follow Target_ | Use the up vector from the Follow target’s transform. |
+| | _Follow Target No Roll_ | Use the up vector from the Follow target’s transform, but with the roll zeroed out. |
+| __Pitch Damping__ || How responsively the camera tracks the target rotation’s x angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Yaw Damping__ || How responsively the camera tracks the target rotation’s y angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Roll Damping__ || How responsively the camera tracks the target rotation’s z angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Auto Dolly__ || Controls how automatic dollying occurs. A Follow target is necessary to use this feature. |
+| | _Enabled_ | Check to enable the automatic dolly. Note: this can have some performance impact, depending on the search resolution. |
+| | _Position Offset_ | Offset, in position units, from the closest point on the path to the follow target. |
+| | _Search Radius_ | The number of segments on either side of the current segment. Use 0 for the entire path. Use a lower number when the path’s shape relative to the target position causes the closest point on the path to become unstable. |
+| | _Search Resolution_ | Cinemachine searches a segment by dividing it into many straight pieces. The higher the number, the more accurate the result. However, performance is proportionally slower for higher numbers. |
+
+
--- /dev/null
+# Transposer
+
+This Virtual Camera __Body__ algorithm moves the Virtual Camera in a fixed offset to the __Follow__ target. It also applies damping.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Binding Mode__ || The coordinate space to use when interpreting the offset from the target, and the damping. For example, for a "Door Cam or “Hood Cam" in a car racing game, use Local Space Locked To Target. |
+| | _Lock To Target On Assign_| Make the Virtual Camera use the Follow target’s local frame at the moment that the Virtual Camera is activated or when the target is assigned. This offset remains constant in world space. Also, the camera does not rotate along with the target. |
+| | _Lock To Target With World Up_ | Make the Virtual Camera use the Follow target’s local frame with tilt and roll set to 0. This binding mode ignores all target rotations except yaw. |
+| | _Lock To Target No Roll_ | Make the Virtual Camera use the Follow target’s local frame, with roll set to 0. |
+| | _Lock To Target_ | Make the Virtual Camera use the Follow target’s local frame. As the target rotates, the camera rotates around it to maintain the offset. |
+| | _World Space_ | The offset in interpreted in world space relative to the Follow target's origin. The camera will not change position when the target rotates. |
+| | _Simple Follow With World Up_ | Interpret the offset and damping values in camera-local space. This mode emulates what a human camera operator would do when instructed to follow a target. |
+| __Follow Offset__ || The distance to maintain the Virtual Camera relative to the Follow target. Set X, Y, and Z to 0 to place the camera at the centre of the target. The default is 0, 0, -10, respectively, which places the camera behind the target. |
+| __X Damping__ || How responsively the camera tries to maintain the offset in the x-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Y Damping__ || How responsively the camera tries to maintain the offset in the y-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Z Damping__ || How responsively the camera tries to maintain the offset in the z-axis. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Pitch Damping__ || How responsively the camera tracks the target rotation’s x angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Yaw Damping__ || How responsively the camera tracks the target rotation’s y angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Roll Damping__ || How responsively the camera tracks the target rotation’s z angle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+
+
+
--- /dev/null
+# Setting Cinemachine Brain properties
+
+The Cinemachine Brain is a component in the Unity camera itself. Cinemachine Brain monitors all active Virtual Cameras in the Scene. It chooses the next Virtual Camera to control the Unity camera. It also controls the [cut or blend](CinemachineBlending.html) from the current Virtual Camera to the next.
+
+To add a Cinemachine Brain component to a Unity camera, do __one__ of the following:
+
+* [Add a Virtual Camera](CinemachineSetUpVCam.html), or other Cinemachine object, to your Scene. Unity adds a Cinemachine Brain component to the Unity camera for you if there isn’t one already.
+
+* [Add](https://docs.unity3d.com/Manual/UsingComponents.html) a Cinemachine Brain component to the Unity camera yourself.
+
+**Tip**: You can also control Virtual Cameras from [Timeline](CinemachineTimeline.html). Timeline overrides the decisions that Cinemachine Brain makes.
+
+Cinemachine Brain holds the following key properties:
+
+* __Blend Settings__: A list that defines how to blend from one Virtual Camera to another. For example, add an item to the list for a 4 second blend from vcam1 to vcam2 then add another item for a 1 second blend from vcam2 back to vcam1. If a blend between two cameras isn’t defined, Cinemachine Brain uses its default blend.
+
+* __Layer Filter__: Cinemachine Brain uses only those Virtual Cameras that pass the culling mask of the Unity camera. You can set up [split-screen environments](CinemachineMultipleCameras.html) by using the culling mask to filter layers.
+
+* __Event Dispatching__: Cinemachine Brain fires events when it changes shot. It fires an event when a Virtual Camera goes live. It also fires an event when it cuts from one Virtual Camera to another. Use the latter event to reset temporal post effects.
+
+
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Show Debug Text__ || Check to display a textual summary of the live Virtual Camera and blend in the view. |
+| __Show Camera Frustum__ || Check to display the frustum of the camera in the Scene view. |
+| __Ignore Time Scale__ || Check to make the Virtual Cameras respond in real time to user input and damping, even if the game is running in slow motion. |
+| __World Up Override__ || The Y axis of the specified GameObject defines the worldspace up vector for Virtual Cameras. Use this property in top-down game environments. Set to None to use the worldspace Y axis. Setting this appropriately is important to avoid gimbal-lock in extreme up/down conditions. |
+| __Update Method__ || When to update the position and rotation of the Virtual Cameras. |
+| | _Fixed Update_ | Synchronize Virtual Camera update with the Physics module, in FixedUpdate. |
+| | _Late Update_ | In MonoBehaviour LateUpdate. |
+| | _Smart Update_ | Update each virtual camera according to how its target is updated. This is the recommended setting. |
+| __Default Blend__ || The blend to use when you haven’t explicitly defined a blend between two Virtual Cameras. |
+| | _Cut_ | Zero-length blend. |
+| | _Ease In Out_ | S-shaped curve, giving a gentle and smooth transition. |
+| | _Ease In_ | Linear out of the outgoing shot, and easy into the incoming. |
+| | _Ease Out_ | Easy out of the outgoing shot, and linear into the incoming. |
+| | _Hard In_ | Easy out of the outgoing, and hard into the incoming. |
+| | _Hard Out_ | Hard out of the outgoing, and easy into the incoming. |
+| | _Linear_ | Linear blend. Mechanical-looking. |
+| | _Custom_ | Custom blend curve. Draw the curve you want. |
+| __Custom Blends__ || The asset that contains custom settings for blends between specific Virtual Cameras in your Scene. |
+| __Create Asset__ || Create an asset containing a [list of custom blends](CinemachineBlending.html) between Virtual Cameras. |
+| __Camera Cut Event__ || This event fires when a Virtual Camera goes live and there is no blend. |
+| __Camera Activated Event__ || This event fires when a Virtual Camera goes live. If a blend is involved, then the event fires on the first frame of the blend. |
+
--- /dev/null
+# Cinemachine Clear Shot Camera
+
+The __Cinemachine ClearShot Camera__ component chooses among its children Virtual Cameras for the best quality shot of the target. Use Clear Shot to set up complex multi-camera coverage of a Scene to guarantee a clear view of the target.
+
+This can be a very powerful tool. Virtual Camera children with [Cinemachine Collider](CinemachineCollider.html) extensions analyze the Scene for target obstructions, optimal target distance, and so on. Clear Shot uses this information to choose the best child to activate.
+
+**Tip:** To use a single [Cinemachine Collider](CinemachineCollider.html) for all Virtual Camera children, add a Cinemachine Collider extension to the ClearShot GameObject instead of each of its Virtual Camera children. This Cinemachine Collider extension applies to all of the children, as if each of them had that Collider as its own extension.
+
+If multiple child cameras have the same shot quality, the Clear Shot camera chooses the one with the highest priority.
+
+You can also define custom blends between the ClearShot children.
+
+## Properties:
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Look At__ | The default target GameObject that the children Virtual Camera move with. The Clear Shot camera uses this target when the child does not specify this target. May be empty if all of the children define targets of their own. |
+| __Follow__ | The target GameObject to aim the Unity camera at. The Clear Shot camera uses this target when the child does not specify this target. May be empty if all of the children define targets of their own. |
+| __Show Debug Text__ | Check to display a textual summary of the live Virtual Camera and blend in the Game view. |
+| __Activate After__ | Wait this many seconds before activating a new child camera. |
+| __Min Duration__ | An active camera must be active for at least this many seconds, unless a higher-priority camera becomes active. |
+| __Randomize Choice__ | Check to choose a random camera if multiple cameras have equal shot quality. Uncheck to use the order of the child Virtual Cameras and their priorities. |
+| __Default Blend__ | The blend to use when you haven’t explicitly defined a blend between two Virtual Cameras. |
+| __Priority__ | Determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority. |
+
+
--- /dev/null
+# Cinemachine Collider
+
+__Cinemachine Collider__ is an [extension](CinemachineVirtualCameraExtensions.html) for the Cinemachine Virtual Camera. It post-processes the final position of the Virtual Camera to attempt to preserve the line of sight with the __Look At__ target of the Virtual Camera. It does this by moving away from the GameObjects that obstruct the view.
+
+Add a Cinemachine Collider extension to a Cinemachine Virtual Camera to do any of the following tasks:
+
+* Push the camera away from obstructing obstacles in the Scene.
+
+* Place the camera in front of obstacles that come between the Virtual Camera and its __Look At__ target.
+
+* Evaluate shot quality. __Shot quality__ is a measure of the distance of the Virtual Camera from its ideal position, the distance of the Virtual Camera to its target, and the obstacles that block the view of the target. Other modules use shot quality, including [Clear Shot](CinemachineClearShot.html).
+
+The Collider uses a [Physics Raycaster](https://docs.unity3d.com/Manual/script-PhysicsRaycaster.html). Therefore, Cinemachine Collider requires that potential obstacles have [collider](https://docs.unity3d.com/Manual/CollidersOverview.html) volumes. There is a performance cost for this requirement. If this cost is prohibitive in your game, consider implementing this functionality in a different way.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Collide Against__ || Cinemachine Collider considers GameObjects in these layers to be potential obstacles. It ignores GameObjects that are not in the selected layers. |
+| __Minimum Distance From Target__ || Ignore obstacles that are less than this distance from the target's pivot point. |
+| __Avoid Obstacles__ || Check to allow the Collider to move the camera in the Scene when the target is obscured by an obstacle. Use the Distance Limit, Camera Radius, and Strategy properties to adjust how to avoid obstacles. If left unchecked, the Cinemachine Collider will report shot quality based on obstacles, but will not attempt to move the camera to improve the shot. |
+| __Distance Limit__ || The maximum raycast distance when checking if the line of sight to this camera’s target is clear. Enter 0 to use the current actual distance to the target. Available when Avoid Obstacles is checked. |
+| __Camera Radius__ || Distance to maintain from any obstacle. Try to keep this value small for best results. Increase it if you are seeing inside obstacles due to a large FOV on the camera. Available when Avoid Obstacles is checked. |
+| __Strategy__ || The way in which the Collider attempts to preserve sight of the target. Available when Avoid Obstacles is checked. |
+| | _Pull Camera Forward_ | Move the camera forward along its Z axis until it is in front of the obstacle that is nearest to the target. |
+| | _Preserve Camera Height_ | Move the camera to an alternate point of view while attempting to keep the camera at its original height. |
+| | _Preserve Camera Distance_ | Move the camera to an alternate point of view while attempting to keep the camera at its original distance from the target. |
+| | _Smoothing Time_ | Minimum number of seconds to hold the camera at the nearest point to the target. Can be used to reduce excess camera movement in environments with lots of obstacles. Available when Avoid Obstacles is checked. |
+| __Damping__ || How quickly to return the camera to its normal position after an occlusion has gone away. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. Available when Avoid Obstacles is checked. |
+| __Damping When Occluded__ || How quickly to move the camera to avoid an obstacle. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. Available when Avoid Obstacles is checked. |
+| __Optimal Target Distance__ || If greater than zero, give a higher score to shots when the target is closer to this distance. Set this property to 0 to disable this feature. |
+
+
+
--- /dev/null
+# Avoiding collisions and evaluating shots
+
+As characters and objects move around in a complex Scene, obstacles in the Scene sometimes come between a camera and its target. Similarly, you might need to move a camera to a position in the Scene that another GameObject already occupies. Cinemachine provides extensions to handle these situations:
+
+* [Cinemachine Collider](CinemachineCollider.html)
+* [Cinemachine Confiner](CinemachineConfiner.html)
+
--- /dev/null
+#Cinemachine Collision Impulse Source
+
+For collision-based impulses, attach a **CinemachineCollisionImpulseSource** component to a GameObject that has a Collider or Collider2D component. **CinemachineCollisionImpulseSource** generates an impulse when something collides with the GameObject or enters a trigger zone.
+
+To add a Collision Impulse Source component:
+
+1. Select the GameObject that you want to trigger impulses, navigate to its Inspector, and click the **Add Component** button.
+
+2. Go to **Scripts > Cinemachine** and select **Cinemachine Collision Impulse Source**.
+
+By default, an Impulse Source affects every [Impulse Listener](CinemachineImpulseListener.md) in range, but you can apply [channel filtering](CinemachineImpulseFiltering.md#ChannelFiltering) to make Impulse Sources affect some Impulse Listeners and not others.
+
+## Properties:
+
+The properties in the Cinemachine Collision Impulse Source Inspector window are divided into the following sections.
+
+- [Impulse Channel](#ImpulseChannel) (A)
+- [Signal Shape](#SignalShape) (B)
+- [Time Envelope](#TimeEnvelope) (C)
+- [Spatial Range](#SpatialRange) (D)
+- [Trigger Object Filter](#TriggerObject) (E)
+- [How to Generate The Impulse](#GenerateImpulse) (F)
+
+
+
+
+
+<a name="ImpulseChannel"></a>
+### Impulse Channel
+
+Impulse Listeners filter impulses based on channels to control which Impulse Sources they react to. Channels work like Camera Layers, but are distinct from them. These properties control the channels that the Collision Impulse Source broadcasts impulse signals on. For details, see documentation on [Filtering](CinemachineImpulseFiltering.md).
+
+
+
+| **Property:** | **Function:** |
+| ------------------- | ------------------------------------------------------------ |
+| **Impulse Channel** | Choose one or more channels from the drop-down.<br /><br />Click **Edit** to modify existing channels or add new ones. |
+
+
+<a name="SignalShape"></a>
+### Signal Shape
+
+These properties control the basic characteristics of the raw signal when it is emitted by the Collision Impulse Source.
+
+
+
+| **Property:** | **Function:** |
+| -------------- | ------------------------------------------------------------ |
+| **Raw Signal** | The raw signal form. <br /><br />Drag a signal Asset onto the signal name to connect the signal to the Collision Impulse Source.<br /><br />Click the “gear” icon for additional signal options, including options for creating new signals.<br /><br />See [Raw Vibration Signals](CinemachineImpulseRawSignal.md) for details.|
+|**Amplitude Gain** | Set a value by which to multiply the amplitude of **Raw Signal**. This controls the strength of the vibrations. This is set to 1 by default.<br /><br />Use values greater than 1 to amplify the signal, 1 for the original signal, values less than 1 and greater than 0 to attenuate the signal, and 0 to mute the signal. |
+|**Frequency Gain**|Set a value by which to multiply the frequency of **Raw Signal**. This controls the speed of the vibrations. This is set to 1 by default.<br /><br />Use values greater than one to increase the frequency, 1 for the original signal, values less than 1 and greater than 0 to reduce the frequency of the signal. A frequency of 0 holds a single noise value indefinitely, as though time were frozen.|
+|**Randomize**|Enable this to randomize the **Raw Signal’s** start time.<br /><br />This property is available when the **Raw Signal** is a noise profile Asset. See [Raw Vibration Signals](CinemachineImpulseRawSignal.md) for details.|
+|**Repeat Mode**|Specify whether to loop the **Raw Signal** over the duration of the time envelope, or stretch it to fit the time envelope.<br /><br />This property is available when the **Raw Signal** is a fixed signal. See [Raw Vibration Signals](CinemachineImpulseRawSignal.md) for details.|
+
+
+<a name="TimeEnvelope"></a>
+### Time Envelope
+
+These properties control the duration of the impulse and the intensity of the **Raw Signal** over that duration.
+
+
+
+| Property: | Function: |
+| --------------------- | ------------------------------------------------------------ |
+| **Attack** | Define how the signal reaches full amplitude at the beginning of the waveform. Click the preview pane (grey bar) to set the shape of the curve, and use the numerical field to set the time (in seconds) to reach the full amplitude. Leave the preview pane blank to use a default curve that is suitable for most purposes. |
+| **Sustain Time** | Set the time to maintain the full amplitude of the waveform after the attack. |
+| **Decay** | Define how the signal goes from full amplitude to zero the end of the waveform. Click the preview pane (grey bar) to set the shape of the curve, and use the numerical field to set the time (in seconds) to mute the signal. Leave the preview pane blank to use a default curve that is suitable for most purposes. |
+| **Scale With Impact** | Enable this to apply signal amplitude scaling to **Time Envelope**. If checked, the Cinemachine Collision Impulse Source component scales the time envelope according to the strength of the impact: stronger impacts last longer, and milder impacts have a shorter duration. |
+
+
+<a name="SpatialRange"></a>
+### Spatial Range
+
+These properties define a zone in the Scene. The impulses from this Impulse Source only affect Impulse Listeners in this zone.
+
+
+
+| Property:|| Function:|
+|--|--|--|
+|**Impact Radius**||Set the radius of the space in the Scene around the impact point where the signal stays at full amplitude. Beyond that the signal strength fades out over the dissipation distance. After that, the strength is zero. In other words, the total effect radius of the signal is **Impact Radius** + **Dissipation Distance**.|
+|**Direction Mode**||Define how the Cinemachine Collision Impulse Source component should apply the direction of the signal as the Impulse Listener moves away from the Impulse Source.|
+||Fixed|Use **Fixed** to use a constant signal direction.|
+||Rotate Toward Source|Use **Rotate Toward Source** to rotate the signal in the direction of the Impulse Source, giving a subtle visual clue about the source’s location. **Rotate Toward Source** has no effect on radially-symmetric signals.|
+|**Dissipation Mode**||Define how the signal dissipates when the listener is outside the **Impact Radius**.|
+||Linear Decay|The signal dissipates evenly over the **Dissipation Distance**.|
+||Soft Decay|The signal dissipates slowly at the beginning of the **Dissipation Distance**, more quickly in the middle, and slowly again as it reaches the end.|
+|| Exponential Decay|The signal dissipates very quickly at the beginning of the **Dissipation Distance**, then more and more slowly as it reaches the end.|
+|**Dissipation Distance**||Set the distance beyond the impact radius over which the signal decays from full strength to nothing.|
+
+
+<a name="TriggerObject"></a>
+### Trigger Object Filter
+
+These properties filter the GameObjects that trigger an impulse when they collide or enter the trigger zone. GameObjects in layers specified by the **Layer Mask** trigger impulses unless you tag them with the **Ignore Tag** value. For details, see documentation on [Filtering](CinemachineImpulseFiltering.md).
+
+
+
+| Property: | Function: |
+| -------------- | ------------------------------------------------------------ |
+| **Layer Mask** | Rigidbody components in these layers that collide with an Impulse Source or enter the trigger zone cause the Source to broadcast its signal. |
+| **Ignore Tag** | GameObjects with this tag do not generate an impulse, even if they are in a layer specified in **Layer Mask**. |
+
+
+<a name="GenerateImpulse"></a>
+### How To Generate The Impulse
+
+An impulse is triggered at a location by an impact mass moving at an impact velocity. Unity dynamically calculates the mass and velocity of the Rigidbody or Rigidbody 2D component that triggers the impulse. The **How To Generate The Impulse** properties control how the mass and velocity of the Rigidbody affect the strength and direction of the signal.
+
+
+
+| Property: | Function: |
+| --------------------------- | ------------------------------------------------------------ |
+| **Use Impact Direction** | Enable this setting to rotate the impulse signal to correspond to the direction of the impact velocity. For example, if the raw signal vibrates vertically but the impact direction is horizontal, you could check this property to make the resulting impulse signal vibrate horizontally. <br /><br />Disable to use the direction of the raw signal irrespective of the impact direction. |
+| **Scale Impact With Mass** | Enable this setting to increase or decrease the amplitude of the impulse signal based on the mass of the colliding GameObjects. The masses are specified in the Rigidbody or RigidBody2D component of the GameObject that contains the Cinemachine Impulse Source, and of the colliding GameObject. <br /><br />Disable this setting to use a constant mass of 1. |
+| **Scale Impact With Speed** | Enable this setting to scale the amplitude of the signal based on the speed of the impact. Faster moving GameObjects have a greater momentum, and therefore produce a stronger signal. <br /><br />Disable this setting to ignore the speed of the colliding GameObject. |
--- /dev/null
+# Cinemachine Confiner
+
+Use the __Cinemachine Confiner__ [extension](CinemachineVirtualCameraExtensions.html) to limit the camera’s position to a volume or area.
+
+Confier operates in 2D or 3D mode. The mode influences the kind of bounding shape it accepts. In 3D mode, the camera’s position in 3D is confined to a volume. This also works for 2D games, but you need to take the depth into account. In 2D mode, you don’t have to worry about depth.
+
+For orthographic cameras, there is an additional option to confine the screen edges, not just the camera point. This ensures that the entire screen area stays within the bounding area.
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Confine Mode__ || Operate using a 2D bounding area or a 3D bounding volume. |
+| | _Confine 2D_ | Use a Collider2D bounding area. |
+| | _Confine 3D_ | Use a 3D Collider bounding volume. |
+| __Bounding Volume__ || The 3D volume to contain the camera in. This property is available when Confine Mode is set to Confine 3D. |
+| __Bounding Shape 2D__ || The 2D area to contain the camera in. This property is available when Confine Mode is set to Confine 2D. |
+| __Confine Screen Edges__ || Check to confine screen edges to the area when the camera is orthographic. When unchecked, confine only the camera center. Has no effect if camera is in perspective mode. |
+| __Damping__ || How gradually to return the camera to the bounding volume or area if it goes beyond the borders. Higher numbers are more gradual. |
+
+
--- /dev/null
+# Document Revision History
+
+| **Date:** | **Reason:** |
+|:---|:---|
+| July 3, 2018 | Updated for 2.2.6. |
+| February 15, 2018 | Updated for 2.1.11. |
+| November 21, 2017 | Initial version. |
+
--- /dev/null
+# Using dolly paths
+
+A dolly path is an array of waypoints in a Scene. Use a dolly path to specify a fixed course to position or animate a Virtual Camera. Use the [Tracked Dolly](CinemachineBodyTrackedDolly.html) algorithm to use a dolly path with your Virtual Camera.
+
+
+
+
+
+Cinemachine provides two types of dolly paths:
+
+* [Smooth Path](CinemachineSmoothPath.html): Each waypoint has a position and roll. Cinemachine uses Bezier interpolation between the waypoints. Smooth Path gives you less control over the position of the path but animation along the path is always smooth and continuous. This is the recommended path type.
+
+* [Path](CinemachinePath.html): Each waypoint has a position, tangent, and roll. Use Path for finer control of the track’s position between waypoints. Animating a VIrtual Camera along a Path might cause jerky motion over waypoints when tangents don’t allow a smooth transition to and from the waypoint.
+
+To create a Virtual Camera with a dolly path:
+
+1. In the Unity menu, choose __Cinemachine > Create Dolly Camera with Track__.\rA new Virtual Camera and dolly track appears in the [Hierarchy]([https://docs.unity3d.com/Manual/Hierarchy.html](https://docs.unity3d.com/Manual/Hierarchy.html)). By default, the dolly track GameObject is a Smooth Path.
+
+2. In the [Hierarchy]([https://docs.unity3d.com/Manual/Hierarchy.html](https://docs.unity3d.com/Manual/Hierarchy.html)) window, select the new dolly track GameObject.
+
+3. In the [Inspector]([https://docs.unity3d.com/Manual/UsingTheInspector.html](https://docs.unity3d.com/Manual/UsingTheInspector.html)), add and adjust waypoints.
+
+To create a path GameObject:
+
+1. In the Unity menu, choose __GameObject > Create Empty.__
+
+2. [Add the path component](https://docs.unity3d.com/Manual/UsingComponents.html), either __CinemachinePath__ or __CinemachineSmoothPath__
+
+To edit a waypoint in a path:
+
+1. In the [Hierarchy]([https://docs.unity3d.com/Manual/Hierarchy.html](https://docs.unity3d.com/Manual/Hierarchy.html)) window, select the path GameObject.
+
+2. Select a waypoint by either clicking its index number in the [Scene](https://docs.unity3d.com/Manual/UsingTheSceneView.html) view or clicking its number in the __Path Details__ section in the [ Inspector](https://docs.unity3d.com/Manual/UsingTheInspector.html).
+
+3. Edit the waypoint by [manipulating its Gizmo](https://docs.unity3d.com/Manual/PositioningGameObjects.html) in the Scene view or edit its properties in the Inspector.<br/>__Note__: When editing a waypoint for a regular path in the Scene view, the waypoint has two Gizmos: for the position and for the tangent.
+
--- /dev/null
+# Cinemachine Dolly Cart
+
+__Cinemachine Dolly Cart__ is a component that constrains the transform of its GameObject to a __Cinemachine Path__ or __Cinemachine Smooth Path__. Use it to animate a GameObject along a path, or as a __Follow__ target for Virtual Cameras.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---
+| __Path__ || The path to follow. |
+| __Update Method__ || When to move the cart when velocity is non-zero. Use __Update__ for normal `MonoBehaviour` updating, __Fixed Update__ for updates in sync with the Physics module, `FixedUpdate()`. |
+| __Position Units__ || The unit of measure for __Position__. |
+| | _Path Units_ | Use waypoints along the path. The value 0 represents the first waypoint on the path, 1 is the second waypoint, and so on. |
+| | _Distance_ | Use distance along the path. The path is sampled according to the Resolution property of the path. Cinemachine creates a distance lookup table, which it stores in an internal cache. |
+| | _Normalized_ | Use the beginning and end of the path. The value 0 represents the beginning of the path, 1 is the end of the path. |
+| __Speed__ || Move the cart with this speed. The value is interpreted according to __Position Units__. |
+| __Position__ || The position along the path to place the cart. This can be animated directly or, if the speed is non-zero, will be updated automatically. The value is interpreted according to __Position Units__. |
--- /dev/null
+# Cinemachine External Camera
+
+This component will expose a non-cinemachine camera to the cinemachine system, allowing it to participate in blends. Just add it as a component alongside an existing Unity Camera component. You will need to take steps (e.g. disabling the Camera component) to ensure that the Camera does not fight with the main Cinemachine Camera. This component is deprecated in favour of using a normal CinemachineVirtualCamera with Do Nothing in both Aim and Body.
+
+## Properties:
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Look At__ | The object that the camera is looking at, if defined. This can be empty, but setting this will improve the quality of the blends to and from this camera. |
+| __Blend Hint__ | Hint for blending positions to and from this camera. |
--- /dev/null
+# Cinemachine Follow Zoom
+
+This [extension](CinemachineVirtualCameraExtensions.html) adjusts the FOV of the lens to keep the target object at a constant size on the screen, regardless of camera and target position.
+
+## Properties:
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Width__ | The shot width to maintain, in world units, at target distance. The FOV will be adjusted so that an object of this size, at target distance, will fill the screen. |
+| __Damping__ | Increase this value to soften the responsiveness of the follow-zoom. Small numbers make the camera more responsive. Larger numbers make the camera respond more slowly. |
+| __Min FOV__ | Lower limit for the FOV that this behavior generates. |
+| __Max FOV__ | Upper limit for the FOV that this behavior generates. |
+
--- /dev/null
+# Cinemachine Free Look Camera
+
+The __Cinemachine Free Look Camera__ component provides a third-person camera experience. This Cinemachine Virtual Camera orbits around its subject along a position specified by three separate camera rigs: __Top__, __Middle__, and __Bottom__.
+
+
+
+Each rig defines a ring around the target, with its own radius, height offset, composer, lens properties, and Noise settings. These are the same as the [properties for a regular Virtual Camera](CinemachineVirtualCamera.html).
+
+Cinemachine Free Look Camera also defines a spline that connects the rigs. The spline defines the camera’s position when blending between the rigs.
+
+
+
+Free Look uses player input along the x and y axes. The x axis controls the orbital position along the __Top__, __Middle__, or __Bottom__ horizontal orbits, like the [Orbital Transposer](CinemachineBodyOrbitalTransposer.html). The y-axis controls the vertical position, using the spline to determine the position between rigs.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Solo__ || Toggles whether or not the Virtual Camera is temporarily live. Use this property to get immediate visual feedback in the [Game view](https://docs.unity3d.com/Manual/GameView.html) to adjust the Virtual Camera. |
+| __Game Window Guides__ || Toggles the visibility of compositional guides in the Game view. These guides are available when Look At specifies a GameObject and the Aim section uses Composer or Group Composer, or when Follow specifies a target and the Body section uses Framing Composer. This property applies to all Virtual Cameras. |
+| __Save During Play__ || Check to [apply the changes while in Play mode](CinemachineSavingDuringPlay.html). Use this feature to fine-tune a Virtual Camera without having to remember which properties to copy and paste. This property applies to all Virtual Cameras. |
+| __Priority__ || The importance of this Virtual Camera for choosing the next shot. A higher value indicates a higher priority. Cinemachine Brain chooses the next live Virtual Camera from all Virtual Cameras that are activated and have the same or higher priority as the current live Virtual Camera. This property has no effect when using a Virtual Camera with Timeline. |
+| __Follow__ || The target GameObject to move with. The [Body properties](CinemachineVirtualCameraBody.html) use this target to update the position of the Unity camera. |
+| __Look At__ || The target GameObject to aim at. The [Aim properties](CinemachineVirtualCameraAim.html) use this target to update the rotation of the Unity camera. This property is normally the same as the Follow target. |
+| __Common Lens__ || Check to apply a common lens setting to all three child rigs. Uncheck to use separate lens settings for each child rig. |
+| __Lens__ || If Common Lens is checked, these lens settings apply to all three rigs. These properties mirror their counterparts in the property settings for the [Unity camera](https://docs.unity3d.com/Manual/class-Camera.html). |
+| | _Field Of View_ | This is the camera view in vertical degrees. For example, to specify the equivalent of a 50mm lens on a Super 35 sensor, enter a Field of View of 19.6 degrees. This property is available when the Unity camera with the Cinemachine Brain component uses a Projection of Perspective. |
+| | _Orthographic Size_ | When using an orthographic camera, this defines the half-height, in world coordinates, of the camera view. This property is available when the Unity camera with the Cinemachine Brain component uses a Projection of Orthographic. |
+| | _Near Clip Plane_ | The closest point relative to the camera where drawing occurs. |
+| | _Far Clip Plane_ | The furthest point relative to the camera where drawing occurs. |
+| | _Dutch_ | Dutch angle. Tilts the Unity camera on the Z axis, in degrees. This property is unique to the Virtual Camera; there is no counterpart property in the Unity camera. |
+| __Transitions__ || |
+| | _Blend Hint_ | How to blend to and from the Free Look camera. Use None for default linear interpolation of position and aim. Use Spherical Position to blend spherically about the Look At position, linearly blending between Look At targets. Use Cylindrical Position to blend in a cylindrical path around the Look At target and interpolate linearly on the vertical axis. Use Screen Space Aim When Targets Differ for a standard linear position blend, with screen-space angular blend between differing Look At targets. |
+| | _Inherit Position_ | When this virtual camera goes Live, attempt to force the position to be the same as the current position of the Unity Camera, allowing the virtual camera to apply its damping to accomplish the blend |
+| | _Camera Activated_ | This event is invoked when the Virtual Camera becomes live. Attach custom handlers here if you need them. |
+| __Y Axis, X Axis__ || The vertical and horizontal axes for blending between rigs. For Y Axis the Value range is 0 to 1 and represents the blend position between the Top, Middle, and Bottom rigs. The value 0.5 represents the middle rig. For X Axis, the Value is the angular deviation (in degrees) of the camera from directly behind the target. |
+| | _Max Speed_ | The maximum speed of this axis in units/second. |
+| | _Accel Time_ | The amount of time in seconds to accelerate to Max Speed. |
+| | _Decel Time_ | The amount of time in seconds to decelerate to zero. |
+| | _Input Axis Name_ | The name of this axis as specified in Unity Input manager. Setting to an empty string disables the automatic updating of the axis. |
+| | _Input Axis Value_ | The value of the input axis. A value of 0 means no input. To drive this directly, use a custom input system. Or you set the Axis Name to control the value with the Unity Input Manager. |
+| | _Invert_ | Check to invert the raw value of the input axis. |
+| __Y Axis Recentering__ || Controls the automatic recentering on the y axis. |
+| | _Enabled_ | Check to enable automatic recentering. |
+| | _Wait Time_ | When no user input has been detected on the axis, the camera waits this long in seconds before recentering. |
+| | _Recentering Time_ | Maximum angular speed of recentering. Accelerates into and decelerates out of the centered position. |
+| __Orbits__ || Properties for defining the Top, Middle, and Bottom rigs. |
+| __Binding Mode__ || The coordinate space to use to interpret the offset from the target. Also sets the up vector. Cinemachine keeps the camera oriented in the up direction while aiming. These modes do incredibly different things, so try them out and one should work well for whatever your requirements are. |
+| | _Lock To Target On Assign_ | The target’s local frame at the moment when the Virtual Camera was activated, or when the target was assigned. |
+| | _Lock To Target With World Up_ | The target’s local frame, with the tilt and roll reset to zero. |
+| | _Lock To Target No Roll_ | The target’s local frame, with the roll reset to zero. |
+| | _Lock To Target_ | The target’s local frame. |
+| | _World Space_ | World space offset. |
+| | _Simple Follow With World Up_ | Relative to the target, using camera-local axes. |
+| __Spline Curvature__ || The tautness of the line that connects the rigs’ orbits. This line determines the final placement on the y axis. |
+| __Height, Radius__ || The radius and height of the Top, Middle, and Bottom rigs relative to the Follow target. |
+
--- /dev/null
+# Getting started
+
+Follow the steps in this section to install Cinemachine in your project. Get started quickly with a few Virtual Cameras, then gradually add more sophisticated features as needed.
+
+## Installing Cinemachine
+
+Cinemachine is a free package, available for any project. You install Cinemachine like [any other package](https://docs.unity3d.com/Packages/com.unity.package-manager-ui@latest/index.html).
+
+After you install Cinemachine, a new *Cinemachine* folder appears in the Gizmos folder of your Project window, and a new __Cinemachine__ menu is available.
+
+
+
+## Upgrading from the Cinemachine Asset Package
+
+If you already installed Cinemachine from the Unity Asset Store, you can upgrade to the Cinemachine Package.
+
+To upgrade to the Cinemachine Package:
+
+1. In Unity Editor, 2018.1 or later, open your project.
+
+2. Save the current Scene you are working on.
+
+3. Create a new, empty Scene.
+
+4. In the [Project window](https://docs.unity3d.com/Manual/ProjectView.html), delete the Cinemachine Asset and any CinemachinePostProcessing adaptor assets you may have installed.
+
+5. Install the Cinemachine package.
+
+## Learning more about Cinemachine
+
+Use the [Unity Tutorials](https://unity3d.com/learn/tutorials/s/animation) to see demonstrations for setting up and using Cinemachine.
+
+Experiment with the example Assets. In the Unity menu, choose __Cinemachine > Import Example Asset Package__ to import these Assets.
+
+Discuss your Cinemachine challenges and ideas in the [Cinemachine community forum](https://forum.unity.com/forums/cinemachine.136) and in the [Answers page](https://answers.unity.com/search.html?sort=relevance&q=cinemachine).
+
--- /dev/null
+# Impulse
+
+Cinemachine Impulse generates and manages camera shake in response to game events. For example, you can use Impulse to make a Cinemachine Virtual Camera shake when one GameObject collides with another, or when something in your Scene explodes.
+
+Impulse has three parts:
+
+- **[Raw vibration signal](CinemachineImpulseRawSignal.md):** a vibration curve in up to 6 dimensions: X, Y, Z, pitch, roll, yaw.
+
+- **[Impulse Source](CinemachineImpulseSourceOverview.md):** a component that emits the raw vibration signal from a point in Scene space, and defines signal characteristics such as duration, intensity, and range.
+
+- **[Impulse Listener](CinemachineImpulseListener.md):** a Cinemachine extension that allows a Virtual Camera to “hear” an impulse, and react to it by shaking.
+
+It’s useful to think about this in terms of individual “impulses.” An impulse is a single occurrence of an Impulse Source emitting a raw vibration signal. Collisions and events in your Scenes _trigger_ impulses, Impulse Sources _generate_ impulses, and Impulse Listeners _react_ to impulses.
+
+## Getting started with Impulse
+
+To set up and use Impulse in a Scene, do the following:
+
+- Add **[Cinemachine Impulse Source](CinemachineImpulseSource.md)** or **[Cinemachine Collision Impulse Source](CinemachineCollisionImpulseSource.md)** components to one or more GameObjects that you want to trigger camera shake.
+
+- Connect Raw Signals to the Impulse Sources. These can be **[6D Noise Profiles](CinemachineImpulseNoiseProfiles.md)**, **[3D Fixed Signals](CinemachineImpulseFixedSignals.md)**, or custom signal types that you create yourself.
+
+- Add a **[Cinemachine Impulse Listener](CinemachineImpulseListener.md)** extension to one or more Cinemachine virtual cameras so they can detect and react to impulses.
\ No newline at end of file
--- /dev/null
+# Filtering impulses
+
+Filtering lets you fine-tune how and when an Impulse Source generates impulses. Cinemachine Impulse allows two types of filtering:
+
+- Use channel filtering to set things up so that an Impulse Listener reacts to certain Impulse Sources and ignores others. See [Filtering with channels](#ChannelFiltering) below for details.
+
+- Use Trigger Object Filtering with Collision Impulse Sources to set things up so that only certain GameObjects trigger an impulse. See [Filtering with layers and tags](#TriggerObjectFiltering) for details.
+
+<a name="ChannelFiltering"></a>
+## Filtering with channels
+
+By default, every Impulse Listener reacts to every Impulse Source within range. Channels allow you to more precisely control which Impulse Sources an Impulse Listener reacts to. To set up channel filtering, you need to do three things:
+
+- Set up your channels
+- Set your Impulse Sources to broadcast on one or more channels
+- Set your Impulse Listeners to listen to one or more channels
+
+When an Impulse Listener is listening to specific channels, it only reacts to Impulse Sources that broadcast on those channels.
+
+### Adding channels
+
+The **CinemachineImpulseChannels** script creates channels in your Scene. It has one channel by default, and you can add as many new channels as you need, up to a maximum of 31.
+
+To add new channels:
+
+1. Inspect the **CinemachineImpulseChannels** script by doing one of the following:
+
+ - In the Cinemachine Impulse Listener inspector, navigate to the **Channel Mask** drop-down and click the **Edit** button next to it.
+
+ - In the Cinemachine Impulse Source or Cinemachine Collision Impulse Source inspector, navigate to the **Impulse Channel** drop-down and click the **Edit** button next to it.
+
+2. Expand the **Impulse Channels** property group and set the **Size** property to the number of channels you want. A new entry appears for each channel.
+
+3. Rename your new channels.
+
+ 
+
+ Channels are available from the channel drop-down in the Inspector as soon as you add them.
+
+### Setting listen / broadcast channels
+
+After setting up your channels, you need to define how your Impulse Listeners and Impulse Sources use them.
+
+- Inspect each Impulse Listener, and choose the channels you want it to listen to from the **Channel Mask** drop-down.
+
+ 
+
+- Inspect each Impulse Source or Collision Impulse Source, and choose the channels you want it to broadcast on from the **Impulse Channel** drop-down.
+
+ 
+
+ You can select multiple filters from the drop down. You can also choose **Everything** to use all filters, or **Nothing** to use none of them.
+
+<a name="TriggerObjectFiltering"></a>
+## Filtering with layers and tags
+
+You can use Unity’s [Layers](https://docs.unity3d.com/Manual/Layers.html) and [Tags](<https://docs.unity3d.com/Manual/Tags.html>) to specify which GameObjects trigger an impulse when they collide with a Collision Impulse Source, or enter a trigger zone. This is called **Trigger Object Filtering**.
+
+The Cinemachine Collision Impulse Source component has two **Trigger Object Filter** properties:
+
+- The **Layer Mask** drop-down lists all of the Scene’s layers. When you select one or more layers, GameObjects in those layers trigger impulses when they collide with the Impulse Source. The Impulse Source ignores collisions with GameObjects on other layers.
+
+- The **Ignore Tag** drop-down lists all of the Scene’s tags. When you select a tag, GameObjects with that tag do not trigger impulses when they collide with the Impulse Source, even if they are in a layer specified in Layer Mask.
+
+For example, in a Scene where a large animal is lumbering through a forest, you might want the camera to shake when it collides with large trees, but not small saplings.
+
+One way to set that up would be to make the animal a Collision Impulse Source, put all of the large trees on their own layer, and select that as the Layer Mask.
+
+If all of the trees, large ones and saplings alike, are already on the same layer, you could assign a special tag to the saplings, and use the **Ignore Tag** property to filter them out.
\ No newline at end of file
--- /dev/null
+# Using Fixed Signals
+
+The **CinemachineFixedSignal** Asset class is a simple 3D curve definition that lets you draw the curves yourself. Cinemachine Impulse either stretches or loops the curve to fit it in the attack-sustain-decay envelope, according to your specification in the Impulse Source.
+
+## Connecting a fixed signal to an Impulse Source
+
+To connect a fixed signal Asset to an Impulse Source, locate it in the Project view and drag it onto the **Raw Signal** field in the Impulse Source Inspector.
+
+## Creating a new fixed signal
+
+To create a new fixed signal Asset:
+
+1. In the Impulse Source Inspector, click the gear icon next to the **Raw Signal** field and choose **New Fixed Signal**.
+
+2. When prompted, give the new Asset a name and choose a location to save it to.
+
+3. Locate the new Asset in the Project view and select it to open the Fixed Signal Inspector.
+
+ 
+
+ The Inspector displays a preview of the curve for each axis. Click a preview pane to define your own curve for that axis. If you leave it blank, there is no movement along that axis.
+
+4. Click a preview curve to open the Curve editor, where you can edit the curve for that axis.
+
+ 
+
+5. Click one of the thumbnails at the bottom of the window to apply a curve preset. You can then edit the curve:
+
+ - Drag the control points and Bezier handles to change the shape of the curve.
+ - Click the gear icon next to the preset thumbnails to open the **Presets** window, where you can click **New** to add your current curve to the curve presets library.
\ No newline at end of file
--- /dev/null
+#Cinemachine Impulse Listener
+
+Impulse [signals](CinemachineImpulseRawSignal.md) and [sources](CinemachineImpulseSourceOverview.md) don’t do anything on their own. An **Impulse Listener** is a Cinemachine extension that allows a virtual camera to “hear” impulse vibration signals and react to them.
+
+When you add an **Impulse Listener** extension to a virtual camera, it makes the camera shake in response to the signals emitted from Impulse Sources. In the simplest case, the Impulse Listener applies the signal verbatim to the camera’s Transform, causing it to shake.
+
+In the image below, the figure’s feet are Impulse Sources. When they collide with the floor (A) they generate impulses. The camera is an Impulse Listener and reacts to the impulses by shaking (B), which shakes the resulting image in the Game view (C).
+
+
+
+To add an Impulse Listener to a Cinemachine virtual camera:
+
+1. Select the virtual camera, navigate to the Inspector window and expand the **Cinemachine Virtual Camera** script.
+
+2. Go to **Extensions > Add Extension**, and select **CinemachineImpulseListener**.
+
+
+
+In the real world, some cameras are mounted less rigidly than others, and tend to shake more as a result. The Impulse Listener’s **Gain** property emulates this behavior by amplifying or attenuating impulse vibration signals. Higher values cause the camera to shake more.
+
+>**TIP:** You can create your own Impulse Listener to interpret vibration signals any way you like.
+
+By default, an Impulse Listener reacts to every Impulse Source in range, but you can apply [channel filtering](CinemachineImpulseFiltering.md#ChannelFiltering) to make a Listener react to some some Sources and ignore others.
+
+##Properties:
+
+| Property: | Function: |
+| ------------------- | ------------------------------------------------------------ |
+| **Channel Mask** | Specify the Impulse channels to react to. For details, see [Filtering with channels](CinemachineImpulseFiltering.md#ChannelFiltering). |
+| **Gain** | Amplify or attenuate the impulse signal. This property enables you to configure different Impulse Listeners to react differently to the same impulse signal. |
+| **Use 2D Distance** | Enable this setting to ignore the z axis when calculating camera distance from the Impulse Source. Use this property for 2D games. |
--- /dev/null
+# Using Noise Profiles
+
+Cinemachine uses a **[Noise Profile](CinemachineNoiseProfiles.md)** Asset to generate Basic Multi-Channel Perlin noise for Cinemachine Virtual Cameras. You can use the same Asset to create a procedural raw signal for Impulse.
+
+The **Noise Profile** Asset allows you to add noise in up to six dimensions: three rotational axes and three positional axes. Typical camera noise profiles use only rotational noise, but for Impulse you often want positional noise as well.
+
+Cinemachine ships with several **Noise Profile** presets, which you can use as they are, or clone and customize. **6D Shake** is a good all-around profile that you can use for a wide variety of situations.
+
+## Connecting a noise profile to an Impulse Source
+
+To connect a noise profile Asset to an Impulse Source or a Collision Impulse Source, do one of the following:
+
+- In the Impulse Source Inspector, click the gear icon next to the **Raw Signal** field and choose a preset from the **Presets** section of the menu.
+
+- In the Project view, locate the noise profile you want to connect and drag it onto the **Raw Signal** field in the Impulse Source Inspector.
+
+## Creating a new noise profile
+
+You can create your own noise profiles from scratch in the Noise Profile Inspector; however, you might find it easier to clone an existing preset and edit it.
+
+To create a new noise profile Asset:
+
+1. In the Impulse Source Inspector, click the gear icon next to the **Raw Signal** field and choose **New Noise Settings**.
+
+2. When prompted, give the new Asset a name and choose a location to save it to.
+
+3. Locate the new Asset in the Project view and select it to open the Noise Profile Inspector.
+
+ 
+
+ The Inspector displays a compound waveform for rotational noise and positional noise. You can expand any rotational or positional axis to view and edit its waveforms individually.
+
+ For details about creating custom noise profiles, see [Working with noise profiles](CinemachineNoiseProfiles.md)
--- /dev/null
+# Raw Vibration Signals
+
+Raw vibration signals are curves that vibrate as a function of time. Cinemachine provides two types of raw signal Asset:
+
+- A 6D (x, y, z, pitch, roll, and yaw) noise profile. See [Using Noise Pofiles](CinemachineImpulseNoiseProfiles.md) for details.
+
+- A 3D Fixed Signal. See [Using Fixed Signals](CinemachineImpulseFixedSignals.md) for details.
+
+Usually these raw signals are Assets in the Project.
+
+In the Impulse Source Inspector window, use the **Raw Signal** field to see which signal is connected to the Impulse Source. The Settings menu (indicated with a gear icon) next to the field provides options for working with raw signals:
+
+
+
+- **Edit** opens the signal in either the Noise Profile Inspector or the Fixed Signal Inspector.
+- **Clone** duplicates the signal Asset. This is useful when you want to use a preset or an existing Asset as a base for a new signal.
+- **Locate** finds the signal in the Project view.
+- **Presets** provides a menu of preset Noise Profile Assets.
+- **New Noise Settings** creates a new Noise Profile Asset from scratch. See [Creating a new noise profile](CinemachineImpulseNoiseProfiles.md#CreateNoiseProfile) for details.
+- **New Fixed Signal** creates a new Fixed Signal Asset from scratch. See [Creating a new fixed signal](CinemachineImpulseFixedSignals.md#CreateFixedSignal) for details.
+
+
+## Creating Custom Signals
+
+You can create your own custom signals. If you derive them from the **[CinemachineSignalSource](../api/Cinemachine.SignalSourceAsset.html)** base class, they appear automatically in the Inspector menu alongside the built-in ones.
--- /dev/null
+# Cinemachine Impulse Source
+
+Use the **Cinemachine Impulse Source** component to generate impulses on events that are not collisions or Collider triggers. This is a generic Impulse Source that exposes a family of `GenerateImpulse()` API methods. These methods generate impulses at the specified locations and with the specified velocities and strengths. Call these methods directly from your game logic, or use them with [UnityEvents](https://docs.unity3d.com/Manual/UnityEvents.html).
+
+>**TIP:** You can use the script for this component as an example to reference when creating your own custom impulse-generating classes.
+
+To add a Cinemachine Impulse Source to your Scene:
+
+1. Select the GameObject that you want to trigger camera shake, navigate to its Inspector, and click the **Add Component** button.
+
+2. Go to **Scripts > Cinemachine**, and select **Cinemachine Impulse Source**.
+
+By default, an Impulse Source affects every [Impulse Listener](CinemachineImpulseListener.md) in range, but you can apply [channel filtering](CinemachineImpulseFiltering.md#ChannelFiltering) to make Impulse Sources affect some Impulse Listeners and not others.
+
+##Properties:
+
+The properties in the Cinemachine Impulse Source Inspector window are divided into the following sections.
+
+- [Impulse Channel](#ImpulseChannel) (A)
+- [Signal Shape](#SignalShape) (B)
+- [Time Envelope](#TimeEnvelope) (C)
+- [Spatial Range](#SpatialRange) (D)
+
+
+
+<a name="ImpulseChannel"></a>
+### Impulse Channel
+
+Impulse Listeners filter impulses based on channels to control which Impulse Sources they react to. Channels work like Camera Layers, but are distinct from them. These properties control the channels that the Impulse Source broadcasts impulse signals on. For details, see documentation on [Filtering](CinemachineImpulseFiltering.md).
+
+
+
+| **Property:** | **Function:** |
+| ------------------- | ------------------------------------------------------------ |
+| **Impulse Channel** | Choose one or more channels from the drop-down.<br /><br />Click **Edit** to modify existing channels or add new ones. |
+
+<a name="SignalShape"></a>
+### Signal Shape
+
+These properties control the basic characteristics of the raw signal when it is emitted by the Impulse Source.
+
+
+
+| **Property:** | **Function:** |
+| -------------- | ------------------------------------------------------------ |
+| **Raw Signal** | The raw signal form. <br /><br />Drag a signal Asset onto the signal name to connect the signal to the Impulse Source.<br /><br />Click the “gear” icon for additional signal options, including options for creating new signals.<br /><br />See [Raw Vibration Signals](CinemachineImpulseRawSignal.md) for details. |
+|**Amplitude Gain** | Set a value by which to multiply the amplitude of **Raw Signal**. This controls the strength of the vibrations. This is set to 1 by default.<br /><br />Use values greater than 1 to amplify the signal, 1 for the original signal, values less than 1 and greater than 0 to attenuate the signal, and 0 to mute the signal. |
+|**Frequency Gain**|Set a value by which to multiply the frequency of **Raw Signal**. This controls the speed of the vibrations. This is set to 1 by default.<br /><br />Use values greater than one to increase the frequency, 1 for the original signal, values less than 1 and greater than 0 to reduce the frequency of the signal. A frequency of 0 holds a single noise value indefinitely, as though time were frozen.|
+|**Randomize**|Enable this to randomize the **Raw Signal’s** start time.<br /><br />This property is available when the **Raw Signal** is a noise profile Asset. See [Raw Vibration Signals](CinemachineImpulseRawSignal.md) for details.|
+|**Repeat Mode**|Specify whether to loop the **Raw Signal** over the duration of the time envelope, or stretch it to fit the time envelope.<br /><br />This property is available when the **Raw Signal** is a fixed signal. See [Raw Vibration Signals](CinemachineImpulseRawSignal.md) for details.|
+
+<a name="TimeEnvelope"></a>
+### Time Envelope
+
+These properties control the duration of the impulse and the intensity of the **Raw Signal** over that duration.
+
+
+
+| Property: | Function: |
+| --------------------- | ------------------------------------------------------------ |
+| **Attack** | Define how the signal reaches full amplitude at the beginning of the waveform. Click the preview pane (grey bar) to set the shape of the curve, and use the numerical field to set the time (in seconds) to reach the full amplitude. Leave the preview pane blank to use a default curve that is suitable for most purposes. |
+| **Sustain Time** | Set the time to maintain the full amplitude of the waveform after the attack. |
+| **Decay** | Define how the signal goes from full amplitude to zero the end of the waveform. Click the preview pane (grey bar) to set the shape of the curve, and use the numerical field to set the time (in seconds) to mute the signal. Leave the preview pane blank to use a default curve that is suitable for most purposes. |
+| **Scale With Impact** | Enable this to apply signal amplitude scaling to **Time Envelope**. If checked, the Cinemachine Impulse Source component scales the time envelope according to the strength of the impact: stronger impacts last longer, and milder impacts have a shorter duration. |
+
+
+<a name="SpatialRange"></a>
+### Spatial Range
+
+These properties define a zone in the Scene. The impulses from this Impulse Source only affect Impulse Listeners in this zone.
+
+
+
+| Property:|| Function:|
+|--|--|--|
+|**Impact Radius**||Set the radius of the space in the Scene around the impact point where the signal stays at full amplitude. Beyond that the signal strength fades out over the dissipation distance. After that, the strength is zero. In other words, the total effect radius of the signal is **Impact Radius** + **Dissipation Distance**.|
+|**Direction Mode**||Define how the Cinemachine Impulse Source component should apply the direction of the signal as the Impulse Listener moves away from the Impulse Source.|
+||Fixed|Use **Fixed** to use a constant signal direction.|
+||Rotate Toward Source|Use **Rotate Toward Source** to rotate the signal in the direction of the Impulse Source, giving a subtle visual clue about the source’s location. **Rotate Toward Source** has no effect on radially-symmetric signals.|
+|**Dissipation Mode**||Define how the signal dissipates when the listener is outside the **Impact Radius**.|
+||Linear Decay|The signal dissipates evenly over the **Dissipation Distance**.|
+||Soft Decay|The signal dissipates slowly at the beginning of the **Dissipation Distance**, more quickly in the middle, and slowly again as it reaches the end.|
+|| Exponential Decay|The signal dissipates very quickly at the beginning of the **Dissipation Distance**, then more and more slowly as it reaches the end.|
+|**Dissipation Distance**||Set the distance beyond the impact radius over which the signal decays from full strength to nothing.|
\ No newline at end of file
--- /dev/null
+# Cinemachine Impulse Sources
+
+An Impulse Source is a component that emits a vibration signal from a point in Scene space. Game events can cause an Impulse Source to emit a signal from the place where the event occurs. The event _triggers_ impulses, and the source _generates_ impulses. Virtual cameras with an Impulse Listener extension _react_ to impulses by shaking.
+
+In the image below, the figure's feet are Impulse Sources. When they collide with the floor (A) they generate impulses. The camera is an Impulse Listener and reacts to the impulses by shaking (B), which shakes the resulting image in the game view (C).
+
+
+
+Cinemachine ships with two types of Impulse Source component.
+
+- **[Cinemachine Collision Impulse Source](CinemachineCollisionImpulseSource.md)** generates impulses in reaction to collisions and trigger zones.
+
+- **[Cinemachine Impulse Source](CinemachineImpulseSource.md)** generates impulses in reaction to events other than collisions.
+
+Your Scene can have as many Impulse Sources as you want. Here are a few examples of where you might use Impulse Source components in a Scene:
+
+- On each of a giant’s feet, so that the ground shakes when the giant walks.
+
+- On a projectile that explodes when it hits a target.
+
+- On the surface of a gelatin planet that wobbles when something touches it.
+
+By default, an Impulse Source affects every [Impulse Listener](CinemachineImpulseListener.md) in range, but you can apply [channel filtering](CinemachineImpulseFiltering.md#ChannelFiltering) to make Sources affect some Listeners and not others.
+
+## Key Impulse Source properties
+
+While the raw vibration signal defines the basic “shape” of the camera shake, the Impulse Source controls several other important properties that define the impulses it generates.
+
+Understanding some of these properties in detail can help you create more realistic camera shake setups.
+
+Below you'll find detailed descriptions of the following key properties:
+
+- **[Amplitude](#Amplitude):** controls the strength of the vibration.
+
+- **[Orientation and direction](#Orientation):** Impulse can transform the signal so that the vibrations are consistent with the direction of the impact that produces them.
+
+- **[Time envelope](#TimeEnvelope):** controls the signal’s attack, sustain, and decay so that the signal fades in and out to the appropriate intensity and has a finite duration.
+
+- **[Spatial range](#SpatialRange):** controls how far the signal travels in the Scene before it fades out completely
+
+For descriptions of all Impulse Source properties, as well as instructions for adding Impulse Sources to your scene, see documentation on the [Impulse Source](CinemachineImpulseSource.md) and [Collision Impulse Source](CinemachineCollisionImpulseSource.md) components.
+
+<a name="Amplitude"></a>
+### Amplitude
+
+The amplitude of the raw impulse signal controls the strength of the vibration for each impact. There are two ways to adjust the amplitude for a given Impulse Source.
+
+The **Amplitude Gain** property amplifies or attenuates the raw impulse signal. It affects all impacts, all the time. Think of it as a global “volume” setting for turning the strength of an Impulse Source’s vibrations up or down.
+
+Changing the magnitude of the **Velocity** vector when generating the signal also scales the signal amplitude, but the effect is per-impact rather than global. By adjusting the velocity of individual Impulse events, you can set things up so that light impacts make smaller vibrations, and heavy impacts make bigger ones.
+
+- For the **Cinemachine Impulse Source** component you must set the velocity vector yourself via a script. The signal’s amplitude scales by the magnitude of this vector.
+
+- The **Cinemachine Collision Impulse Source** component calculates the velocity vector automatically according to rules defined by the three properties in the **[How To Generate The Impulse](CinemachineCollisionImpulseSource.md#GenerateImpulse)** section.
+
+These global and per-impact adjustments are multiplied to calculate the actual amplitude of each impact.
+
+
+<a name="Orientation"></a>
+### Orientation and Direction
+
+To create realistic vibrations, an impulse signal should be strongest along the axis of impact, and its amplitude (or strength) should be proportional to the force of the impact. For example, if you strike a wall with a hammer, the wall vibrates primarily along the axis of the hammer’s path. For the hammer’s impulse signal to be realistic, it should have the most vibration along that axis.
+
+In the image below, the main axis for vibration (A) matches the direction the hammer is traveling when it hits the wall (B).
+
+
+
+Rather than requiring separate signal definitions for every possible impact direction and strength, Impulse uses the concept of a “local space” for defining the raw signal. You can rotate and scale the raw signal in its local space to produce a “final” signal that matches the actual impact.
+
+Impulse assumes that the main direction for an impact is “down,” so as a general rule, your signals should put more vibration along the Y axis (the 6D shake noise preset does this). You can then rely on local-space rotation and scaling to produce the correct vibrations for each impact occurrence.
+
+#### Controlling orientation and direction
+
+The **Cinemachine Impulse Source** and **Cinemachine Collision Impulse Source** components have properties that control the orientation of the raw signal. Use these properties to mimic real-world vibration.
+
+- For the **Cinemachine Impulse Source** component, the [GenerateImpulse()](../api/Cinemachine.CinemachineImpulseSource.html#Cinemachine_CinemachineImpulseSource_GenerateImpulse_) method takes a velocity vector as a parameter. This vector defines the direction and strength of the impact. The Impulse system uses this to calculate the final signal based on the Raw signal definition, rotating and scaling it appropriately.
+
+- For the **Cinemachine Collision Impulse Source** component, the velocity vector is generated automatically based on the directions and masses of the GameObjects involved.
+
+ To control how this is done, use the properties in the **[How To Generate The Impulse](CinemachineCollisionImpulseSource.md#GenerateImpulse)** section of the Inspector window. The **Use Impact Direction** property controls whether the signal is rotated to correspond to the impact direction.
+
+#### Direction mode
+
+The **[Spatial Range](CinemachineImpulseSource.md#SpatialRange) > Direction Mode** property allows you to add a subtle tweak to the signal orientation. When you set it to **Rotate Towards Source**, the impulse signal is further rotated so that vibrations point a little more prominently in the direction of the Impulse Source.
+
+The effect isn’t noticeable for radially symmetric vibrations, but for signals that emphasize a direction, like 6D shake, it gives a subconscious indication of where the vibration is coming from. This can be quite effective when you generate impacts in multiple locations and you don't want them to all feel the same.
+
+The default **Direction Mode** setting of **Fixed** turns the effect off.
+
+
+<a name="TimeEnvelope"></a>
+### Time envelope
+
+Vibrations from a real-world impact get stronger until they reach their peak strength, then weaken until the vibration stops. How long this cycle takes depends on the strength of the impact, and the characteristics of the GameObjects involved.
+
+For instance, striking a concrete wall with a hammer produces a short, sharp impact. The vibrations reach their peak strength almost instantly and stop almost instantly. Striking a large sheet of thin metal, on the other hand, produces sustained vibration, which starts suddenly, stays at peak intensity for a while, and gradually softens.
+
+Use an Impulse Source’s **[Time Envelope](CinemachineImpulseSource.md#TimeEnvelope)** properties to control this cycle when impacts in the Scene shake the camera. The time envelope has three properties:
+
+- **Attack** controls the Impulse signal’s transition to peak intensity.
+- **Sustain Time** specifies how long the signal stays at peak intensity.
+- **Decay** controls the signal’s transition from peak intensity to zero.
+
+Both **Attack** and **Decay** consist of a duration value that specifies how long the transition takes, and a curve that defines how it happens (for example, whether it happens gradually or suddenly). The curves are optional; if you leave them blank in the Inspector window, Impulse uses its default curves, which are suitable for most purposes. **Sustain Time** is a duration value only.
+
+Taken together, these properties control how long vibrations from an impact occurrence last, and how they fade in and fade out. However, they don’t account for the strength of the impact. To do that, enable the **Scale with Impact** property. When it’s enabled, the time envelope scales according the strength of an impact. Stronger impacts make the envelope longer, and weaker ones make it shorter. This does not affect the envelope’s proportions.
+
+<a name="SpatialRange"></a>
+### Spatial Range
+
+An Impulse Source’s **[Spatial Range](CinemachineImpulseSource.md#SpatialRange)** properties define the zone in the Scene that the Impulse Source affects. Impulse Listeners in this zone react to the Impulse source (unless they are [filtered out](CinemachineImpulseFiltering.md)), while Listeners outside of it do not.
+
+The zone consists of two parts: the **Impact Radius** and the **Dissipation Distance**. When the Impulse Source generates an impulse, the vibration signal stays at full strength until it reaches the end of the **Impact Radius**. Its strength then fades to zero over the **Dissipation Distance**. Together, these two properties define the signal’s total range.
+
+In the image below, the vibration signal stays at full strength from the time it’s emitted from impact point until it reaches the Impact Radius (A), then fades out over the Dissipation Distance (B).
+
+
+
+The **Dissipation Mode** property controls _how_ the signal fades out over the **Dissipation Distance**.
+
+* **Exponential Decay** creates a fade-out that starts fast and slows down as it nears the end of the dissipation distance.
+
+* **Soft Decay** creates a fade-out that starts slow, speeds up, and slows down again as it nears the end of the dissipation distance.
+
+* **Linear Decay** creates an even fade-out over the dissipation distance.
\ No newline at end of file
--- /dev/null
+# Managing and grouping Virtual Cameras
+
+A __manager__ camera oversees many Virtual Cameras but acts as a single Virtual Camera from the point of view of Cinemachine Brain and Timeline.
+
+Cinemachine includes these manager cameras:
+
+* [Free Look Camera](CinemachineFreeLook.html): an enhanced [Orbital Transposer](CinemachineBodyOrbitalTransposer.html). It manages three horizontal orbits, arranged vertically to surround an avatar.
+
+* [Mixing Camera](CinemachineMixingCamera.html): uses the weighted average of up to eight child Virtual Cameras.
+
+* [Blend List Camera](CinemachineBlendListCamera.html): executes a sequence of blends or cuts of its child Virtual Cameras.
+
+* [Clear Shot Camera](CinemachineClearShot.html): picks the child Virtual Camera with the best view of the target.
+
+* [State-Driven Camera](CinemachineStateDrivenCamera.html): picks a child Virtual Camera in reaction to changes in animation state.
+
+Because manager cameras act like normal Virtual Cameras, you can nest them. In other words, create arbitrarily complex camera rigs that combine regular Virtual Cameras and manager cameras.
+
--- /dev/null
+# Cinemachine Mixing Camera
+
+The __Cinemachine Mixing Camera__ component uses the weighted average of its child Virtual Cameras to compute the position and other properties of the Unity camera.
+
+
+
+Mixing Camera manages up to eight child Virtual Cameras. In the Mixing Camera component, these Virtual Cameras are fixed slots, not a dynamic array. Mixing Camera uses this implementation to support weight animation in Timeline. Timeline cannot animate array elements.
+
+To create a Mixing Camera:
+
+1. In the Unity menu, choose __Cinemachine > Create Mixing Camera__.
+A new Mixing Camera appears in the [Hierarchy](https://docs.unity3d.com/Manual/Hierarchy.html) window. By default, Unity also adds two Virtual Cameras as children of the Mixing Camera.
+
+2. Adjust the children Virtual Cameras.
+
+3. Add up to six more child cameras.
+
+4. Select the Mixing Camera in the Hierarchy window then adjust the Child Camera Weights in the [Inspector](https://docs.unity3d.com/Manual/UsingTheInspector.html) window.
+
+
+
+## Properties:
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Solo__ | Toggles whether or not the Mixing Camera is temporarily live. Use this property to get immediate visual feedback in the [Game view](https://docs.unity3d.com/Manual/GameView.html) to adjust the Virtual Camera. |
+| __Game Window Guides__ | Toggles the visibility of compositional guides in the Game view. This property applies to all Virtual Cameras. |
+| __Save During Play__ | Check to [apply the changes while in Play mode](CinemachineSavingDuringPlay.html). Use this feature to fine-tune a Virtual Camera without having to remember which properties to copy and paste. This property applies to all Virtual Cameras. |
+| __Priority__ | The importance of this Mixing Camera for choosing the next shot. A higher value indicates a higher priority. Cinemachine Brain chooses the next live Virtual Camera from all Virtual Cameras that are activated and have the same or higher priority as the current live Virtual Camera. This property has no effect when using a Virtual Camera with Timeline. |
+| __Child Camera Weights__ | The weight of the Virtual Camera. Each child Virtual Camera has a corresponding Weight property. Note that setting one camera's weight to 1 does not put the other weights to zero. The contribution of any individual camera is its weight divided by the sum of all the child weights. |
+| __Mix Result__ | A graphical representation of the weights of the child Virtual Cameras. The light part of the bar of each child camera represents the proportion of its contribution to the final position of the Mixing Camera. When the bar is completely dark, the camera makes no contribution to the position of the Mixing Camera. |
+
+
--- /dev/null
+# Using multiple Unity cameras
+
+Split-screen and picture-in-picture effects require the use of more than one Unity camera. Each Unity camera presents its own view on the player’s screen.
+
+To use a multi-camera split-screen for two players:
+
+1. For each player, [create a layer](https://docs.unity3d.com/Manual/Layers.html). For example, for two players, create layers named P1 and P2.
+
+2. Add two Unity cameras to your Scene, set up their viewports, and give each one its own Cinemachine Brain component.
+
+3. For each Unity camera, set the __Culling Mask__ to the appropriate layer while excluding the other layer. For example, set the first Unity camera to include layer P1 while excluding P2.
+
+4. Add 2 Virtual Cameras, one to follow each player to follow the players. Assign each Virtual Camera to a player layer.
+
--- /dev/null
+# Working with noise profiles
+
+A __noise profile__ is an asset that defines a procedural curve for camera noise. The __Basic Multi Channel Perlin__ component applies a noise profile to the movement of the camera. Cinemachine applies noise movement after computing the position of the camera. This way, camera noise does not affect the computation of camera movement in future updates.
+
+Cinemachine includes some predefined profile assets. Choose a predefined noise profile in the Noise component. Create your own noise profile asset by choosing __Create > Cinemachine > NoiseSettings__ in the [Project window](https://docs.unity3d.com/Manual/ProjectView.html).
+
+The properties in the Inspector show graphs that give a visual representation of the noise profile. There are properties for the x, y, and z axes for position and rotation. Each axis may have more than one layer.
+
+
+
+For realistic procedural noise, choose frequencies and amplitudes with care to ensure an interesting noise quality that is not obviously repetitive. The most convincing camera shakes use __Rotation__ noise because that’s where the camera is aiming. Handheld camera operators tend to shake more rotationally than they do positionally. After specifying __Rotation__ noise, add __Position__ noise.
+
+Convincing noise profiles typically mix low, medium, and high frequencies together. When creating a new noise profile, start with these three layers of noise for each axis.
+
+For amplitude, use larger values for wider lenses to shake the camera noticeably. For telephoto lenses, use smaller amplitude values because the narrower FOV amplifies the effect.
+
+For frequency, a typical low range is 0.1-0.5 Hz, the mid range 0.8-1.5, and the high 3-4. The highest useful frequency depends on the frame rate of your game. A game typically runs at 30 or 60Hz. Noise frequencies higher than the frame rate of your game fall between the cracks of the Nyquist rate. In other words, they will not be directly tracked.
+
+For example, if your game runs at 60 frames/second and you set a frequency to 100, you will get choppy camera noise. This is because your game can’t render something that moves faster than the frame rate.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Preview Time__ || The number of seconds to display in the graphs in the Inspector. This property is for editing in the Inspector; it does not affect the content of the noise profile asset that you are editing. |
+| __Preview Height__ || The vertical height of the graphs of the noise profile in the Inspector. This property is for editing noise profiles; it does not affect the noise profile asset. |
+| __Animated__ || Check to show a moving representation of an example of the noise profile in the graph. This property is for editing noise profiles; it does not affect the noise profile asset. |
+| __Position Noise__ || A graphical representation of all noise layers for all axes for camera movement. |
+| __Position X__, __Position Y__, __Position Z__ || The layers of noise for each axis to apply to camera movement. Each axis has a graphical representation of its layers. Each layer has properties for Frequency, Amplitude, and optional Perlin noise. Click + or - to add and remove layers, respectively. |
+| | _Frequency_ | The frequency of the wave in the noise layer, in Hz. |
+| | _Amplitude_ | The amplitude (height) of the wave in the noise layer, in distance units. |
+| | _Non-random wave if checked_ | Check to remove the Perlin noise from the noise layer. Without Perlin noise, Cinemachine uses a regular sine wave. Uncheck to apply Perlin noise to the layer, randomizing both the frequency and the amplitude while remaining in the neighbourhood of the selected values. |
+| __Rotation Noise__ || A graphical representation of all noise layers for all axes for camera rotation. |
+| __Rotation X__, __Rotation Y__, __Rotation Z__ || The layers of noise for each axis to apply to camera rotation. Each layer has properties for Frequency, Amplitude, and optional Perlin Noise. Click + or - to add and remove layers, respectively. |
+| | _Frequency_ | The frequency of the wave in the noise layer, in Hz. |
+| | _Amplitude_ | The amplitude (height) of the wave in the noise layer, in degrees. |
+| | _Non-random wave if checked_ | Check to remove the Perlin noise from the noise layer. Without Perlin noise, Cinemachine uses a regular sine wave. Uncheck to include random Perlin noise variation, randomizing both the frequency and the amplitude while remaining in the neighbourhood of the selected values. |
+
+
--- /dev/null
+# Cinemachine overview
+
+Using Cinemachine requires a new way of thinking about working with cameras. For example, you might have already invested heavily in carefully scripted camera behaviors. However, Cinemachine can give the same results, if not better, in less time. Get up and running quickly to create and tune cameras without bothering your engineer.
+
+## Virtual Cameras
+
+Cinemachine does not create new cameras. Instead, it directs a single Unity camera for multiple shots. You compose these shots with __Virtual Cameras__. Virtual Cameras move and rotate the Unity camera and control its settings.
+
+The Virtual Cameras are separate GameObjects from the Unity Camera, and behave independently. They are not nested within each other. For example, a Scene might look like this:
+
+
+
+The main tasks that the Virtual Camera does for you:
+
+* Position the Unity camera in the Scene.
+
+* Aim the Unity camera at something.
+
+* Add procedural noise to the Unity camera. Noise simulates things like handheld effects or vehicle shakes.
+
+Cinemachine encourages you to create many Virtual Cameras. The Virtual Camera is designed to consume little processing power. If your Scene is performance-sensitive, deactivate all but the essential Virtual Cameras at any given moment for extreme performance.
+
+A good rule of thumb is to use a single Virtual Camera for a single shot. Take advantage of this to create dramatic or subtle cuts or blends. Examples:
+
+* For a cutscene where two characters exchange dialog, use three Virtual Cameras: one camera for a mid-shot of both characters, and separate Virtual Cameras for a close-up of each character. Then use Timeline to synchronize audio with the Virtual Cameras.
+
+* Duplicate an existing Virtual Camera so that both Virtual Cameras are in the same position in the Scene. For the second Virtual Camera, change the FOV or composition a bit. When a player enters a trigger volume, Cinemachine blends from the first to the second Virtual Camera to emphasize a change in action.
+
+One Virtual Camera has control of the Unity camera at any point in time. This is the __live__ Virtual Camera. The only exception to this rule is during a blend from one Virtual Camera to the next. During blending, both Virtual Cameras are live.
+
+## Cinemachine Brain
+
+The Cinemachine Brain is a component in the Unity Camera itself. Cinemachine Brain monitors all active Virtual Cameras in the Scene. To specify the next live Virtual Camera, you [activate or deactivate](https://docs.unity3d.com/Manual/DeactivatingGameObjects.html) the desired Virtual Camera's game object. Cinemachine Brain then chooses the most recently activated Virtual Camera with the same or higher priority as the live Virtual Camera. It performs a cut or blend between the previous and new Virtual Cameras.
+
+**Tip**: Use Cinemachine Brain to respond to dynamic game events in real time. It allows your game logic to control the camera by manipulating priorities. This is particularly useful for live gameplay, where action isn’t always predictable. Use [Timeline](CinemachineTimeline.html) to choreograph cameras in predictable situations, like cutscenes. Timeline overrides the Cinemachine Brain priority system to give you precise, to-the-frame camera control.
+
+## Moving and aiming
+
+Use the [__Body__ properties](CinemachineVirtualCameraBody.html) in a Virtual Camera to specify how to move it in the Scene. Use the [__Aim__ properties](CinemachineVirtualCameraAim.html) to specify how to rotate it.
+
+A Virtual Camera has two targets:
+
+* The __Follow__ target specifies a GameObject for the Virtual Camera to move with.
+* The __Look At__ target specifies the GameObject to aim at.
+
+Cinemachine includes a variety of procedural algorithms to control moving and aiming. Each algorithm solves a specific problem, and has properties to customize the algorithm for your specific needs. Cinemachine implements these algorithms as `CinemachineComponent` objects. Use the `CinemachineComponent` class to implement a custom moving or aiming behavior.
+
+The __Body__ properties offer the following procedural algorithms for moving the Virtual Camera in a Scene:
+
+* __Transposer__: Move in a fixed relationship to the __Follow__ target, with optional damping.
+* __Do Nothing__: Do not move the Virtual Camera.
+* __Framing Transposer__: Move in a fixed screen-space relationship to the __Follow__ target, with optional damping.
+* __Orbital Transposer__: Move in a variable relationship to the __Follow__ target, optionally accepting player input.
+* __Tracked Dolly__: Move along a predefined path.
+* __Hard Lock to Target__: Use the same position at the __Follow__ target.
+
+The __Aim__ properties offer the following procedural algorithms for rotating a Virtual Camera to face the __Look At__ target:
+
+* __Composer__: Keep the __Look At__ target in the camera frame, with compositional constraints.
+* __Group Composer__: Keep multiple __Look At__ targets in the camera frame.
+* __Do Nothing__: Do not rotate the Virtual Camera.
+* __POV__: Rotate the Virtual Camera based on the user’s input.
+* __Same As Follow Target__: Set the camera’s rotation to the rotation of the __Follow__ target.
+* __Hard Look At__: Keep the __Look At__ target in the center of the camera frame.
+
+
+## Composing a shot
+
+The [__Framing Transposer__](CinemachineBodyFramingTransposer.html), [__Composer__](CinemachineAimComposer.html), and [__Group Composer__](CinemachineAimGroupComposer.html) algorithms define areas in the camera frame for you to compose a shot:
+
+* __Dead zone__: The area of the frame that Cinemachine keeps the target in.
+
+* __Soft zone__: If the target enters this region of the frame, the camera will re-orient to put it back in the dead zone. It will do this slowly or quickly, according to the time specified in the Damping settings.
+
+* __Screen__: The screen position of the center of the dead zone. 0.5 is the center of the screen.
+
+* __Damping__: Simulates the lag that a real camera operator introduces while operating a heavy physical camera. Damping specifies quickly or slowly the camera reacts when the target enters the __soft zone__ while the camera tracks the target. Use small numbers to simulate a more responsive camera, rapidly moving or aiming the camera to keep the target in the __dead zone__. Larger numbers simulate heavier cameras, The larger the value, the more Cinemachine allows the target to enter the soft zone.
+
+The __Game Window Guides__ gives an interactive, visual indication of these areas. The guides appear as tinted areas in the [Game view](https://docs.unity3d.com/Manual/GameView.html).
+
+
+
+The clear area indicates the __dead zone__. The blue-tinted area indicates the __soft zone__. The position of the soft and dead zones indicates the __screen__ position. The red-tinted area indicates the __no pass__ area, which the target never enters. The yellow square indicates the target.
+
+Adjust these areas to get a wide range of camera behaviors. To do this, drag their edges in the Game view or edit their properties in the Inspector window. For example, use larger damping values to simulate a larger, heavier camera, or enlarge the __soft zone__ and __dead zone__ to create an area in the middle of the camera frame that is immune to target motion. Use this feature for things like animation cycles, where you don’t want the camera to track the target if it moves just a little.
+
+## Using noise to simulate camera shake
+
+Real-world physical cameras are often heavy and cumbersome. They are hand-held by the camera operator or mounted on unstable objects like moving vehicles. Use [Noise properties](CinemachineVirtualCameraNoise.html) to simulate these real-world qualities for cinematic effect. For example, you could add a camera shake when following a running character to immerse the player in the action.
+
+At each frame update, Cinemachine adds noise separately from the movement of the camera to follow a target. Noise does not influence the camera’s position in future frames. This separation ensures that properties like __damping__ behave as expected.
--- /dev/null
+# Cinemachine Path
+
+__Cinemachine Path__ is a component that defines a world-space path, consisting of an array of waypoints. Each waypoint specifies position, tangent, and roll settings. Bezier interpolation is performed between the waypoints, to get a smooth and continuous path.
+
+**Tip**: While the path position will always be smooth and continuous, it is still possible to get jarring movement when animating along the path. This happens when tangents aren’t set to ensure continuity of both the first and second order derivatives. It is not easy to get this right. To avoid this potentially jarring movement, use Cinemachine Smooth Path. CinemachineSmoothPath sets the tangents automatically to ensure complete smoothness.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Resolution__ || Path samples per waypoint. Cinemachine uses this value to limit the granularity when calculating path distances. The crosshatches on the path gizmo in the scene view reflect this value|
+| __Appearance__ || The settings that control how the path appears in the Scene view. |
+| | _Path Color_ | The color of the path when it is selected. |
+| | _Inactive Path Color_ | The color of the path when it is not selected. |
+| | _Width_ | The width of the railroad tracks that represent the path. |
+| __Looped__ || Check to join the ends of the path to form a continuous loop. |
+| __Selected Waypoint__ || Properties for the waypoint you selected in the Scene view or in the Waypoints list. |
+| __Prefer Tangent Drag__ || Check to use the Gizmo for the tangent of a waypoint when the Gizmos for the tangent and position coincide in the Scene view. |
+| __Waypoints__ || The list of waypoints that define the path. |
+| | _Position_ | Position in path-local space (i.e. relative to the transform of the path object itself) |
+| | _Tangent_ | Offset from the position, which defines the tangent of the curve at the waypoint. The length of the tangent encodes the strength of the bezier handle. The same handle is used symmetrically on both sides of the waypoint, to ensure smoothness. |
+| | _Roll_ | The roll of the path at this waypoint. The other orientation axes are inferred from the tangent and world up. |
+
+
--- /dev/null
+# Cinemachine and Postprocessing
+
+Use the Cinemachine Post Processing [extension](CinemachineVirtualCameraExtensions.html) to attach a Postprocessing V2 profile to a Virtual Camera.
+
+**Note**: Unity recommends using Postprocessing V2 instead of Postprocessing V1.
+
+The Cinemachine Post Processing extension holds a Post-Processing Profile asset to apply to a Virtual Camera when it is activated. If the camera is blending with another Virtual Camera, then the blend weight is applied to the Post Process effects also.
+
+Before attaching post processing profiles to Virtual Cameras, you first need to set up your project to use post processing. You need to do this setup only once.
+
+To set up project to use Post Processing V2 with Cinemachine:
+
+1. [Install](https://docs.unity3d.com/Packages/com.unity.package-manager-ui@latest/index.html) the Postprocessing V2 package.
+
+2. In the Unity menu, choose __Cinemachine > Import Post Processing V2 Adaptor Asset Package__.
+
+3. Select your Unity camera with Cinemachine Brain in the [Scene](https://docs.unity3d.com/Manual/UsingTheSceneView.html) view.
+
+4. [Add the component](https://docs.unity3d.com/Manual/UsingComponents.html) named __Post-Process Layer__. This will anble Post Process profiles to affect the Camera.
+
+To add a Post Process profile to a Virtual Camera
+
+3. Select your Virtual Camera in the [Scene](https://docs.unity3d.com/Manual/UsingTheSceneView.html) view or [Hierarchy](https://docs.unity3d.com/Manual/Hierarchy.html) window.
+
+4. In the [Inspector](https://docs.unity3d.com/Manual/UsingTheInspector.html), choose __Add Extension > CinemachinePostProcessing__, then configre the Profile asset to have the effects you want when this virtual camera is live.
+
+## Properties:
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Profile__ | The Post-Processing profile to activate when this Virtual Camera is live. |
+| __Focus Tracks Target__ | Check to set Focus Distance to the distance between the camera and the Look At target. |
+| __Offset__ | When Focus Tracks Target is checked, this offset is applied to the target position when setting the focus, focus distance. If there is no Look At target, then this is the offset from the Unity camera position, the actual focus distance. |
+
+
--- /dev/null
+# Saving in Play Mode
+
+It’s often most convenient to adjust camera settings while the game is playing. But normally, Unity does not save your changes to the Scene when you exit Play Mode. Cinemachine has a special feature to preserve the tweaks you make during Play Mode. It doesn’t save structural changes, like adding or removing a behavior. With the exception of certain properties, Cinemachine preserves most of the settings in your Virtual Cameras when you exit Play Mode.
+
+When you exit Play Mode, Cinemachine scans the Scene to collect any changed properties in the Virtual Cameras. Cinemachine saves these changes a second or so after exiting. Use the __Edit > Undo__ command to revert these changes.
+
+Check __Save During Play__ on any Virtual Camera in the [Inspector](https://docs.unity3d.com/Manual/UsingTheInspector.html) to enable this feature. This is a global property, not per-camera, so you only need to check or uncheck it once.
+
+Cinemachine components have the special attribute `[SaveDuringPlay]` to enable this functionality. Feel free to use it on classes within your own custom scripts too if you need it. To exclude a field in a class with the `[SaveDuringPlay]` attribute, add the `[NoSaveDuringPlay]` attribute to the field.
+
--- /dev/null
+# Setting up Virtual Cameras
+
+In your project, organize your Scene Hierarchy to have a single Unity camera with a CinemachineBrain component and many Virtual Cameras.
+
+To add a Virtual Camera to a Scene:
+
+1. In the Unity menu, choose __Cinemachine > Create Virtual Camera__. <br/>Unity adds a new GameObject with a Cinemachine Virtual Camera component. If necessary, Unity also adds a [Cinemachine Brain](CinemachineBrainProperties.html) component to the Unity camera GameObject for you.
+
+2. Use the __Follow__ property to specify a GameObject to follow. <br/>The Virtual Camera automatically positions the Unity camera relative to this GameObject at all times, even as you move it in the Scene.
+
+3. Use the __Look At__ property to specify the GameObject that the Virtual Camera should aim at. <br/>The Virtual Camera automatically rotates the Unity camera to face this GameObject at all times, even as you move it in the Scene.
+
+4. [Customize the Virtual Camera](CinemachineVirtualCamera.html) as needed. <br/>Choose the algorithm for following and looking at, and adjust settings such as the follow offset, the follow damping, the screen composition, and the damping used when re-aiming the camera.
+
+
+
--- /dev/null
+# Cinemachine Smooth Path
+
+A __Cinemachine Smooth Path__ is a component that defines a world-space path, consisting of an array of waypoints. Each waypoint has position and roll settings. Cinemachine uses Bezier interpolation to calculate positions between the waypoints to get a smooth and continuous path. The path passes through all waypoints. Unlike Cinemachine Path, first and second order continuity is guaranteed, which means that not only the positions but also the angular velocities of objects animated along the path will be smooth and continuous.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Resolution__ || Path samples per waypoint. Cinemachine uses this value to calculate path distances. |
+| __Looped__ || If checked, then the path ends are joined to form a continuous loop. |
+| __Waypoints__ || The waypoints that define the path. They are interpolated using a bezier curve. |
+| __Resolution__ || Path samples per waypoint. This is used for calculating path distances. |
+| __Appearance__ || The settings that control how the path appears in the Scene view. |
+| | _Path Color_ | The color of the path when it is selected. |
+| | _Inactive Path Color_ | The color of the path when it is not selected. |
+| | _Width_ | The width of the railroad tracks that represent the path. |
+| __Looped__ || Check to join the ends of the path to form a continuous loop. |
+| __Selected Waypoint__ || Properties for the waypoint you selected in the Scene view or in the Waypoints list. |
+| __Waypoints__ || The list of waypoints that define the path. They are interpolated using a bezier curve. |
+| | _Position_ | Position in path-local space. |
+| | _Roll_ | Defines the roll of the path at this waypoint. The other orientation axes are inferred from the tangent and world up. |
+
+
--- /dev/null
+# Cinemachine State-Driven Camera
+
+The __Cinemachine State-Driven Camera__ component activates a child Virtual Camera when an animation target changes states. For example, consider your avatar’s local-motion system and orbit camera. Your game feels more alive to the player when the camera shakes more as your avatar runs. When the avatar walks, blend for example to a Virtual Camera with more damping.
+
+
+
+The animation target for a State-Driven Camera is a GameObject with an [Animator](https://docs.unity3d.com/Manual/class-Animator.html) component controlled by an [Animator Controller](https://docs.unity3d.com/Manual/class-AnimatorController.html).
+
+Assign normal __Look At__ and __Follow__ targets to each child Virtual Camera. If a child Virtual Camera has no __Look At__ or __Follow__ target, State-Driven camera uses its own, respective targets.
+
+State-Driven Camera has a list that assigns child Virtual Cameras to animation states. You can define default and custom blends between the State-Driven children.
+
+In the Inspector, the State-Driven camera lists its Virtual Camera children. Use this list to add and delete child Virtual Cameras, and assign priorities.
+
+
+
+To create a State-Driven camera:
+
+1. Set up the animation target GameObject to [control it with an Animator Controller](https://docs.unity3d.com/Manual/AnimatorControllers.html).
+
+2. In the Unity menu, choose __Cinemachine > Create State-Driven Camera__.<br/>A new State-Driven camera appears in the hierarchy with a new child Virtual Camera.
+
+3. In the [Inspector](https://docs.unity3d.com/Manual/UsingTheInspector.html), assign the animation target you created in step 1 to the Animated Target property.
+
+4. If needed, add more child VIrtual Cameras either by clicking + in Virtual Camera Children or dragging and dropping existing Virtual Cameras in the [Hierarchy](https://docs.unity3d.com/Manual/Hierarchy.html) window.
+
+5. Use the __State__ to assign child Virtual Cameras to the animation states.
+
+## Properties:
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Solo__ | Toggles whether or not the Virtual Camera is temporarily live. Use this property to get immediate visual feedback in the [Game view](https://docs.unity3d.com/Manual/GameView.html) to adjust the Virtual Camera. |
+| __Game Window Guides__ | Toggles the visibility of compositional guides in the Game view. These guides are available when Look At specifies a GameObject and the Aim section uses Composer or Group Composer, or when Follow specifies a target and the Body section uses Framing Composer. This property applies to all Virtual Cameras. |
+| __Save During Play__ | Check to [apply the changes while in Play mode](CinemachineSavingDuringPlay.html). Use this feature to fine-tune a Virtual Camera without having to remember which properties to copy and paste. This property applies to all Virtual Cameras. |
+| __Priority__ | The importance of this State-Driven camera for choosing the next shot. A higher value indicates a higher priority. This property has no effect when using a State-Driven camera with Timeline. |
+| __Look At__ | The default target GameObject that the children Virtual Camera move with. The State-Driven camera uses this target when the child does not specify this target. May be empty if all of the children define targets of their own. |
+| __Follow__ | The default target GameObject to aim the Unity camera at. The State-Driven camera uses this target when the child does not specify this target. May be empty if all of the children define targets of their own. |
+| __Animated Target__ | The GameObject that contains the Animator Controller. The State-Drive camera reacts to the animation state changes from this GameObject. |
+| __Layer__ | The animation layer to observe in the Animated Target. |
+| __Show Debug Text__ | Check to display a textual summary of the live Virtual Camera and blend in the game view. |
+| __Default Blend__ | The blend which is used if you don’t explicitly define a blend between two Virtual Cameras. |
+| __Custom Blends__ | The asset which contains custom settings for specific child blends. |
+| __State__ | The list of animation state assignments for child Virtual Cameras. |
+| __Virtual Camera Children__ | The list of Virtual Cameras that are children of the State-Driven camera. |
+
+
--- /dev/null
+# Storyboard
+
+Use the Cinemachine Storyboard [extension](CinemachineVirtualCameraExtensions.html) to let artists, producers, and directors contribute to your game development. Cinemachine Storyboard places a still image in screen space over the output of the Unity camera.
+
+Storyboard simplifies animatics for your team. Start with still images to pre-visualize terrain, layout, movement, lighting, timing, and so on. Following the intentions of the Storyboard image, developers incrementally add the assets, GameObjects, and settings that implement the Scene.
+
+Use the properties in the Storyboard component to hide and show the image to compare it to the actual rendering of the Unity camera.
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Show Image__ || Toggle the visibility of the storyboard image. |
+| __Image__ || The image to display as an overlay over the output of the Virtual Camera. |
+| __Aspect__ || How to handle differences between image aspect and screen aspect. |
+| | _Best Fit_ | Resize the image as large as possible on the screen without cropping. Preserve the vertical and horizontal proportions. |
+| | _Crop Image To Fit_ | Resize the image to fill the screen, cropping if necessary. Preserve the vertical and horizontal proportions. |
+| | _Stretch To Fit_ | Resize the image to fill the screen, adjusting the vertical or horizontal width if necessary. |
+| __Alpha__ || The opacity of the image. Use 0 for transparent, 1 for opaque. |
+| __Center__ || The screen-space position of the image. Use 0 for center. |
+| __Rotation__ || The screen-space rotation of the image. |
+| __Scale__ || The screen-space scaling of the image. |
+| __Sync Scale__ || Check to synchronize the scale of the x and y axes. |
+| __Mute Camera__ || Check to prevent the Virtual Camera from updating the position, rotation, or scale of the Unity camera. Use this feature to prevent Timeline from [blending](CinemachineBlending.html) the camera to an unintended position in the Scene. |
+| __Split View__ || Wipe the image on and off horizontally. |
--- /dev/null
+# Cinemachine Target Group
+
+Use Cinemachine Target Group to treat multiple GameObjects as a single Look At target. Use a Target Group with the [Group Composer](CinemachineAimGroupComposer.html) algorithm.
+
+To create a Virtual Camera with a Target Group:
+
+1. In the Unity menu, choose __Cinemachine > Create Target Group Camera__. <br/>Unity adds a new Virtual Camera and Target Group to the Scene. The __Follow__ and __Look At__ targets in the Virtual Camera refer to the new Target Group.
+
+2. In the [Hierarchy](https://docs.unity3d.com/Manual/Hierarchy.html), select the new Target Group object.
+
+3. In the [Inspector](https://docs.unity3d.com/Manual/UsingTheInspector.html), click the + sign to add a new item to the group.
+
+4. In the new item, assign a GameObject, and edit the __Weight__ and __Radius__ properties.
+
+5. To add more GameObjects to the Target Group, repeat steps 3-4.
+
+
+
+## Properties:
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Position Mode__ || How to calculate the position of the Target Group. |
+| | _Group Center_ | Use the center of the axis-aligned bounding box that contains all items of the Target Group. |
+| | _Group Average_ | Use the weighted average of the positions of the items in the Target Group. |
+| __Rotation Mode__ || How to calculate the rotation of the Target Group. |
+| | _Manual_ | Use the values specified in the Rotation properties of the Target Group’s transform. This is the recommended setting. |
+| | _Group Average_ | Weighted average of the orientation of the items in the Target Group. |
+| __Update Method__ || When to update the transform of the Target Group. |
+| | _Update_ | Update in the normal MonoBehaviour Update() method. |
+| | _Fixed Update_ | Updated in sync with the Physics module, in FixedUpdate(). |
+| | _Late Update_ | Updated in MonoBehaviour `LateUpdate()`. |
+| __Targets__ || The list of target GameObjects. |
+| | _Weight_ | How much weight to give the item when averaging. Cannot be negative. |
+| | _Radius_ | The radius of the item, used for calculating the bounding box. Cannot be negative. |
--- /dev/null
+# Cinemachine and Timeline
+
+Use [Timeline](https://docs.unity3d.com/Manual/TimelineSection.html) to activate, deactivate, and blend between Virtual Cameras. In Timeline, combine Cinemachine with other GameObjects and assets to interactively implement and tune rich cutscenes, even interactive ones.
+
+**Tip**: For simple shot sequences, use a [Cinemachine Blend List Camera](CinemachineBlendListCamera.html) instead of Timeline.
+
+Timeline overrides the priority-based decisions made by [Cinemachine Brain](CinemachineBrainProperties.html). When the timeline finishes, control returns to the Cinemachine Brain, which chooses the Virtual Camera with the highest Priority setting.
+
+You control Virtual Cameras in Timeline with a __Cinemachine Shot Clip__. Each shot clip points to a Virtual Camera to activate then deactivate. Use a sequence of shot clips to specify the order and duration of each shot.
+
+To cut between two Virtual Cameras, place the clips next to each other. To blend between two Virtual Cameras, overlap the clips.
+
+
+
+To create a Timeline for Cinemachine:
+
+1. Create an empty GameObject in your Scene by choosing the __GameObject > Create Empty __menu item.
+
+2. Give the empty GameObject a descriptive name. For example, `IntroTimeline`.
+
+3. In your Scene, select your empty Timeline object as the focus to [create a Timeline Asset and instance](https://docs.unity3d.com/Manual/TimelineWorkflowCreatingAssetInstance.html).
+
+4. Click the padlock button to lock the TImeline window to make it easier to add and adjust tracks.
+
+5. Drag a Unity camera with a CinemachineBrain component onto the Timeline Editor, then choose __Create Cinemachine Track__ from the drop-down menu.
+
+6. [Add other tracks to the Timeline](https://docs.unity3d.com/Manual/TimelineAddingTracks.html) for controlling the subjects of your Scene. For example, add an Animation track to animate your main character.
+
+**Tip**: Delete the default track that refers to your Timeline object. This track isn’t necessary for Timeline. For example, in the Timeline editor, right-click the track for IntroTimeline and choose __Delete__.
+
+To add Cinemachine Shot Clips to a Cinemachine Track:
+
+1. In the Cinemachine Track, right-click and choose __Add Cinemachine Shot Clip__.
+
+2. Do one of the following:
+
+ * To add an existing Virtual Camera to the shot clip, drag and drop it onto the Virtual Camera property in the Cinemachine Shot component.
+
+ * To create a new Virtual Camera and add it to the shot clip, click Create in the Cinemachine Shot component.
+
+3. In the Timeline editor, adjust the order, duration, cutting, and blending of the shot clip.
+
+4. [Adjust the properties of the Virtual Camera](CinemachineVirtualCamera.html) to place it in the Scene and specify what to aim at or follow.
+
+5. To animate properties of the Virtual Camera, create an [Animation Track](https://docs.unity3d.com/Manual/TimelineAnimationTrackProperties.html) for it and animate as you would any other GameObject.
+
+6. [Organize your Timeline tracks](https://docs.unity3d.com/Manual/TimelineTrackList.html) to fine-tune your Scene.
+
--- /dev/null
+# Top-down games
+
+Cinemachine Virtual Cameras are modeled after human camera operators and how they operate real-life cameras. As such, they have a sensitivity to the up/down axis, and always try to avoid introducing roll into the camera framing. Because of this sensitivity, the Virtual Camersa avoid looking straight up or down for extended periods. They may do it in passing, but if the __Look At__ target is straight up or down for extended periods, they will not always give the desired result.
+
+**Tip:** You can deliberately roll by animating properties like __Dutch__ in a Virtual Camera.
+
+If you are building a top-down game where the cameras look straight down, the best practice is to redefine the up direction, for the purposes of the camera. You do this by setting the __World Up Override__ in the [Cinemachine Brain](CinemachineBrainProperties.html) to a GameObject whose local up points in the direction that you want the Virtual Camera’s up to normally be. This is applied to all Virtual Cameras controlled by that Brain.
+
--- /dev/null
+# Setting Virtual Camera properties
+
+The Cinemacine Virtual Camera is a component that you add to an empty GameObject. It represents a Virtual Camera in the Unity Scene.
+
+Use the __Aim__, __Body__, and __Noise__ properties to specify how the Virtual Camera animates position, rotation, and other properties. The Virtual Camera applies these settings to the Unity Camera when [Cinemachine Brain](CinemachineBrainProperties.html) or [Timeline](CinemachineTimeline.html) transfers control of the Unity camera to the Virtual Camera.
+
+At any time, each Virtual Camera may be in one of these states:
+
+* __Live__: The Virtual Camera actively controls a Unity camera that has a Cinemachine Brain. When a Cinemachine Brain blends from one Virtual Camera to the next, both Virtual Cameras are live. When the blend is complete, there is only one live Virtual Camera.
+
+* __Standby__: The Virtual Camera doesn’t control the Unity camera. However, it still follows and aims at its targets, and updates at every frame. A Virtual Camera in this state is activated and has a priority that is the same as or lower than the live Virtual Camera.
+
+* __Disabled__: The Virtual Camera doesn’t control the Unity camera and doesn’t actively follow or aim at its targets. A Virtual Camera in this state doesn’t consume processing power. To disable a Virtual Camera, deactivate its game object. The Virtual Camera is present but disabled in the Scene. However, even though the game object is deactivated, the virtual camera can still control the Unity camera if the virtual camera is participating in a blend, or if it is invoked by Timeline.
+
+
+
+### Properties
+
+| **Property:** || **Function:** |
+|:---|:---|:---|
+| __Solo__ || Toggles whether or not the Virtual Camera is temporarily live. Use this property to get immediate visual feedback in the [Game view](https://docs.unity3d.com/Manual/GameView.html) to adjust the Virtual Camera. |
+| __Game Window Guides__ || Toggles the visibility of compositional guides in the Game view. These guides are available when Look At specifies a GameObject and the Aim section uses Composer or Group Composer, or when Follow specifies a target and the Body section uses Framing Composer. This property applies to all Virtual Cameras. |
+| __Save During Play__ || Check to [apply the changes while in Play mode](CinemachineSavingDuringPlay.html). Use this feature to fine-tune a Virtual Camera without having to remember which properties to copy and paste. This property applies to all Virtual Cameras. |
+| __Priority__ || The importance of this Virtual Camera for choosing the next shot. A higher value indicates a higher priority. Cinemachine Brain chooses the next live Virtual Camera from all Virtual Cameras that are activated and have the same or higher priority as the current live Virtual Camera. This property has no effect when using a Virtual Camera with Timeline. |
+| __Follow__ || The target GameObject that the Virtual Camera moves with. The [Body properties](CinemachineVirtualCameraBody.html) use this target to update the position of the Unity camera. Keep this property empty to make the Unity camera use the position of the Virtual Camera’ transform. For example, you might choose to animate the Virtual Camera in Timeline. |
+| __Look At__ || The target GameObject to aim the Unity camera at. The [Aim properties](CinemachineVirtualCameraAim.html) use this target to update the rotation of the Unity camera. Keep this property empty to make the Unity camera use the orientation of the Virtual Camera. |
+| __Position Blending__ || Style for blending positions to and from this Virtual Camera. |
+| | _Linear_ | Standard linear position blend. |
+| | _Spherical_ | Spherical blend about the Look At position, if there is a Look At target. |
+| | _Cylindrical_ | Cylindrical blend about the Look At position, if there is a Look At target. Vertical coordinate is linearly interpolated. |
+| __Lens__ || These properties mirror their counterparts in the properties for the [Unity camera](https://docs.unity3d.com/Manual/class-Camera.html). |
+| | _Field Of View_ | The camera view in vertical degrees. For example, to specify the equivalent of a 50mm lens on a Super 35 sensor, enter a Field of View of 19.6 degrees. This property is available when the Unity camera with the Cinemachine Brain component uses a Projection of Perspective. |
+| | _Presets_ | A drop-down menu of settings for commonly-used lenses. Choose **Edit Presets** to add or edit the asset that contains a default list of lenses. |
+| | _Orthographic Size_ | When using an orthographic camera, defines the half-height of the camera view, in world coordinates. Available when the Unity camera with the Cinemachine Brain component uses a Projection of Orthographic. |
+| | _Near Clip Plane_ | The closest point relative to the camera where drawing occurs. |
+| | _Far Clip Plane_ | The furthest point relative to the camera where drawing occurs. |
+| __Dutch__ || Dutch angle. Tilts the Unity camera on the z-axis, in degrees. This property is unique to the Virtual Camera; there is no counterpart property in the Unity camera. |
+| __Extensions__ || Components that add extra behaviors to the Virtual Camera. |
+| | _Add Extension_ | Choose a new [extension](CinemachineVirtualCameraExtensions.html) to add to the Virtual Camera. |
+
+
--- /dev/null
+# Aim properties
+
+Use the Aim properties to specify how to rotate the Virtual Camera. To change the camera’s position, use the [Body properties](CinemachineVirtualCameraBody.html).
+
+
+
+* [__Composer__](CinemachineAimComposer.html): Keep the __Look At__ target in the camera frame.
+
+* [__Group Composer__](CinemachineAimGroupComposer.html): Keep multiple __Look At__ targets in the camera frame.
+
+* [__Do Nothing__](CinemachineAimDoNothing.html): Do not procedurally rotate the Virtual Camera.
+
+* [__POV__](CinemachineAimPOV.html): Rotate the Virtual Camera based on the user’s input.
+
+* [__Same As Follow Target__](CinemachineAimSameAsFollow.html): Set the camera’s rotation to the rotation of the __Follow__ target.
+
+* [__Hard Look At__](CinemachineAimHardLook.html): Keep the __Look At__ target in the center of the camera frame.
+
--- /dev/null
+# Body properties
+
+Use the Body properties to specify the algorithm that moves the Virtual Camera in the Scene. To rotate the camera, set the [Aim properties](CinemachineVirtualCameraAim.html).
+
+
+
+Cinemachine includes these algorithms for moving a Virtual Camera:
+
+* [__Transposer__](CinemachineBodyTransposer.html): moves in a fixed relationship to the __Follow__ target.
+* [__Do Nothing__](CinemachineBodyDoNothing.html): does not move the Virtual Camera.
+* [__Framing Transposer__](CinemachineBodyFramingTransposer.html): moves in a fixed screen-space relationship to the __Follow__ target.
+* [__Orbital Transposer__](CinemachineBodyOrbitalTransposer.html): moves in a variable relationship to the __Follow__ target, optionally accepting player input.
+* [__Tracked Dolly__](CinemachineBodyTrackedDolly.html): moves along a predefined path.
+* [__Hard Lock to Target__](CinemachineBodyHardLockTarget.html): uses the same position at the __Follow__ target.
--- /dev/null
+# Extensions
+
+Extensions are components that add more sophisticated behaviors to a Virtual Camera. For example, the [Collider](CinemachineCollider.html) extension moves a camera out of the way of GameObjects that obstruct the camera’s view of its target.
+
+Cinemachine includes a variety of extensions. Create your own custom extensions by deriving from the `CinemachineExtension` class.
+
+To add an extension to a Virtual Camera:
+
+1. Select your Virtual Camera in the [Scene](https://docs.unity3d.com/Manual/UsingTheSceneView.html) view or [Hierarchy](https://docs.unity3d.com/Manual/Hierarchy.html) window.
+
+2. In the [Inspector](https://docs.unity3d.com/Manual/UsingTheInspector.html), use the __Add Extension__ drop-down menu to choose the extension.
+
--- /dev/null
+# Noise properties
+
+Use Noise properties in a Virtual Camera to simulate camera shake. Cinemachine includes a __Basic Multi Channel Perlin__ component, which adds Perlin noise to the movement of the Virtual Camera. __Perlin noise__ is a technique to compute random movement with a natural behavior.
+
+
+
+The Basic Multi Channel Perlin component applies a noise profile. A noise profile is an Asset that defines the behavior of noise over time. Cinemachine includes a few noise profile assets. You can [edit these and create your own](CinemachineNoiseProfiles.html).
+
+To apply noise:
+
+1. Select your Virtual Camera in the [Scene](https://docs.unity3d.com/Manual/UsingTheSceneView.html) view or [Hierarchy](https://docs.unity3d.com/Manual/Hierarchy.html) window.
+
+2. In the [Inspector](https://docs.unity3d.com/Manual/UsingTheInspector.html), use the __Noise__ drop-down menu to choose __Basic Multi Channel Perlin__.
+
+3. In __Noise Profile__, choose an existing profile asset or [create your own profile](CinemachineNoiseProfiles.html).
+
+4. Use __Amplitude Gain__ and __Frequency Gain__ to fine-tune the noise.
+
+## Properties
+
+| **Property:** | **Function:** |
+|:---|:---|
+| __Noise Profile__ | The noise profile asset to use.|
+| __Amplitude Gain__ | Gain to apply to the amplitudes defined in the noise profile. Use 1 to use the amplitudes defined in the noise profile. Setting this to 0 mutes the noise. Tip: Animate this property to ramp the noise effect up and down.|
+| __Frequency Gain__ | Factor to apply to the frequencies defined in the noise profile. Use 1 to use the frequencies defined in the noise profile. Use larger values to shake the camera more rapidly. Tip: Animate this property to ramp the noise effect up and down. |
+
+
+
--- /dev/null
+* [Cinemachine Documentation](index)
+ * [Cinemachine overview](CinemachineOverview)
+ * [Getting started](CinemachineGettingStarted)
+ * [Setting up Virtual Cameras](CinemachineSetUpVCam)
+ * [Saving in Play Mode](CinemachineSavingDuringPlay)
+ * [Setting Virtual Camera properties](CinemachineVirtualCamera)
+ * [Body properties](CinemachineVirtualCameraBody)
+ * [Transposer](CinemachineBodyTransposer)
+ * [Do Nothing](CinemachineBodyDoNothing)
+ * [Framing Transposer](CinemachineBodyFramingTransposer)
+ * [Orbital Transposer](CinemachineBodyOrbitalTransposer)
+ * [Tracked Dolly](CinemachineBodyTrackedDolly)
+ * [Hard Lock to Target](CinemachineBodyHardLockTarget)
+ * [Aim properties](CinemachineVirtualCameraAim)
+ * [Composer](CinemachineAimComposer)
+ * [Group Composer](CinemachineAimGroupComposer)
+ * [Do Nothing](CinemachineAimDoNothing)
+ * [POV](CinemachineAimPOV)
+ * [Same As Follow Target](CinemachineAimSameAsFollow)
+ * [Hard Look At](CinemachineAimHardLook)
+ * [Noise properties](CinemachineVirtualCameraNoise)
+ * [Extensions](CinemachineVirtualCameraExtensions)
+ * [Working with noise profiles](CinemachineNoiseProfiles)
+ * [Setting Cinemachine Brain properties](CinemachineBrainProperties)
+ * [Blending between Virtual Cameras](CinemachineBlending)
+ * [Cinemachine and Timeline](CinemachineTimeline)
+ * [Storyboard](CinemachineStoryboard)
+ * [Cinemachine and Postprocessing](CinemachinePostProcessing)
+ * [Managing and grouping Virtual Cameras](CinemachineManagerCameras)
+ * [Cinemachine Free Look](CinemachineFreeLook)
+ * [Cinemachine Mixing Camera](CinemachineMixingCamera)
+ * [Cinemachine Blend List Camera](CinemachineBlendListCamera)
+ * [Cinemachine Clear Shot](CinemachineClearShot)
+ * [Cinemachine State-Driven camera](CinemachineStateDrivenCamera)
+ * [Avoiding collisions and evaluating shots](CinemachineColliderConfiner)
+ * [Cinemachine Collider](CinemachineCollider)
+ * [Cinemachine Confiner](CinemachineConfiner)
+ * [Cinemachine Target Group](CinemachineTargetGroup)
+ * [Cinemachine and 2D graphics](Cinemachine2D)
+ * [Cinemachine and top-down games](CinemachineTopDown)
+ * [Using multiple Unity cameras](CinemachineMultipleCameras)
+ * [Cinemachine External Camera](CinemachineExternalCamera)
+ * [Cinemachine Follow Zoom](CinemachineFollowZoom)
+ * [Using dolly paths](CinemachineDolly)
+ * [Cinemachine Path](CinemachinePath)
+ * [Cinemachine Smooth Path](CinemachineSmoothPath)
+ * [Cinemachine Dolly Cart](CinemachineDollyCart)
+ * [Cinemachine Impulse](CinemachineImpulse)
+ * [Cinemachine Impulse Sources](CinemachineImpulseSourceOverview)
+ * [Cinemachine Collision Impulse Source](CinemachineCollisionImpulseSource)
+ * [Cinemachine Impulse Source](CinemachineImpulseSource)
+ * [Raw Vibration Signals](CinemachineImpulseRawSignal)
+ * [Using Noise Profiles](CinemachineImpulseNoiseProfiles)
+ * [Using Fixed Signals](CinemachineImpulseFixedSignals)
+ * [Cinemachine Impulse Listener](CinemachineImpulseListener)
+ * [Filtering impulses](CinemachineImpulseFiltering)
+ * [Document Revision History](CinemachineDocRevisionHistory)
\ No newline at end of file
--- /dev/null
+# Cinemachine
+
+
+
+Cinemachine is a suite of modules for operating the Unity camera. Cinemachine solves the complex mathematics and logic of tracking targets, composing, blending, and cutting between shots. It is designed to significantly reduce the number of time-consuming manual manipulations and script revisions that take place during development.
+
+The procedural nature of these modules makes Cinemachine bug-resistant. When you make adjustments—for example, change an animation, vehicle speed, terrain, or other GameObjects in your Scene—Cinemachine dynamically adjusts its behavior to make the best shot. There is no need, for example, to re-write camera scripts just because a character turns left instead of right.
+
+Cinemachine works in real time across all genres including FPS, third person, 2D, side-scroller, top down, and RTS. It supports as many shots in your Scene as you need. Its modular system lets you compose sophisticated behaviors.
+
+Cinemachine works well with other Unity tools, acting as a powerful complement to Timeline, animation, and post-processing assets. Create your own [extensions](CinemachineVirtualCameraExtensions) or integrate it with your custom camera scripts.
+
+## Requirements
+
+Cinemachine has no external dependencies. Just install it and start using it. If you are also using the Post Processing Stack (version 2), then you need to install the Cinemachine PostProcessing Adapter Package from the Cinemachine menu. This installs code that connects the two packages and enables virtual cameras to have Post Processing profiles.
+
+This Cinemachine version 2.2 is compatible with the following versions of the Unity Editor:
+
+* 2017.1 and later
--- /dev/null
+
+### AxisState
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Axis state for defining how to react to player input. The settings here control the responsiveness of the axis to player input.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **Value** | Single | The current value of the axis. |
+| **m_MaxSpeed** | Single | The maximum speed of this axis in units/second. |
+| **m_AccelTime** | Single | The amount of time in seconds it takes to accelerate to MaxSpeed with the supplied Axis at its maximum value. |
+| **m_DecelTime** | Single | The amount of time in seconds it takes to decelerate the axis to zero if the supplied axis is in a neutral position. |
+| **m_InputAxisName** | String | The name of this axis as specified in Unity Input manager. Setting to an empty string will disable the automatic updating of this axis. |
+| **m_InputAxisValue** | Single | The value of the input axis. A value of 0 means no input. You can drive this directly from a custom input system, or you can set the Axis Name and have the value driven by the internal Input Manager. |
+| **m_InvertInput** | Boolean | If checked, then the raw value of the input axis will be inverted before it is used. |
+| **m_MinValue** | Single | The minimum value for the axis. |
+| **m_MaxValue** | Single | The maximum value for the axis. |
+| **m_Wrap** | Boolean | If checked, then the axis will wrap around at the min/max values, forming a loop. |
+
+
+#### Methods
+
+``Void Validate()``
+
+Call from OnValidate: Make sure the fields are sensible.
+
+``Boolean Update(Single deltaTime)``
+
+Updates the state of this axis based on the axis defined by AxisState.m_AxisName.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **deltaTime** | Single | Delta time in seconds. |
+
+_Returns:_ Returns true if this axis' input was non-zero this Update, flase otherwise.
+
+
+### AxisState.Recentering
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Helper for automatic axis recentering.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_enabled** | Boolean | If checked, will enable automatic recentering of the axis. If unchecked, recenting is disabled. |
+| **m_WaitTime** | Single | If no user input has been detected on the axis, the axis will wait this long in seconds before recentering. |
+| **m_RecenteringTime** | Single | Maximum angular speed of recentering. Will accelerate into and decelerate out of this. |
+
+
+#### Methods
+
+``Void Validate()``
+
+Call this from OnValidate().
+
+``Void CancelRecentering()``
+
+Cancel any recenetering in progress.
+
+``Void DoRecentering(AxisState& axis, Single deltaTime, Single recenterTarget)``
+
+Bring the axis back to the cenetered state.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **axis** | AxisState& | |
+| **deltaTime** | Single | |
+| **recenterTarget** | Single | |
+
+
+
+### CinemachineBasicMultiChannelPerlin
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+As a part of the Cinemachine Pipeline implementing the Noise stage, this component adds Perlin Noise to the Camera state, in the Correction channel of the CameraState.
+
+The noise is created by using a predefined noise profile asset. This defines the shape of the noise over time. You can scale this in amplitude or in time, to produce a large family of different noises using the same profile.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **IsValid** | Boolean | _[Get]_ True if the component is valid, i.e. it has a noise definition and is enabled. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Noise stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_NoiseProfile** | NoiseSettings | The asset containing the Noise Profile. Define the frequencies and amplitudes there to make a characteristic noise profile. Make your own or just use one of the many presets. |
+| **m_AmplitudeGain** | Single | Gain to apply to the amplitudes defined in the NoiseSettings asset. 1 is normal. Setting this to 0 completely mutes the noise. |
+| **m_FrequencyGain** | Single | Scale factor to apply to the frequencies defined in the NoiseSettings asset. 1 is normal. Larger magnitudes will make the noise shake more rapidly. |
+
+
+#### Methods
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Applies noise to the Correction channel of the CameraState if the delta time is greater than 0. Otherwise, does nothing.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | How much to advance the perlin noise generator. Noise is only applied if this value is greater than or equal to 0. |
+
+
+
+### CinemachineBlendDefinition
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Definition of a Camera blend. This struct holds the information necessary to generate a suitable AnimationCurve for a Cinemachine Blend.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **BlendCurve** | AnimationCurve | _[Get]_ A normalized AnimationCurve specifying the interpolation curve for this camera blend. Y-axis values must be in range [0,1] (internally clamped within Blender) and time must be in range of [0, 1]. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Style** | Style | Shape of the blend curve.<br>_Possible Values:_<br>- **Cut**: Zero-length blend.<br>- **EaseInOut**: S-shaped curve, giving a gentle and smooth transition.<br>- **EaseIn**: Linear out of the outgoing shot, and easy into the incoming.<br>- **EaseOut**: Easy out of the outgoing shot, and linear into the incoming.<br>- **HardIn**: Easy out of the outgoing, and hard into the incoming.<br>- **HardOut**: Hard out of the outgoing, and easy into the incoming.<br>- **Linear**: Linear blend. Mechanical-looking.<br>- **Custom**: Custom blend curve.<br> |
+| **m_Time** | Single | Duration of the blend, in seconds. |
+| **m_CustomCurve** | AnimationCurve | A user-defined AnimationCurve, used only if style is Custom. Curve MUST be normalized, i.e. time range [0...1], value range [0...1]. |
+
+
+
+### CinemachineBlenderSettings
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ ScriptableObject
+
+
+Asset that defines the rules for blending between Virtual Cameras.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_CustomBlends** | CustomBlend[] | The array containing explicitly defined blends between two Virtual Cameras. |
+
+
+#### Methods
+
+``AnimationCurve GetBlendCurveForVirtualCameras(String fromCameraName, String toCameraName, AnimationCurve defaultCurve)``
+
+Attempts to find a blend curve which matches the to and from cameras as specified. If no match is found, the function returns either the default blend for this Blender or NULL depending on the state of returnDefaultOnNoMatch.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **fromCameraName** | String | The game object name of the from camera. |
+| **toCameraName** | String | The game object name of the to camera. |
+| **defaultCurve** | AnimationCurve | Curve to return if no curve found. Can be NULL. |
+
+
+
+### CinemachineBlenderSettings.CustomBlend
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Container specifying how two specific Cinemachine Virtual Cameras blend together.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_From** | String | When blending from this camera. |
+| **m_To** | String | When blending to this camera. |
+| **m_Blend** | CinemachineBlendDefinition | Blend curve definition. |
+
+
+
+### CinemachineBlendListCamera
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineVirtualCameraBase
+
+_Implements:_ ICinemachineCamera
+
+
+This is a virtual camera "manager" that owns and manages a collection of child Virtual Cameras. When the camera goes live, these child vcams are enabled, one after another, holding each camera for a designated time. Blends between cameras are specified. The last camera is held indefinitely.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **Description** | String | _[Get]_ Gets a brief debug description of this virtual camera, for use when displayiong debug info. |
+| **LiveChild** | ICinemachineCamera | _[Get,Set]_ Get the current "best" child virtual camera, that would be chosen if the State Driven Camera were active. |
+| **LiveChildOrSelf** | ICinemachineCamera | _[Get]_ Return the live child. |
+| **State** | CameraState | _[Get]_ The State of the current live child. |
+| **LookAt** | Transform | _[Get,Set]_ Get the current LookAt target. Returns parent's LookAt if parent is non-null and no specific LookAt defined for this camera. |
+| **Follow** | Transform | _[Get,Set]_ Get the current Follow target. Returns parent's Follow if parent is non-null and no specific Follow defined for this camera. |
+| **ChildCameras** | CinemachineVirtualCameraBase[] | _[Get]_ The list of child cameras. These are just the immediate children in the hierarchy. |
+| **IsBlending** | Boolean | _[Get]_ Is there a blend in progress? |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_LookAt** | Transform | Default object for the camera children to look at (the aim target), if not specified in a child camera. May be empty if all of the children define targets of their own. |
+| **m_Follow** | Transform | Default object for the camera children wants to move with (the body target), if not specified in a child camera. May be empty if all of the children define targets of their own. |
+| **m_ShowDebugText** | Boolean | When enabled, the current child camera and blend will be indicated in the game window, for debugging. |
+| **m_EnableAllChildCameras** | Boolean | Force all child cameras to be enabled. This is useful if animating them in Timeline, but consumes extra resources. |
+| **m_ChildCameras** | CinemachineVirtualCameraBase[] | Internal API for the editor. Do not use this field. |
+| **m_Instructions** | Instruction[] | The set of instructions for enabling child cameras. |
+| **CinemachineGUIDebuggerCallback** | Action | This is deprecated. It is here to support the soon-to-be-removed Cinemachine Debugger in the Editor. |
+| **m_ExcludedPropertiesInInspector** | String[] | Inspector control - Use for hiding sections of the Inspector UI. |
+| **m_LockStageInInspector** | Stage[] | Inspector control - Use for enabling sections of the Inspector UI. |
+| **m_Priority** | Int32 | The priority will determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority. |
+
+
+#### Methods
+
+``virtual Boolean IsLiveChild(ICinemachineCamera vcam)``
+
+Check whether the vcam a live child of this camera.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | ICinemachineCamera | The Virtual Camera to check. |
+
+_Returns:_ True if the vcam is currently actively influencing the state of this vcam.
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the vcam that a target got warped, so that the vcam can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``virtual Void OnTransitionFromCamera(ICinemachineCamera fromCam, Vector3 worldUp, Single deltaTime)``
+
+Notification that this virtual camera is going live.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **fromCam** | ICinemachineCamera | The camera being deactivated. May be null. |
+| **worldUp** | Vector3 | Default world Up, set by the CinemachineBrain. |
+| **deltaTime** | Single | Delta time for time-based effects (ignore if less than or equal to 0). |
+
+``virtual Void InternalUpdateCameraState(Vector3 worldUp, Single deltaTime)``
+
+Called by CinemachineCore at designated update time so the vcam can position itself and track its targets. This implementation updates all the children, chooses the best one, and implements any required blending.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | Default world Up, set by the CinemachineBrain. |
+| **deltaTime** | Single | Delta time for time-based effects (ignore if less than or equal to 0). |
+
+``protected virtual Void OnEnable()``
+
+Makes sure the internal child cache is up to date.
+
+``Void OnTransformChildrenChanged()``
+
+Makes sure the internal child cache is up to date.
+
+``protected virtual Void OnGUI()``
+
+Displays the current active camera on the game screen, if requested.
+
+``Void ValidateInstructions()``
+
+Internal API for the inspector editor.
+
+
+
+### CinemachineBrain
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ MonoBehaviour
+
+
+CinemachineBrain is the link between the Unity Camera and the Cinemachine Virtual Cameras in the scene. It monitors the priority stack to choose the current Virtual Camera, and blend with another if necessary. Finally and most importantly, it applies the Virtual Camera state to the attached Unity Camera.
+
+The CinemachineBrain is also the place where rules for blending between virtual cameras are defined. Camera blending is an interpolation over time of one virtual camera position and state to another. If you think of virtual cameras as cameramen, then blending is a little like one cameraman smoothly passing the camera to another cameraman. You can specify the time over which to blend, as well as the blend curve shape. Note that a camera cut is just a zero-time blend.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **OutputCamera** | Camera | _[Get]_ Get the Unity Camera that is attached to this GameObject. This is the camera that will be controlled by the brain. |
+| **PostProcessingComponent** | Component | _[Get,Set]_ Internal support for opaque post-processing module. |
+| **SoloCamera** | ICinemachineCamera | _(static)_ _[Get,Set]_ API for the Unity Editor. Show this camera no matter what. This is static, and so affects all Cinemachine brains. |
+| **DefaultWorldUp** | Vector3 | _[Get]_ Get the default world up for the virtual cameras. |
+| **IsBlending** | Boolean | _[Get]_ Is there a blend in progress? |
+| **ActiveBlend** | CinemachineBlend | _[Get]_ Get the current blend in progress. Returns null if none. |
+| **ActiveVirtualCamera** | ICinemachineCamera | _[Get]_ Get the current active virtual camera. |
+| **CurrentCameraState** | CameraState | _[Get]_ The current state applied to the unity camera (may be the result of a blend). |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_ShowDebugText** | Boolean | When enabled, the current camera and blend will be indicated in the game window, for debugging. |
+| **m_ShowCameraFrustum** | Boolean | When enabled, the camera's frustum will be shown at all times in the scene view. |
+| **m_IgnoreTimeScale** | Boolean | When enabled, the cameras will always respond in real-time to user input and damping, even if the game is running in slow motion. |
+| **m_WorldUpOverride** | Transform | If set, this object's Y axis will define the worldspace Up vector for all the virtual cameras. This is useful for instance in top-down game environments. If not set, Up is worldspace Y. Setting this appropriately is important, because Virtual Cameras don't like looking straight up or straight down. |
+| **m_UpdateMethod** | UpdateMethod | Use FixedUpdate if all your targets are animated during FixedUpdate (e.g. RigidBodies), LateUpdate if all your targets are animated during the normal Update loop, and SmartUpdate if you want Cinemachine to do the appropriate thing on a per-target basis. SmartUpdate is the recommended setting.<br>_Possible Values:_<br>- **FixedUpdate**: Virtual cameras are updated in sync with the Physics module, in FixedUpdate.<br>- **LateUpdate**: Virtual cameras are updated in MonoBehaviour LateUpdate.<br>- **SmartUpdate**: Virtual cameras are updated according to how the target is updated.<br> |
+| **m_DefaultBlend** | CinemachineBlendDefinition | The blend that is used in cases where you haven't explicitly defined a blend between two Virtual Cameras. |
+| **m_CustomBlends** | CinemachineBlenderSettings | This is the asset that contains custom settings for blends between specific virtual cameras in your scene. |
+| **m_CameraCutEvent** | BrainEvent | This event will fire whenever a virtual camera goes live and there is no blend. |
+| **m_CameraActivatedEvent** | VcamEvent | This event will fire whenever a virtual camera goes live. If a blend is involved, then the event will fire on the first frame of the blend. |
+
+
+#### Methods
+
+``static Color GetSoloGUIColor()``
+
+API for the Unity Editor.
+
+_Returns:_ Color used to indicate that a camera is in Solo mode.
+``Boolean IsLive(ICinemachineCamera vcam)``
+
+True if the ICinemachineCamera the current active camera, or part of a current blend, either directly or indirectly because its parents are live.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | ICinemachineCamera | The camera to test whether it is live. |
+
+_Returns:_ True if the camera is live (directly or indirectly) or part of a blend in progress.
+
+
+### CinemachineClearShot
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineVirtualCameraBase
+
+_Implements:_ ICinemachineCamera
+
+
+Cinemachine ClearShot is a "manager camera" that owns and manages a set of Virtual Camera gameObject children. When Live, the ClearShot will check the children, and choose the one with the best quality shot and make it Live.
+
+This can be a very powerful tool. If the child cameras have CinemachineCollider extensions, they will analyze the scene for target obstructions, optimal target distance, and other items, and report their assessment of shot quality back to the ClearShot parent, who will then choose the best one. You can use this to set up complex multi-camera coverage of a scene, and be assured that a clear shot of the target will always be available.
+
+If multiple child cameras have the same shot quality, the one with the highest priority will be chosen.
+
+You can also define custom blends between the ClearShot children.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **Description** | String | _[Get]_ Gets a brief debug description of this virtual camera, for use when displayiong debug info. |
+| **LiveChild** | ICinemachineCamera | _[Get,Set]_ Get the current "best" child virtual camera, that would be chosen if the ClearShot camera were active. |
+| **State** | CameraState | _[Get]_ The CameraState of the currently live child. |
+| **LiveChildOrSelf** | ICinemachineCamera | _[Get]_ Return the live child. |
+| **LookAt** | Transform | _[Get,Set]_ Get the current LookAt target. Returns parent's LookAt if parent is non-null and no specific LookAt defined for this camera. |
+| **Follow** | Transform | _[Get,Set]_ Get the current Follow target. Returns parent's Follow if parent is non-null and no specific Follow defined for this camera. |
+| **IsBlending** | Boolean | _[Get]_ Is there a blend in progress? |
+| **ChildCameras** | CinemachineVirtualCameraBase[] | _[Get]_ The list of child cameras. These are just the immediate children in the hierarchy. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_LookAt** | Transform | Default object for the camera children to look at (the aim target), if not specified in a child camera. May be empty if all children specify targets of their own. |
+| **m_Follow** | Transform | Default object for the camera children wants to move with (the body target), if not specified in a child camera. May be empty if all children specify targets of their own. |
+| **m_ShowDebugText** | Boolean | When enabled, the current child camera and blend will be indicated in the game window, for debugging. |
+| **m_ChildCameras** | CinemachineVirtualCameraBase[] | Internal API for the editor. Do not use this filed. |
+| **m_ActivateAfter** | Single | Wait this many seconds before activating a new child camera. |
+| **m_MinDuration** | Single | An active camera must be active for at least this many seconds. |
+| **m_RandomizeChoice** | Boolean | If checked, camera choice will be randomized if multiple cameras are equally desirable. Otherwise, child list order and child camera priority will be used. |
+| **m_DefaultBlend** | CinemachineBlendDefinition | The blend which is used if you don't explicitly define a blend between two Virtual Cameras. |
+| **m_CustomBlends** | CinemachineBlenderSettings | This is the asset which contains custom settings for specific blends. |
+| **CinemachineGUIDebuggerCallback** | Action | This is deprecated. It is here to support the soon-to-be-removed Cinemachine Debugger in the Editor. |
+| **m_ExcludedPropertiesInInspector** | String[] | Inspector control - Use for hiding sections of the Inspector UI. |
+| **m_LockStageInInspector** | Stage[] | Inspector control - Use for enabling sections of the Inspector UI. |
+| **m_Priority** | Int32 | The priority will determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority. |
+
+
+#### Methods
+
+``virtual Boolean IsLiveChild(ICinemachineCamera vcam)``
+
+Check whether the vcam a live child of this camera.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | ICinemachineCamera | The Virtual Camera to check. |
+
+_Returns:_ True if the vcam is currently actively influencing the state of this vcam.
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the vcam that a target got warped, so that the vcam can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``virtual Void InternalUpdateCameraState(Vector3 worldUp, Single deltaTime)``
+
+Internal use only. Called by CinemachineCore at designated update time so the vcam can position itself and track its targets. This implementation updates all the children, chooses the best one, and implements any required blending.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | Default world Up, set by the CinemachineBrain. |
+| **deltaTime** | Single | Delta time for time-based effects (ignore if less than 0). |
+
+``protected virtual Void OnEnable()``
+
+Makes sure the internal child cache is up to date.
+
+``Void OnTransformChildrenChanged()``
+
+Makes sure the internal child cache is up to date.
+
+``protected virtual Void OnGUI()``
+
+Displays the current active camera on the game screen, if requested.
+
+``Void ResetRandomization()``
+
+If RandomizeChoice is enabled, call this to re-randomize the children next frame. This is useful if you want to freshen up the shot.
+
+``virtual Void OnTransitionFromCamera(ICinemachineCamera fromCam, Vector3 worldUp, Single deltaTime)``
+
+Notification that this virtual camera is going live. This implementation resets the child randomization.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **fromCam** | ICinemachineCamera | The camera being deactivated. May be null. |
+| **worldUp** | Vector3 | Default world Up, set by the CinemachineBrain. |
+| **deltaTime** | Single | Delta time for time-based effects (ignore if less than or equal to 0). |
+
+
+
+### CinemachineCollider
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineExtension
+
+
+An add-on module for Cinemachine Virtual Camera that post-processes the final position of the virtual camera. Based on the supplied settings, the Collider will attempt to preserve the line of sight with the LookAt target of the virtual camera by moving away from objects that will obstruct the view.
+
+Additionally, the Collider can be used to assess the shot quality and report this as a field in the camera State.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **DebugPaths** | List`1 | _[Get]_ Inspector API for debugging collision resolution path. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_CollideAgainst** | LayerMask | The Unity layer mask against which the collider will raycast. |
+| **m_IgnoreTag** | String | Obstacles with this tag will be ignored. It is a good idea to set this field to the target's tag. |
+| **m_MinimumDistanceFromTarget** | Single | Obstacles closer to the target than this will be ignored. |
+| **m_AvoidObstacles** | Boolean | When enabled, will attempt to resolve situations where the line of sight to the target is blocked by an obstacle. |
+| **m_DistanceLimit** | Single | The maximum raycast distance when checking if the line of sight to this camera's target is clear. If the setting is 0 or less, the current actual distance to target will be used. |
+| **m_CameraRadius** | Single | Camera will try to maintain this distance from any obstacle. Try to keep this value small. Increase it if you are seeing inside obstacles due to a large FOV on the camera. |
+| **m_Strategy** | ResolutionStrategy | The way in which the Collider will attempt to preserve sight of the target.<br>_Possible Values:_<br>- **PullCameraForward**<br>- **PreserveCameraHeight**<br>- **PreserveCameraDistance**<br> |
+| **m_MaximumEffort** | Int32 | Upper limit on how many obstacle hits to process. Higher numbers may impact performance. In most environments, 4 is enough. |
+| **m_Damping** | Single | The gradualness of collision resolution. Higher numbers will move the camera more gradually away from obstructions. |
+| **m_OptimalTargetDistance** | Single | If greater than zero, a higher score will be given to shots when the target is closer to this distance. Set this to zero to disable this feature. |
+
+
+#### Methods
+
+``Boolean IsTargetObscured(ICinemachineCamera vcam)``
+
+See wheter an object is blocking the camera's view of the target.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | ICinemachineCamera | The virtual camera in question. This might be different from the virtual camera that owns the collider, in the event that the camera has children. |
+
+_Returns:_ True if something is blocking the view.
+``Boolean CameraWasDisplaced(CinemachineVirtualCameraBase vcam)``
+
+See whether the virtual camera has been moved nby the collider.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | CinemachineVirtualCameraBase | The virtual camera in question. This might be different from the virtual camera that owns the collider, in the event that the camera has children. |
+
+_Returns:_ True if the virtual camera has been displaced due to collision or target obstruction.
+``protected virtual Void OnDestroy()``
+
+Cleanup.
+
+``protected virtual Void PostPipelineStageCallback(CinemachineVirtualCameraBase vcam, Stage stage, CameraState& state, Single deltaTime)``
+
+Callcack to to the collision resolution and shot evaluation.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | CinemachineVirtualCameraBase | |
+| **stage** | Stage | |
+| **state** | CameraState& | |
+| **deltaTime** | Single | |
+
+
+
+### CinemachineComposer
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+This is a CinemachineComponent in the Aim section of the component pipeline. Its job is to aim the camera at the vcam's LookAt target object, with configurable offsets, damping, and composition rules.
+
+The composer does not change the camera's position. It will only pan and tilt the camera where it is, in order to get the desired framing. To move the camera, you have to use the virtual camera's Body section.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **IsValid** | Boolean | _[Get]_ True if component is enabled and has a LookAt defined. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Aim stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+| **TrackedPoint** | Vector3 | _[Get]_ Internal API for inspector. |
+| **SoftGuideRect** | Rect | _[Get,Set]_ Internal API for the inspector editor. |
+| **HardGuideRect** | Rect | _[Get,Set]_ Internal API for the inspector editor. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **OnGUICallback** | Action | Used by the Inspector Editor to display on-screen guides. |
+| **m_TrackedObjectOffset** | Vector3 | Target offset from the target object's center in target-local space. Use this to fine-tune the tracking target position when the desired area is not the tracked object's center. |
+| **m_LookaheadTime** | Single | This setting will instruct the composer to adjust its target offset based on the motion of the target. The composer will look at a point where it estimates the target will be this many seconds into the future. Note that this setting is sensitive to noisy animation, and can amplify the noise, resulting in undesirable camera jitter. If the camera jitters unacceptably when the target is in motion, turn down this setting, or animate the target more smoothly. |
+| **m_LookaheadSmoothing** | Single | Controls the smoothness of the lookahead algorithm. Larger values smooth out jittery predictions and also increase prediction lag. |
+| **m_LookaheadIgnoreY** | Boolean | If checked, movement along the Y axis will be ignored for lookahead calculations. |
+| **m_HorizontalDamping** | Single | How aggressively the camera tries to follow the target in the screen-horizontal direction. Small numbers are more responsive, rapidly orienting the camera to keep the target in the dead zone. Larger numbers give a more heavy slowly responding camera. Using different vertical and horizontal settings can yield a wide range of camera behaviors. |
+| **m_VerticalDamping** | Single | How aggressively the camera tries to follow the target in the screen-vertical direction. Small numbers are more responsive, rapidly orienting the camera to keep the target in the dead zone. Larger numbers give a more heavy slowly responding camera. Using different vertical and horizontal settings can yield a wide range of camera behaviors. |
+| **m_ScreenX** | Single | Horizontal screen position for target. The camera will rotate to position the tracked object here. |
+| **m_ScreenY** | Single | Vertical screen position for target, The camera will rotate to position the tracked object here. |
+| **m_DeadZoneWidth** | Single | Camera will not rotate horizontally if the target is within this range of the position. |
+| **m_DeadZoneHeight** | Single | Camera will not rotate vertically if the target is within this range of the position. |
+| **m_SoftZoneWidth** | Single | When target is within this region, camera will gradually rotate horizontally to re-align towards the desired position, depending on the damping speed. |
+| **m_SoftZoneHeight** | Single | When target is within this region, camera will gradually rotate vertically to re-align towards the desired position, depending on the damping speed. |
+| **m_BiasX** | Single | A non-zero bias will move the target position horizontally away from the center of the soft zone. |
+| **m_BiasY** | Single | A non-zero bias will move the target position vertically away from the center of the soft zone. |
+
+
+#### Methods
+
+``protected virtual Vector3 GetLookAtPointAndSetTrackedPoint(Vector3 lookAt)``
+
+Apply the target offsets to the target location. Also set the TrackedPoint property, taking lookahead into account.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **lookAt** | Vector3 | The unoffset LookAt point. |
+
+_Returns:_ The LookAt point with the offset applied.
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the us that a target got warped, so that we can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``virtual Void PrePipelineMutateCameraState(CameraState& curState)``
+
+
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | |
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Applies the composer rules and orients the camera accordingly.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for calculating damping. If less than zero, then target will snap to the center of the dead zone. |
+
+
+
+### CinemachineConfiner
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineExtension
+
+
+An add-on module for Cinemachine Virtual Camera that post-processes the final position of the virtual camera. It will confine the virtual camera's position to the volume specified in the Bounding Volume field.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **IsValid** | Boolean | _[Get]_ Check if the bounding volume is defined. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_ConfineMode** | Mode | The confiner can operate using a 2D bounding shape or a 3D bounding volume.<br>_Possible Values:_<br>- **Confine2D**<br>- **Confine3D**<br> |
+| **m_BoundingVolume** | Collider | The volume within which the camera is to be contained. |
+| **m_BoundingShape2D** | Collider2D | The 2D shape within which the camera is to be contained. |
+| **m_ConfineScreenEdges** | Boolean | If camera is orthographic, screen edges will be confined to the volume. If not checked, then only the camera center will be confined. |
+| **m_Damping** | Single | How gradually to return the camera to the bounding volume if it goes beyond the borders. Higher numbers are more gradual. |
+
+
+#### Methods
+
+``Boolean CameraWasDisplaced(CinemachineVirtualCameraBase vcam)``
+
+See whether the virtual camera has been moved by the confiner.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | CinemachineVirtualCameraBase | The virtual camera in question. This might be different from the virtual camera that owns the confiner, in the event that the camera has children. |
+
+_Returns:_ True if the virtual camera has been repositioned.
+``protected virtual Void PostPipelineStageCallback(CinemachineVirtualCameraBase vcam, Stage stage, CameraState& state, Single deltaTime)``
+
+Callback to to the camera confining.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | CinemachineVirtualCameraBase | |
+| **stage** | Stage | |
+| **state** | CameraState& | |
+| **deltaTime** | Single | |
+
+``Void InvalidatePathCache()``
+
+Call this if the bounding shape's points change at runtime.
+
+
+
+### CinemachineDollyCart
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ MonoBehaviour
+
+
+This is a very simple behaviour that constrains its transform to a CinemachinePath. It can be used to animate any objects along a path, or as a Follow target for Cinemachine Virtual Cameras.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Path** | CinemachinePathBase | The path to follow. |
+| **m_UpdateMethod** | UpdateMethod | When to move the cart, if Velocity is non-zero.<br>_Possible Values:_<br>- **Update**<br>- **FixedUpdate**<br> |
+| **m_PositionUnits** | PositionUnits | How to interpret the Path Position. If set to Path Units, values are as follows: 0 represents the first waypoint on the path, 1 is the second, and so on. Values in-between are points on the path in between the waypoints. If set to Distance, then Path Position represents distance along the path.<br>_Possible Values:_<br>- **PathUnits**<br>- **Distance**<br>- **Normalized**<br> |
+| **m_Speed** | Single | Move the cart with this speed along the path. The value is interpreted according to the Position Units setting. |
+| **m_Position** | Single | The position along the path at which the cart will be placed. This can be animated directly or, if the velocity is non-zero, will be updated automatically. The value is interpreted according to the Position Units setting. |
+
+
+
+### CinemachineExternalCamera
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineVirtualCameraBase
+
+_Implements:_ ICinemachineCamera
+
+
+This component will expose a non-cinemachine camera to the cinemachine system, allowing it to participate in blends. Just add it as a component alongside an existing Unity Camera component.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **State** | CameraState | _[Get]_ Get the CameraState, as we are able to construct one from the Unity Camera. |
+| **LookAt** | Transform | _[Get,Set]_ The object that the camera is looking at. |
+| **Follow** | Transform | _[Get,Set]_ This vcam defines no targets. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_LookAt** | Transform | The object that the camera is looking at. Setting this will improve the quality of the blends to and from this camera. |
+| **m_PositionBlending** | PositionBlendMethod | Hint for blending positions to and from this virtual camera.<br>_Possible Values:_<br>- **Linear**<br>- **Spherical**<br>- **Cylindrical**<br> |
+| **CinemachineGUIDebuggerCallback** | Action | This is deprecated. It is here to support the soon-to-be-removed Cinemachine Debugger in the Editor. |
+| **m_ExcludedPropertiesInInspector** | String[] | Inspector control - Use for hiding sections of the Inspector UI. |
+| **m_LockStageInInspector** | Stage[] | Inspector control - Use for enabling sections of the Inspector UI. |
+| **m_Priority** | Int32 | The priority will determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority. |
+
+
+#### Methods
+
+``virtual Void InternalUpdateCameraState(Vector3 worldUp, Single deltaTime)``
+
+Internal use only. Do not call this method.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | |
+| **deltaTime** | Single | |
+
+
+
+### CinemachineFollowZoom
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineExtension
+
+
+An add-on module for Cinemachine Virtual Camera that adjusts the FOV of the lens to keep the target object at a constant size on the screen, regardless of camera and target position.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Width** | Single | The shot width to maintain, in world units, at target distance. |
+| **m_Damping** | Single | Increase this value to soften the aggressiveness of the follow-zoom. Small numbers are more responsive, larger numbers give a more heavy slowly responding camera. |
+| **m_MinFOV** | Single | Lower limit for the FOV that this behaviour will generate. |
+| **m_MaxFOV** | Single | Upper limit for the FOV that this behaviour will generate. |
+
+
+#### Methods
+
+``protected virtual Void PostPipelineStageCallback(CinemachineVirtualCameraBase vcam, Stage stage, CameraState& state, Single deltaTime)``
+
+Callback to preform the zoom adjustment.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | CinemachineVirtualCameraBase | |
+| **stage** | Stage | |
+| **state** | CameraState& | |
+| **deltaTime** | Single | |
+
+
+
+### CinemachineFramingTransposer
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+This is a Cinemachine Component in the Body section of the component pipeline. Its job is to position the camera in a fixed screen-space relationship to the vcam's Follow target object, with offsets and damping.
+
+The camera will be first moved along the camera Z axis until the Follow target is at the desired distance from the camera's X-Y plane. The camera will then be moved in its XY plane until the Follow target is at the desired point on the camera's screen.
+
+The FramingTansposer will only change the camera's position in space. It will not re-orient or otherwise aim the camera.
+
+For this component to work properly, the vcam's LookAt target must be null. The Follow target will define what the camera is looking at.
+
+If the Follow target is a CinemachineTargetGroup, then additional controls will be available to dynamically adjust the camera's view in order to frame the entire group.
+
+Although this component was designed for orthographic cameras, it works equally well with persective cameras and can be used in 3D environments.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **SoftGuideRect** | Rect | _[Get,Set]_ Internal API for the inspector editor. |
+| **HardGuideRect** | Rect | _[Get,Set]_ Internal API for the inspector editor. |
+| **IsValid** | Boolean | _[Get]_ True if component is enabled and has a valid Follow target. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Body stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+| **TrackedPoint** | Vector3 | _[Get]_ Internal API for inspector. |
+| **m_LastBounds** | Bounds | _[Get]_ For editor visulaization of the calculated bounding box of the group. |
+| **m_lastBoundsMatrix** | Matrix4x4 | _[Get]_ For editor visualization of the calculated bounding box of the group. |
+| **TargetGroup** | CinemachineTargetGroup | _[Get]_ Get Follow target as CinemachineTargetGroup, or null if target is not a group. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **OnGUICallback** | Action | Used by the Inspector Editor to display on-screen guides. |
+| **m_LookaheadTime** | Single | This setting will instruct the composer to adjust its target offset based on the motion of the target. The composer will look at a point where it estimates the target will be this many seconds into the future. Note that this setting is sensitive to noisy animation, and can amplify the noise, resulting in undesirable camera jitter. If the camera jitters unacceptably when the target is in motion, turn down this setting, or animate the target more smoothly. |
+| **m_LookaheadSmoothing** | Single | Controls the smoothness of the lookahead algorithm. Larger values smooth out jittery predictions and also increase prediction lag. |
+| **m_LookaheadIgnoreY** | Boolean | If checked, movement along the Y axis will be ignored for lookahead calculations. |
+| **m_XDamping** | Single | How aggressively the camera tries to maintain the offset in the X-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's x-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_YDamping** | Single | How aggressively the camera tries to maintain the offset in the Y-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's y-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_ZDamping** | Single | How aggressively the camera tries to maintain the offset in the Z-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's z-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_ScreenX** | Single | Horizontal screen position for target. The camera will move to position the tracked object here. |
+| **m_ScreenY** | Single | Vertical screen position for target, The camera will move to position the tracked object here. |
+| **m_CameraDistance** | Single | The distance along the camera axis that will be maintained from the Follow target. |
+| **m_DeadZoneWidth** | Single | Camera will not move horizontally if the target is within this range of the position. |
+| **m_DeadZoneHeight** | Single | Camera will not move vertically if the target is within this range of the position. |
+| **m_DeadZoneDepth** | Single | The camera will not move along its z-axis if the Follow target is within this distance of the specified camera distance. |
+| **m_UnlimitedSoftZone** | Boolean | If checked, then then soft zone will be unlimited in size. |
+| **m_SoftZoneWidth** | Single | When target is within this region, camera will gradually move horizontally to re-align towards the desired position, depending on the damping speed. |
+| **m_SoftZoneHeight** | Single | When target is within this region, camera will gradually move vertically to re-align towards the desired position, depending on the damping speed. |
+| **m_BiasX** | Single | A non-zero bias will move the target position horizontally away from the center of the soft zone. |
+| **m_BiasY** | Single | A non-zero bias will move the target position vertically away from the center of the soft zone. |
+| **m_GroupFramingMode** | FramingMode | What screen dimensions to consider when framing. Can be Horizontal, Vertical, or both.<br>_Possible Values:_<br>- **Horizontal**: Consider only the horizontal dimension. Vertical framing is ignored.<br>- **Vertical**: Consider only the vertical dimension. Horizontal framing is ignored.<br>- **HorizontalAndVertical**: The larger of the horizontal and vertical dimensions will dominate, to get the best fit.<br>- **None**: Don't do any framing adjustment.<br> |
+| **m_AdjustmentMode** | AdjustmentMode | How to adjust the camera to get the desired framing. You can zoom, dolly in/out, or do both.<br>_Possible Values:_<br>- **ZoomOnly**<br>- **DollyOnly**<br>- **DollyThenZoom**<br> |
+| **m_GroupFramingSize** | Single | The bounding box of the targets should occupy this amount of the screen space. 1 means fill the whole screen. 0.5 means fill half the screen, etc. |
+| **m_MaxDollyIn** | Single | The maximum distance toward the target that this behaviour is allowed to move the camera. |
+| **m_MaxDollyOut** | Single | The maximum distance away the target that this behaviour is allowed to move the camera. |
+| **m_MinimumDistance** | Single | Set this to limit how close to the target the camera can get. |
+| **m_MaximumDistance** | Single | Set this to limit how far from the target the camera can get. |
+| **m_MinimumFOV** | Single | If adjusting FOV, will not set the FOV lower than this. |
+| **m_MaximumFOV** | Single | If adjusting FOV, will not set the FOV higher than this. |
+| **m_MinimumOrthoSize** | Single | If adjusting Orthographic Size, will not set it lower than this. |
+| **m_MaximumOrthoSize** | Single | If adjusting Orthographic Size, will not set it higher than this. |
+
+
+#### Methods
+
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the us that a target got warped, so that we can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Positions the virtual camera according to the transposer rules.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for damping. If less than 0, no damping is done. |
+
+
+
+### CinemachineFreeLook
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineVirtualCameraBase
+
+_Implements:_ ICinemachineCamera
+
+
+A Cinemachine Camera geared towards a 3rd person camera experience. The camera orbits around its subject with three separate camera rigs defining rings around the target. Each rig has its own radius, height offset, composer, and lens settings. Depending on the camera's position along the spline connecting these three rigs, these settings are interpolated to give the final camera position and state.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **RigNames** | String[] | _(static)_ _[Get]_ Names of the 3 child rigs. |
+| **State** | CameraState | _[Get]_ The cacmera state, which will be a blend of the child rig states. |
+| **LookAt** | Transform | _[Get,Set]_ Get the current LookAt target. Returns parent's LookAt if parent is non-null and no specific LookAt defined for this camera. |
+| **Follow** | Transform | _[Get,Set]_ Get the current Follow target. Returns parent's Follow if parent is non-null and no specific Follow defined for this camera. |
+| **LiveChildOrSelf** | ICinemachineCamera | _[Get]_ Returns the rig with the greatest weight. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_LookAt** | Transform | Object for the camera children to look at (the aim target). |
+| **m_Follow** | Transform | Object for the camera children wants to move with (the body target). |
+| **m_PositionBlending** | PositionBlendMethod | Hint for blending positions to and from this virtual camera.<br>_Possible Values:_<br>- **Linear**<br>- **Spherical**<br>- **Cylindrical**<br> |
+| **m_CommonLens** | Boolean | If enabled, this lens setting will apply to all three child rigs, otherwise the child rig lens settings will be used. |
+| **m_Lens** | LensSettings | Specifies the lens properties of this Virtual Camera. This generally mirrors the Unity Camera's lens settings, and will be used to drive the Unity camera when the vcam is active. |
+| **m_YAxis** | AxisState | The Vertical axis. Value is 0..1. Chooses how to blend the child rigs. |
+| **m_YAxisRecentering** | Recentering | Controls how automatic recentering of the Y axis is accomplished. |
+| **m_XAxis** | AxisState | The Horizontal axis. Value is -180...180. This is passed on to the rigs' OrbitalTransposer component. |
+| **m_Heading** | Heading | The definition of Forward. Camera will follow behind. |
+| **m_RecenterToTargetHeading** | Recentering | Controls how automatic recentering of the X axis is accomplished. |
+| **m_BindingMode** | BindingMode | The coordinate space to use when interpreting the offset from the target. This is also used to set the camera's Up vector, which will be maintained when aiming the camera.<br>_Possible Values:_<br>- **LockToTargetOnAssign**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame at the moment when the virtual camera was enabled, or when the target was assigned.<br>- **LockToTargetWithWorldUp**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame, with the tilt and roll zeroed out.<br>- **LockToTargetNoRoll**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame, with the roll zeroed out.<br>- **LockToTarget**: Camera will be bound to the Follow target using the target's local frame.<br>- **WorldSpace**: Camera will be bound to the Follow target using a world space offset.<br>- **SimpleFollowWithWorldUp**: Offsets will be calculated relative to the target, using Camera-local axes.<br> |
+| **m_SplineCurvature** | Single | Controls how taut is the line that connects the rigs' orbits, which determines final placement on the Y axis. |
+| **m_Orbits** | Orbit[] | The radius and height of the three orbiting rigs. |
+| **CinemachineGUIDebuggerCallback** | Action | This is deprecated. It is here to support the soon-to-be-removed Cinemachine Debugger in the Editor. |
+| **m_ExcludedPropertiesInInspector** | String[] | Inspector control - Use for hiding sections of the Inspector UI. |
+| **m_LockStageInInspector** | Stage[] | Inspector control - Use for enabling sections of the Inspector UI. |
+| **m_Priority** | Int32 | The priority will determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority. |
+
+
+#### Methods
+
+``protected virtual Void OnValidate()``
+
+Enforce bounds for fields, when changed in inspector.
+
+``CinemachineVirtualCamera GetRig(Int32 i)``
+
+Get a child rig.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **i** | Int32 | Rig index. Can be 0, 1, or 2. |
+
+_Returns:_ The rig, or null if index is bad.
+``protected virtual Void OnEnable()``
+
+Updates the child rig cache.
+
+``protected virtual Void OnDestroy()``
+
+Makes sure that the child rigs get destroyed in an undo-firndly manner. Invalidates the rig cache.
+
+``virtual Boolean IsLiveChild(ICinemachineCamera vcam)``
+
+Check whether the vcam a live child of this camera. Returns true if the child is currently contributing actively to the camera state.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | ICinemachineCamera | The Virtual Camera to check. |
+
+_Returns:_ True if the vcam is currently actively influencing the state of this vcam.
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the vcam that a target got warped, so that the vcam can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``virtual Void InternalUpdateCameraState(Vector3 worldUp, Single deltaTime)``
+
+Internal use only. Called by CinemachineCore at designated update time so the vcam can position itself and track its targets. All 3 child rigs are updated, and a blend calculated, depending on the value of the Y axis.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | Default world Up, set by the CinemachineBrain. |
+| **deltaTime** | Single | Delta time for time-based effects (ignore if less than 0). |
+
+``virtual Void OnTransitionFromCamera(ICinemachineCamera fromCam, Vector3 worldUp, Single deltaTime)``
+
+If we are transitioning from another FreeLook, grab the axis values from it.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **fromCam** | ICinemachineCamera | The camera being deactivated. May be null. |
+| **worldUp** | Vector3 | Default world Up, set by the CinemachineBrain. |
+| **deltaTime** | Single | Delta time for time-based effects (ignore if less than or equal to 0). |
+
+``Vector3 GetLocalPositionForCameraFromInput(Single t)``
+
+Returns the local position of the camera along the spline used to connect the three camera rigs. Does not take into account the current heading of the camera (or its target).
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **t** | Single | The t-value for the camera on its spline. Internally clamped to the value [0,1]. |
+
+_Returns:_ The local offset (back + up) of the camera WRT its target based on the supplied t-value.
+
+
+### CinemachineGroupComposer
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComposer
+
+
+This is a CinemachineComponent in the Aim section of the component pipeline. Its job is to aim the camera at a target object, with configurable offsets, damping, and composition rules.
+
+In addition, if the target is a CinemachineTargetGroup, the behaviour will adjust the FOV and the camera distance to ensure that the entire group of targets is framed properly.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **TargetGroup** | CinemachineTargetGroup | _[Get]_ Get LookAt target as CinemachineTargetGroup, or null if target is not a group. |
+| **m_LastBounds** | Bounds | _[Get]_ For editor visulaization of the calculated bounding box of the group. |
+| **m_lastBoundsMatrix** | Matrix4x4 | _[Get]_ For editor visualization of the calculated bounding box of the group. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_GroupFramingSize** | Single | The bounding box of the targets should occupy this amount of the screen space. 1 means fill the whole screen. 0.5 means fill half the screen, etc. |
+| **m_FramingMode** | FramingMode | What screen dimensions to consider when framing. Can be Horizontal, Vertical, or both.<br>_Possible Values:_<br>- **Horizontal**: Consider only the horizontal dimension. Vertical framing is ignored.<br>- **Vertical**: Consider only the vertical dimension. Horizontal framing is ignored.<br>- **HorizontalAndVertical**: The larger of the horizontal and vertical dimensions will dominate, to get the best fit.<br> |
+| **m_FrameDamping** | Single | How aggressively the camera tries to frame the group. Small numbers are more responsive, rapidly adjusting the camera to keep the group in the frame. Larger numbers give a more heavy slowly responding camera. |
+| **m_AdjustmentMode** | AdjustmentMode | How to adjust the camera to get the desired framing. You can zoom, dolly in/out, or do both.<br>_Possible Values:_<br>- **ZoomOnly**<br>- **DollyOnly**<br>- **DollyThenZoom**<br> |
+| **m_MaxDollyIn** | Single | The maximum distance toward the target that this behaviour is allowed to move the camera. |
+| **m_MaxDollyOut** | Single | The maximum distance away the target that this behaviour is allowed to move the camera. |
+| **m_MinimumDistance** | Single | Set this to limit how close to the target the camera can get. |
+| **m_MaximumDistance** | Single | Set this to limit how far from the target the camera can get. |
+| **m_MinimumFOV** | Single | If adjusting FOV, will not set the FOV lower than this. |
+| **m_MaximumFOV** | Single | If adjusting FOV, will not set the FOV higher than this. |
+| **m_MinimumOrthoSize** | Single | If adjusting Orthographic Size, will not set it lower than this. |
+| **m_MaximumOrthoSize** | Single | If adjusting Orthographic Size, will not set it higher than this. |
+| **OnGUICallback** | Action | Used by the Inspector Editor to display on-screen guides. |
+| **m_TrackedObjectOffset** | Vector3 | Target offset from the target object's center in target-local space. Use this to fine-tune the tracking target position when the desired area is not the tracked object's center. |
+| **m_LookaheadTime** | Single | This setting will instruct the composer to adjust its target offset based on the motion of the target. The composer will look at a point where it estimates the target will be this many seconds into the future. Note that this setting is sensitive to noisy animation, and can amplify the noise, resulting in undesirable camera jitter. If the camera jitters unacceptably when the target is in motion, turn down this setting, or animate the target more smoothly. |
+| **m_LookaheadSmoothing** | Single | Controls the smoothness of the lookahead algorithm. Larger values smooth out jittery predictions and also increase prediction lag. |
+| **m_LookaheadIgnoreY** | Boolean | If checked, movement along the Y axis will be ignored for lookahead calculations. |
+| **m_HorizontalDamping** | Single | How aggressively the camera tries to follow the target in the screen-horizontal direction. Small numbers are more responsive, rapidly orienting the camera to keep the target in the dead zone. Larger numbers give a more heavy slowly responding camera. Using different vertical and horizontal settings can yield a wide range of camera behaviors. |
+| **m_VerticalDamping** | Single | How aggressively the camera tries to follow the target in the screen-vertical direction. Small numbers are more responsive, rapidly orienting the camera to keep the target in the dead zone. Larger numbers give a more heavy slowly responding camera. Using different vertical and horizontal settings can yield a wide range of camera behaviors. |
+| **m_ScreenX** | Single | Horizontal screen position for target. The camera will rotate to position the tracked object here. |
+| **m_ScreenY** | Single | Vertical screen position for target, The camera will rotate to position the tracked object here. |
+| **m_DeadZoneWidth** | Single | Camera will not rotate horizontally if the target is within this range of the position. |
+| **m_DeadZoneHeight** | Single | Camera will not rotate vertically if the target is within this range of the position. |
+| **m_SoftZoneWidth** | Single | When target is within this region, camera will gradually rotate horizontally to re-align towards the desired position, depending on the damping speed. |
+| **m_SoftZoneHeight** | Single | When target is within this region, camera will gradually rotate vertically to re-align towards the desired position, depending on the damping speed. |
+| **m_BiasX** | Single | A non-zero bias will move the target position horizontally away from the center of the soft zone. |
+| **m_BiasY** | Single | A non-zero bias will move the target position vertically away from the center of the soft zone. |
+
+
+#### Methods
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Applies the composer rules and orients the camera accordingly.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for calculating damping. If less than zero, then target will snap to the center of the dead zone. |
+
+
+
+### CinemachineHardLockToTarget
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+This is a CinemachineComponent in the Aim section of the component pipeline. Its job is to place the camera on the Follow Target.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **IsValid** | Boolean | _[Get]_ True if component is enabled and has a LookAt defined. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Aim stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+
+
+#### Methods
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Applies the composer rules and orients the camera accordingly.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for calculating damping. If less than zero, then target will snap to the center of the dead zone. |
+
+
+
+### CinemachineHardLookAt
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+This is a CinemachineComponent in the Aim section of the component pipeline. Its job is to aim the camera hard at the LookAt target.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **IsValid** | Boolean | _[Get]_ True if component is enabled and has a LookAt defined. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Aim stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+
+
+#### Methods
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Applies the composer rules and orients the camera accordingly.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for calculating damping. If less than zero, then target will snap to the center of the dead zone. |
+
+
+
+### CinemachineMixingCamera
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineVirtualCameraBase
+
+_Implements:_ ICinemachineCamera
+
+
+CinemachineMixingCamera is a "manager camera" that takes on the state of the weighted average of the states of its child virtual cameras.
+
+A fixed number of slots are made available for cameras, rather than a dynamic array. We do it this way in order to support weight animation from the Timeline. Timeline cannot animate array elements.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **State** | CameraState | _[Get]_ The blended CameraState. |
+| **LookAt** | Transform | _[Get,Set]_ Not used. |
+| **Follow** | Transform | _[Get,Set]_ Not used. |
+| **LiveChildOrSelf** | ICinemachineCamera | _[Get]_ Return the live child. |
+| **ChildCameras** | CinemachineVirtualCameraBase[] | _[Get]_ Get the cached list of child cameras. These are just the immediate children in the hierarchy. Note: only the first entries of this list participate in the final blend, up to MaxCameras. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Weight0** | Single | The weight of the first tracked camera. |
+| **m_Weight1** | Single | The weight of the second tracked camera. |
+| **m_Weight2** | Single | The weight of the third tracked camera. |
+| **m_Weight3** | Single | The weight of the fourth tracked camera. |
+| **m_Weight4** | Single | The weight of the fifth tracked camera. |
+| **m_Weight5** | Single | The weight of the sixth tracked camera. |
+| **m_Weight6** | Single | The weight of the seventh tracked camera. |
+| **m_Weight7** | Single | The weight of the eighth tracked camera. |
+| **CinemachineGUIDebuggerCallback** | Action | This is deprecated. It is here to support the soon-to-be-removed Cinemachine Debugger in the Editor. |
+| **m_ExcludedPropertiesInInspector** | String[] | Inspector control - Use for hiding sections of the Inspector UI. |
+| **m_LockStageInInspector** | Stage[] | Inspector control - Use for enabling sections of the Inspector UI. |
+| **m_Priority** | Int32 | The priority will determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority. |
+
+
+#### Methods
+
+``Single GetWeight(Int32 index)``
+
+Get the weight of the child at an index.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **index** | Int32 | The child index. Only immediate CinemachineVirtualCameraBase children are counted. |
+
+_Returns:_ The weight of the camera. Valid only if camera is active and enabled.
+``Void SetWeight(Int32 index, Single w)``
+
+Set the weight of the child at an index.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **index** | Int32 | The child index. Only immediate CinemachineVirtualCameraBase children are counted. |
+| **w** | Single | The weight to set. Can be any non-negative number. |
+
+``Single GetWeight(CinemachineVirtualCameraBase vcam)``
+
+Get the weight of the child CinemachineVirtualCameraBase.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | CinemachineVirtualCameraBase | The child camera. |
+
+_Returns:_ The weight of the camera. Valid only if camera is active and enabled.
+``Void SetWeight(CinemachineVirtualCameraBase vcam, Single w)``
+
+Set the weight of the child CinemachineVirtualCameraBase.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | CinemachineVirtualCameraBase | The child camera. |
+| **w** | Single | The weight to set. Can be any non-negative number. |
+
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the vcam that a target got warped, so that the vcam can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``protected virtual Void OnEnable()``
+
+Makes sure the internal child cache is up to date.
+
+``Void OnTransformChildrenChanged()``
+
+Makes sure the internal child cache is up to date.
+
+``protected virtual Void OnValidate()``
+
+Makes sure the weights are non-negative.
+
+``virtual Boolean IsLiveChild(ICinemachineCamera vcam)``
+
+Check whether the vcam a live child of this camera.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | ICinemachineCamera | The Virtual Camera to check. |
+
+_Returns:_ True if the vcam is currently actively influencing the state of this vcam.
+``protected Void InvalidateListOfChildren()``
+
+Invalidate the cached list of child cameras.
+
+``protected Void ValidateListOfChildren()``
+
+Rebuild the cached list of child cameras.
+
+``virtual Void InternalUpdateCameraState(Vector3 worldUp, Single deltaTime)``
+
+Internal use only. Do not call this methid. Called by CinemachineCore at designated update time so the vcam can position itself and track its targets. This implementation computes and caches the weighted blend of the tracked cameras.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | Default world Up, set by the CinemachineBrain. |
+| **deltaTime** | Single | Delta time for time-based effects (ignore if less than 0). |
+
+
+
+### CinemachineOrbitalTransposer
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineTransposer
+
+
+This is a CinemachineComponent in the the Body section of the component pipeline. Its job is to position the camera in a variable relationship to a the vcam's Follow target object, with offsets and damping.
+
+This component is typically used to implement a camera that follows its target. It can accept player input from an input device, which allows the player to dynamically control the relationship between the camera and the target, for example with a joystick.
+
+The OrbitalTransposer introduces the concept of __Heading__, which is the direction in which the target is moving, and the OrbitalTransposer will attempt to position the camera in relationship to the heading, which is by default directly behind the target. You can control the default relationship by adjusting the Heading Bias setting.
+
+If you attach an input controller to the OrbitalTransposer, then the player can also control the way the camera positions itself in relation to the target heading. This allows the camera to move to any spot on an orbit around the target.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Heading** | Heading | The definition of Forward. Camera will follow behind. |
+| **m_RecenterToTargetHeading** | Recentering | Automatic heading recentering. The settings here defines how the camera will reposition itself in the absence of player input. |
+| **m_XAxis** | AxisState | Heading Control. The settings here control the behaviour of the camera in response to the player's input. |
+| **m_HeadingIsSlave** | Boolean | Drive the x-axis setting programmatically. Automatic heading updating will be disabled. |
+| **m_BindingMode** | BindingMode | The coordinate space to use when interpreting the offset from the target. This is also used to set the camera's Up vector, which will be maintained when aiming the camera.<br>_Possible Values:_<br>- **LockToTargetOnAssign**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame at the moment when the virtual camera was enabled, or when the target was assigned.<br>- **LockToTargetWithWorldUp**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame, with the tilt and roll zeroed out.<br>- **LockToTargetNoRoll**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame, with the roll zeroed out.<br>- **LockToTarget**: Camera will be bound to the Follow target using the target's local frame.<br>- **WorldSpace**: Camera will be bound to the Follow target using a world space offset.<br>- **SimpleFollowWithWorldUp**: Offsets will be calculated relative to the target, using Camera-local axes.<br> |
+| **m_FollowOffset** | Vector3 | The distance vector that the transposer will attempt to maintain from the Follow target. |
+| **m_XDamping** | Single | How aggressively the camera tries to maintain the offset in the X-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's x-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_YDamping** | Single | How aggressively the camera tries to maintain the offset in the Y-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's y-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_ZDamping** | Single | How aggressively the camera tries to maintain the offset in the Z-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's z-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_PitchDamping** | Single | How aggressively the camera tries to track the target rotation's X angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+| **m_YawDamping** | Single | How aggressively the camera tries to track the target rotation's Y angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+| **m_RollDamping** | Single | How aggressively the camera tries to track the target rotation's Z angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+
+
+#### Methods
+
+``protected virtual Void OnValidate()``
+
+
+
+``Single UpdateHeading(Single deltaTime, Vector3 up, AxisState& axis)``
+
+Update the X axis and calculate the heading. This can be called by a delegate with a custom axis. Used for damping. If less than 0, no damping is done.World Up, set by the CinemachineBrainAxis value.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **deltaTime** | Single | Used for damping. If less than 0, no damping is done. |
+| **up** | Vector3 | World Up, set by the CinemachineBrain. |
+| **axis** | AxisState& | |
+
+_Returns:_ Axis value.
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the us that a target got warped, so that we can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Positions the virtual camera according to the transposer rules.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for damping. If less than 0, no damping is done. |
+
+
+
+### CinemachineOrbitalTransposer.Heading
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+How the "forward" direction is defined. Orbital offset is in relation to the forward direction.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Definition** | HeadingDefinition | How 'forward' is defined. The camera will be placed by default behind the target. PositionDelta will consider 'forward' to be the direction in which the target is moving.<br>_Possible Values:_<br>- **PositionDelta**: Target heading calculated from the difference between its position on the last update and current frame.<br>- **Velocity**: Target heading calculated from its Rigidbody's velocity. If no Rigidbody exists, it will fall back to HeadingDerivationMode.PositionDelta.<br>- **TargetForward**: Target heading calculated from the Target Transform's euler Y angle.<br>- **WorldForward**: Default heading is a constant world space heading.<br> |
+| **m_VelocityFilterStrength** | Int32 | Size of the velocity sampling window for target heading filter. This filters out irregularities in the target's movement. Used only if deriving heading from target's movement (PositionDelta or Velocity). |
+| **m_Bias** | Single | Where the camera is placed when the X-axis value is zero. This is a rotation in degrees around the Y axis. When this value is 0, the camera will be placed behind the target. Nonzero offsets will rotate the zero position around the target. |
+
+
+
+### CinemachinePath
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachinePathBase
+
+
+Defines a world-space path, consisting of an array of waypoints, each of which has position, tangent, and roll settings. Bezier interpolation is performed between the waypoints, to get a smooth and continuous path.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **MinPos** | Single | _[Get]_ The minimum value for the path position. |
+| **MaxPos** | Single | _[Get]_ The maximum value for the path position. |
+| **Looped** | Boolean | _[Get]_ True if the path ends are joined to form a continuous loop. |
+| **DistanceCacheSampleStepsPerSegment** | Int32 | _[Get]_ When calculating the distance cache, sample the path this many times between points. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Looped** | Boolean | If checked, then the path ends are joined to form a continuous loop. |
+| **m_Waypoints** | Waypoint[] | The waypoints that define the path. They will be interpolated using a bezier curve. |
+| **m_Resolution** | Int32 | Path samples per waypoint. This is used for calculating path distances. |
+| **m_Appearance** | Appearance | The settings that control how the path will appear in the editor scene view. |
+
+
+#### Methods
+
+``virtual Vector3 EvaluatePosition(Single pos)``
+
+Get a worldspace position of a point along the path.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **pos** | Single | Postion along the path. Need not be normalized. |
+
+_Returns:_ World-space position of the point along at path at pos.
+``virtual Vector3 EvaluateTangent(Single pos)``
+
+Get the tangent of the curve at a point along the path.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **pos** | Single | Postion along the path. Need not be normalized. |
+
+_Returns:_ World-space direction of the path tangent. Length of the vector represents the tangent strength.
+``virtual Quaternion EvaluateOrientation(Single pos)``
+
+Get the orientation the curve at a point along the path.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **pos** | Single | Postion along the path. Need not be normalized. |
+
+_Returns:_ World-space orientation of the path, as defined by tangent, up, and roll.
+
+
+### CinemachinePath.Waypoint
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+A waypoint along the path.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **position** | Vector3 | Position in path-local space. |
+| **tangent** | Vector3 | Offset from the position, which defines the tangent of the curve at the waypoint. The length of the tangent encodes the strength of the bezier handle. The same handle is used symmetrically on both sides of the waypoint, to ensure smoothness. |
+| **roll** | Single | Defines the roll of the path at this waypoint. The other orientation axes are inferred from the tangent and world up. |
+
+
+
+### CinemachinePathBase.Appearance
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+
+This class holds the settings that control how the path will appear in the editor scene view. The path is not visible in the game view.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **pathColor** | Color | The color of the path itself when it is active in the editor. |
+| **inactivePathColor** | Color | The color of the path itself when it is inactive in the editor. |
+| **width** | Single | The width of the railroad-tracks that are drawn to represent the path. |
+
+
+
+### CinemachinePOV
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+This is a CinemachineComponent in the Aim section of the component pipeline. Its job is to aim the camera in response to the user's mouse or joystick input.
+
+The composer does not change the camera's position. It will only pan and tilt the camera where it is, in order to get the desired framing. To move the camera, you have to use the virtual camera's Body section.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **IsValid** | Boolean | _[Get]_ True if component is enabled and has a LookAt defined. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Aim stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_VerticalAxis** | AxisState | The Vertical axis. Value is -90..90. Controls the vertical orientation. |
+| **m_VerticalRecentering** | Recentering | Controls how automatic recentering of the Vertical axis is accomplished. |
+| **m_HorizontalAxis** | AxisState | The Horizontal axis. Value is -180..180. Controls the horizontal orientation. |
+| **m_HorizontalRecentering** | Recentering | Controls how automatic recentering of the Horizontal axis is accomplished. |
+
+
+#### Methods
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Applies the axis values and orients the camera accordingly.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for calculating damping. Not used. |
+
+
+
+### CinemachineSameAsFollowTarget
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+This is a CinemachineComponent in the Aim section of the component pipeline. Its job is to match the orientation of the Follow target.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **IsValid** | Boolean | _[Get]_ True if component is enabled and has a Follow target defined. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Aim stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+
+
+#### Methods
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Orients the camera to match the Follow target's orientation.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Not used. |
+
+
+
+### CinemachineSmoothPath
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachinePathBase
+
+
+Defines a world-space path, consisting of an array of waypoints, each of which has position and roll settings. Bezier interpolation is performed between the waypoints, to get a smooth and continuous path. The path will pass through all waypoints, and (unlike CinemachinePath) first and second order continuity is guaranteed.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **MinPos** | Single | _[Get]_ The minimum value for the path position. |
+| **MaxPos** | Single | _[Get]_ The maximum value for the path position. |
+| **Looped** | Boolean | _[Get]_ True if the path ends are joined to form a continuous loop. |
+| **DistanceCacheSampleStepsPerSegment** | Int32 | _[Get]_ When calculating the distance cache, sample the path this many times between points. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Looped** | Boolean | If checked, then the path ends are joined to form a continuous loop. |
+| **m_Waypoints** | Waypoint[] | The waypoints that define the path. They will be interpolated using a bezier curve. |
+| **m_Resolution** | Int32 | Path samples per waypoint. This is used for calculating path distances. |
+| **m_Appearance** | Appearance | The settings that control how the path will appear in the editor scene view. |
+
+
+#### Methods
+
+``virtual Void InvalidateDistanceCache()``
+
+Call this if the path changes in such a way as to affect distances or other cached path elements.
+
+``virtual Vector3 EvaluatePosition(Single pos)``
+
+Get a worldspace position of a point along the path.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **pos** | Single | Postion along the path. Need not be normalized. |
+
+_Returns:_ World-space position of the point along at path at pos.
+``virtual Vector3 EvaluateTangent(Single pos)``
+
+Get the tangent of the curve at a point along the path.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **pos** | Single | Postion along the path. Need not be normalized. |
+
+_Returns:_ World-space direction of the path tangent. Length of the vector represents the tangent strength.
+``virtual Quaternion EvaluateOrientation(Single pos)``
+
+Get the orientation the curve at a point along the path.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **pos** | Single | Postion along the path. Need not be normalized. |
+
+_Returns:_ World-space orientation of the path, as defined by tangent, up, and roll.
+
+
+### CinemachineSmoothPath.Waypoint
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+A waypoint along the path.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **position** | Vector3 | Position in path-local space. |
+| **roll** | Single | Defines the roll of the path at this waypoint. The other orientation axes are inferred from the tangent and world up. |
+
+
+
+### CinemachineStateDrivenCamera
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineVirtualCameraBase
+
+_Implements:_ ICinemachineCamera
+
+
+This is a virtual camera "manager" that owns and manages a collection of child Virtual Cameras. These child vcams are mapped to individual states in an animation state machine, allowing you to associate specific vcams to specific animation states. When that state is active in the state machine, then the associated camera will be activated.
+
+You can define custom blends and transitions between child cameras.
+
+In order to use this behaviour, you must have an animated target (i.e. an object animated with a state machine) to drive the behaviour.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **Description** | String | _[Get]_ Gets a brief debug description of this virtual camera, for use when displayiong debug info. |
+| **LiveChild** | ICinemachineCamera | _[Get,Set]_ Get the current "best" child virtual camera, that would be chosen if the State Driven Camera were active. |
+| **LiveChildOrSelf** | ICinemachineCamera | _[Get]_ Return the live child. |
+| **State** | CameraState | _[Get]_ The State of the current live child. |
+| **LookAt** | Transform | _[Get,Set]_ Get the current LookAt target. Returns parent's LookAt if parent is non-null and no specific LookAt defined for this camera. |
+| **Follow** | Transform | _[Get,Set]_ Get the current Follow target. Returns parent's Follow if parent is non-null and no specific Follow defined for this camera. |
+| **ChildCameras** | CinemachineVirtualCameraBase[] | _[Get]_ The list of child cameras. These are just the immediate children in the hierarchy. |
+| **IsBlending** | Boolean | _[Get]_ Is there a blend in progress? |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_LookAt** | Transform | Default object for the camera children to look at (the aim target), if not specified in a child camera. May be empty if all of the children define targets of their own. |
+| **m_Follow** | Transform | Default object for the camera children wants to move with (the body target), if not specified in a child camera. May be empty if all of the children define targets of their own. |
+| **m_AnimatedTarget** | Animator | The state machine whose state changes will drive this camera's choice of active child. |
+| **m_LayerIndex** | Int32 | Which layer in the target state machine to observe. |
+| **m_ShowDebugText** | Boolean | When enabled, the current child camera and blend will be indicated in the game window, for debugging. |
+| **m_EnableAllChildCameras** | Boolean | Force all child cameras to be enabled. This is useful if animating them in Timeline, but consumes extra resources. |
+| **m_ChildCameras** | CinemachineVirtualCameraBase[] | Internal API for the editor. Do not use this field. |
+| **m_Instructions** | Instruction[] | The set of instructions associating virtual cameras with states. These instructions are used to choose the live child at any given moment. |
+| **m_DefaultBlend** | CinemachineBlendDefinition | The blend which is used if you don't explicitly define a blend between two Virtual Camera children. |
+| **m_CustomBlends** | CinemachineBlenderSettings | This is the asset which contains custom settings for specific child blends. |
+| **m_ParentHash** | ParentHash[] | Internal API for the Inspector editor. |
+| **CinemachineGUIDebuggerCallback** | Action | This is deprecated. It is here to support the soon-to-be-removed Cinemachine Debugger in the Editor. |
+| **m_ExcludedPropertiesInInspector** | String[] | Inspector control - Use for hiding sections of the Inspector UI. |
+| **m_LockStageInInspector** | Stage[] | Inspector control - Use for enabling sections of the Inspector UI. |
+| **m_Priority** | Int32 | The priority will determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority. |
+
+
+#### Methods
+
+``virtual Boolean IsLiveChild(ICinemachineCamera vcam)``
+
+Check whether the vcam a live child of this camera.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | ICinemachineCamera | The Virtual Camera to check. |
+
+_Returns:_ True if the vcam is currently actively influencing the state of this vcam.
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the vcam that a target got warped, so that the vcam can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``virtual Void InternalUpdateCameraState(Vector3 worldUp, Single deltaTime)``
+
+Internal use only. Do not call this method. Called by CinemachineCore at designated update time so the vcam can position itself and track its targets. This implementation updates all the children, chooses the best one, and implements any required blending.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | Default world Up, set by the CinemachineBrain. |
+| **deltaTime** | Single | Delta time for time-based effects (ignore if less than or equal to 0). |
+
+``protected virtual Void OnEnable()``
+
+Makes sure the internal child cache is up to date.
+
+``Void OnTransformChildrenChanged()``
+
+Makes sure the internal child cache is up to date.
+
+``protected virtual Void OnGUI()``
+
+Displays the current active camera on the game screen, if requested.
+
+``static String CreateFakeHashName(Int32 parentHash, String stateName)``
+
+API for the inspector editor. Animation module does not have hashes for state parents, so we have to invent them in order to implement nested state handling.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **parentHash** | Int32 | |
+| **stateName** | String | |
+
+``Void ValidateInstructions()``
+
+Internal API for the inspector editor.
+
+
+
+### CinemachineStoryboard
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineExtension
+
+
+An add-on module for Cinemachine Virtual Camera that places an image in screen space over the camera's output.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_ShowImage** | Boolean | If checked, the specified image will be displayed as an overlay over the virtual camera's output. |
+| **m_Image** | Texture | The image to display. |
+| **m_Aspect** | FillStrategy | How to handle differences between image aspect and screen aspect.<br>_Possible Values:_<br>- **BestFit**<br>- **CropImageToFit**<br>- **StretchToFit**<br> |
+| **m_Alpha** | Single | The opacity of the image. 0 is transparent, 1 is opaque. |
+| **m_Center** | Vector2 | The screen-space position at which to display the image. Zero is center. |
+| **m_Rotation** | Vector3 | The screen-space rotation to apply to the image. |
+| **m_Scale** | Vector2 | The screen-space scaling to apply to the image. |
+| **m_SyncScale** | Boolean | If checked, X and Y scale are synchronized. |
+| **m_MuteCamera** | Boolean | If checked, Camera transform will not be controlled by this virtual camera. |
+| **m_SplitView** | Single | Wipe the image on and off horizontally. |
+
+
+#### Methods
+
+``protected virtual Void PostPipelineStageCallback(CinemachineVirtualCameraBase vcam, Stage stage, CameraState& state, Single deltaTime)``
+
+Standard CinemachineExtension callback.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **vcam** | CinemachineVirtualCameraBase | |
+| **stage** | Stage | |
+| **state** | CameraState& | |
+| **deltaTime** | Single | |
+
+``protected virtual Void OnDestroy()``
+
+
+
+``protected virtual Void ConnectToVcam(Boolean connect)``
+
+
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **connect** | Boolean | |
+
+
+
+### CinemachineTargetGroup
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ MonoBehaviour
+
+
+Defines a group of target objects, each with a radius and a weight. The weight is used when calculating the average position of the target group. Higher-weighted members of the group will count more. The bounding box is calculated by taking the member positions, weight, and radii into account.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **BoundingBox** | Bounds | _[Get]_ The axis-aligned bounding box of the group, computed using the targets positions and radii. |
+| **IsEmpty** | Boolean | _[Get]_ Return true if there are no members with weight > 0. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_PositionMode** | PositionMode | How the group's position is calculated. Select GroupCenter for the center of the bounding box, and GroupAverage for a weighted average of the positions of the members.<br>_Possible Values:_<br>- **GroupCenter**: Group position will be the center of the group's axis-aligned bounding box.<br>- **GroupAverage**: Group position will be the weighted average of the positions of the members.<br> |
+| **m_RotationMode** | RotationMode | How the group's rotation is calculated. Select Manual to use the value in the group's transform, and GroupAverage for a weighted average of the orientations of the members.<br>_Possible Values:_<br>- **Manual**: Manually set in the group's transform.<br>- **GroupAverage**: Weighted average of the orientation of its members.<br> |
+| **m_UpdateMethod** | UpdateMethod | When to update the group's transform based on the position of the group members.<br>_Possible Values:_<br>- **Update**<br>- **FixedUpdate**<br>- **LateUpdate**<br> |
+| **m_Targets** | Target[] | The target objects, together with their weights and radii, that will contribute to the group's average position, orientation, and size. |
+
+
+#### Methods
+
+``Bounds GetViewSpaceBoundingBox(Matrix4x4 mView)``
+
+The axis-aligned bounding box of the group, in a specific reference frame.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **mView** | Matrix4x4 | The frame of reference in which to compute the bounding box. |
+
+_Returns:_ The axis-aligned bounding box of the group, in the desired frame of reference.
+
+
+### CinemachineTargetGroup.Target
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Holds the information that represents a member of the group.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The target objects. This object's position and orientation will contribute to the group's average position and orientation, in accordance with its weight. |
+| **weight** | Single | How much weight to give the target when averaging. Cannot be negative. |
+| **radius** | Single | The radius of the target, used for calculating the bounding box. Cannot be negative. |
+
+
+
+### CinemachineTrackedDolly
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+A Cinemachine Virtual Camera Body component that constrains camera motion to a CinemachinePath. The camera can move along the path.
+
+This behaviour can operate in two modes: manual positioning, and Auto-Dolly positioning. In Manual mode, the camera's position is specified by animating the Path Position field. In Auto-Dolly mode, the Path Position field is animated automatically every frame by finding the position on the path that's closest to the virtual camera's Follow target.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **IsValid** | Boolean | _[Get]_ True if component is enabled and has a path. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Body stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Path** | CinemachinePathBase | The path to which the camera will be constrained. This must be non-null. |
+| **m_PathPosition** | Single | The position along the path at which the camera will be placed. This can be animated directly, or set automatically by the Auto-Dolly feature to get as close as possible to the Follow target. The value is interpreted according to the Position Units setting. |
+| **m_PositionUnits** | PositionUnits | How to interpret Path Position. If set to Path Units, values are as follows: 0 represents the first waypoint on the path, 1 is the second, and so on. Values in-between are points on the path in between the waypoints. If set to Distance, then Path Position represents distance along the path.<br>_Possible Values:_<br>- **PathUnits**<br>- **Distance**<br>- **Normalized**<br> |
+| **m_PathOffset** | Vector3 | Where to put the camera relative to the path position. X is perpendicular to the path, Y is up, and Z is parallel to the path. This allows the camera to be offset from the path itself (as if on a tripod, for example). |
+| **m_XDamping** | Single | How aggressively the camera tries to maintain its position in a direction perpendicular to the path. Small numbers are more responsive, rapidly translating the camera to keep the target's x-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_YDamping** | Single | How aggressively the camera tries to maintain its position in the path-local up direction. Small numbers are more responsive, rapidly translating the camera to keep the target's y-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_ZDamping** | Single | How aggressively the camera tries to maintain its position in a direction parallel to the path. Small numbers are more responsive, rapidly translating the camera to keep the target's z-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_CameraUp** | CameraUpMode | How to set the virtual camera's Up vector. This will affect the screen composition, because the camera Aim behaviours will always try to respect the Up direction.<br>_Possible Values:_<br>- **Default**: Leave the camera's up vector alone. It will be set according to the Brain's WorldUp.<br>- **Path**: Take the up vector from the path's up vector at the current point.<br>- **PathNoRoll**: Take the up vector from the path's up vector at the current point, but with the roll zeroed out.<br>- **FollowTarget**: Take the up vector from the Follow target's up vector.<br>- **FollowTargetNoRoll**: Take the up vector from the Follow target's up vector, but with the roll zeroed out.<br> |
+| **m_PitchDamping** | Single | How aggressively the camera tries to track the target rotation's X angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+| **m_YawDamping** | Single | How aggressively the camera tries to track the target rotation's Y angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+| **m_RollDamping** | Single | How aggressively the camera tries to track the target rotation's Z angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+| **m_AutoDolly** | AutoDolly | Controls how automatic dollying occurs. A Follow target is necessary to use this feature. |
+
+
+#### Methods
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Positions the virtual camera according to the transposer rules.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for damping. If less that 0, no damping is done. |
+
+
+
+### CinemachineTrackedDolly.AutoDolly
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Controls how automatic dollying occurs.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Enabled** | Boolean | If checked, will enable automatic dolly, which chooses a path position that is as close as possible to the Follow target. Note: this can have significant performance impact. |
+| **m_PositionOffset** | Single | Offset, in current position units, from the closest point on the path to the follow target. |
+| **m_SearchRadius** | Int32 | Search up to how many waypoints on either side of the current position. Use 0 for Entire path. |
+| **m_SearchResolution** | Int32 | We search between waypoints by dividing the segment into this many straight pieces. The higher the number, the more accurate the result, but performance is proportionally slower for higher numbers. |
+
+
+
+### CinemachineTransposer
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineComponentBase
+
+
+This is a CinemachineComponent in the Body section of the component pipeline. Its job is to position the camera in a fixed relationship to the vcam's Follow target object, with offsets and damping.
+
+The Tansposer will only change the camera's position in space. It will not re-orient or otherwise aim the camera. To to that, you need to instruct the vcam in the Aim section of its pipeline.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **EffectiveOffset** | Vector3 | _[Get]_ Get the target offset, with sanitization. |
+| **IsValid** | Boolean | _[Get]_ True if component is enabled and has a valid Follow target. |
+| **Stage** | Stage | _[Get]_ Get the Cinemachine Pipeline stage that this component implements. Always returns the Body stage.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_BindingMode** | BindingMode | The coordinate space to use when interpreting the offset from the target. This is also used to set the camera's Up vector, which will be maintained when aiming the camera.<br>_Possible Values:_<br>- **LockToTargetOnAssign**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame at the moment when the virtual camera was enabled, or when the target was assigned.<br>- **LockToTargetWithWorldUp**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame, with the tilt and roll zeroed out.<br>- **LockToTargetNoRoll**: Camera will be bound to the Follow target using a frame of reference consisting of the target's local frame, with the roll zeroed out.<br>- **LockToTarget**: Camera will be bound to the Follow target using the target's local frame.<br>- **WorldSpace**: Camera will be bound to the Follow target using a world space offset.<br>- **SimpleFollowWithWorldUp**: Offsets will be calculated relative to the target, using Camera-local axes.<br> |
+| **m_FollowOffset** | Vector3 | The distance vector that the transposer will attempt to maintain from the Follow target. |
+| **m_XDamping** | Single | How aggressively the camera tries to maintain the offset in the X-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's x-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_YDamping** | Single | How aggressively the camera tries to maintain the offset in the Y-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's y-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_ZDamping** | Single | How aggressively the camera tries to maintain the offset in the Z-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's z-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors. |
+| **m_PitchDamping** | Single | How aggressively the camera tries to track the target rotation's X angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+| **m_YawDamping** | Single | How aggressively the camera tries to track the target rotation's Y angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+| **m_RollDamping** | Single | How aggressively the camera tries to track the target rotation's Z angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera. |
+
+
+#### Methods
+
+``protected virtual Void OnValidate()``
+
+Derived classes should call this from their OnValidate() implementation.
+
+``virtual Void MutateCameraState(CameraState& curState, Single deltaTime)``
+
+Positions the virtual camera according to the transposer rules.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | The current camera state. |
+| **deltaTime** | Single | Used for damping. If less than 0, no damping is done. |
+
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the us that a target got warped, so that we can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+``protected Void InitPrevFrameStateInfo(CameraState& curState, Single deltaTime)``
+
+Initializes the state for previous frame if appropriate.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **curState** | CameraState& | |
+| **deltaTime** | Single | |
+
+``protected Void TrackTarget(Single deltaTime, Vector3 up, Vector3 desiredCameraOffset, Vector3& outTargetPosition, Quaternion& outTargetOrient)``
+
+Positions the virtual camera according to the transposer rules.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **deltaTime** | Single | Used for damping. If less than 0, no damping is done. |
+| **up** | Vector3 | Current camera up. |
+| **desiredCameraOffset** | Vector3 | Where we want to put the camera relative to the follow target. |
+| **outTargetPosition** | Vector3& | Resulting camera position. |
+| **outTargetOrient** | Quaternion& | Damped target orientation. |
+
+``Vector3 GeTargetCameraPosition(Vector3 worldUp)``
+
+Internal API for the Inspector Editor, so it can draw a marker at the target.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | |
+
+``Quaternion GetReferenceOrientation(Vector3 worldUp)``
+
+Internal API for the Inspector Editor, so it can draw a marker at the target.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | |
+
+
+
+### CinemachineVirtualCamera
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ CinemachineVirtualCameraBase
+
+_Implements:_ ICinemachineCamera
+
+
+This behaviour is intended to be attached to an empty Transform GameObject, and it represents a Virtual Camera within the Unity scene.
+
+The Virtual Camera will animate its Transform according to the rules contained in its CinemachineComponent pipeline (Aim, Body, and Noise). When the virtual camera is Live, the Unity camera will assume the position and orientation of the virtual camera.
+
+A virtual camera is not a camera. Instead, it can be thought of as a camera controller, not unlike a cameraman. It can drive the Unity Camera and control its position, orientation, lens settings, and PostProcessing effects. Each Virtual Camera owns its own Cinemachine Component Pipeline, through which you provide the instructions for dynamically tracking specific game objects.
+
+A virtual camera is very lightweight, and does no rendering of its own. It merely tracks interesting GameObjects, and positions itself accordingly. A typical game can have dozens of virtual cameras, each set up to follow a particular character or capture a particular event.
+
+A Virtual Camera can be in any of three states:
+
+* **Live**: The virtual camera is actively controlling the Unity Camera. The virtual camera is tracking its targets and being updated every frame.
+* **Standby**: The virtual camera is tracking its targets and being updated every frame, but no Unity Camera is actively being controlled by it. This is the state of a virtual camera that is enabled in the scene but perhaps at a lower priority than the Live virtual camera.
+* **Disabled**: The virtual camera is present but disabled in the scene. It is not actively tracking its targets and so consumes no processing power. However, the virtual camera can be made live from the Timeline.
+
+The Unity Camera can be driven by any virtual camera in the scene. The game logic can choose the virtual camera to make live by manipulating the virtual cameras' enabled flags and their priorities, based on game logic.
+
+In order to be driven by a virtual camera, the Unity Camera must have a CinemachineBrain behaviour, which will select the most eligible virtual camera based on its priority or on other criteria, and will manage blending.
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **State** | CameraState | _[Get]_ The CameraState object holds all of the information necessary to position the Unity camera. It is the output of this class. |
+| **LookAt** | Transform | _[Get,Set]_ Get the LookAt target for the Aim component in the CinemachinePipeline. If this vcam is a part of a meta-camera collection, then the owner's target will be used if the local target is null. |
+| **Follow** | Transform | _[Get,Set]_ Get the Follow target for the Body component in the CinemachinePipeline. If this vcam is a part of a meta-camera collection, then the owner's target will be used if the local target is null. |
+| **UserIsDragging** | Boolean | _[Get,Set]_ API for the editor, to make the dragging of position handles behave better. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_LookAt** | Transform | The object that the camera wants to look at (the Aim target). If this is null, then the vcam's Transform orientation will define the camera's orientation. |
+| **m_Follow** | Transform | The object that the camera wants to move with (the Body target). If this is null, then the vcam's Transform position will define the camera's position. |
+| **m_PositionBlending** | PositionBlendMethod | Hint for blending positions to and from this virtual camera.<br>_Possible Values:_<br>- **Linear**<br>- **Spherical**<br>- **Cylindrical**<br> |
+| **m_Lens** | LensSettings | Specifies the lens properties of this Virtual Camera. This generally mirrors the Unity Camera's lens settings, and will be used to drive the Unity camera when the vcam is active. |
+| **CinemachineGUIDebuggerCallback** | Action | This is deprecated. It is here to support the soon-to-be-removed Cinemachine Debugger in the Editor. |
+| **m_ExcludedPropertiesInInspector** | String[] | Inspector control - Use for hiding sections of the Inspector UI. |
+| **m_LockStageInInspector** | Stage[] | Inspector control - Use for enabling sections of the Inspector UI. |
+| **m_Priority** | Int32 | The priority will determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority. |
+
+
+#### Methods
+
+``virtual Void InternalUpdateCameraState(Vector3 worldUp, Single deltaTime)``
+
+Internal use only. Do not call this method. Called by CinemachineCore at the appropriate Update time so the vcam can position itself and track its targets. This class will invoke its pipeline and generate a CameraState for this frame.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **worldUp** | Vector3 | |
+| **deltaTime** | Single | |
+
+``protected virtual Void OnEnable()``
+
+Make sure that the pipeline cache is up-to-date.
+
+``protected virtual Void OnDestroy()``
+
+Calls the DestroyPipelineDelegate for destroying the hidden child object, to support undo.
+
+``protected virtual Void OnValidate()``
+
+Enforce bounds for fields, when changed in inspector.
+
+``Void InvalidateComponentPipeline()``
+
+Editor API: Call this when changing the pipeline from the editor. Will force a rebuild of the pipeline cache.
+
+``Transform GetComponentOwner()``
+
+Get the hidden CinemachinePipeline child object.
+
+``CinemachineComponentBase[] GetComponentPipeline()``
+
+Get the component pipeline owned by the hidden child pipline container. For most purposes, it is preferable to use the GetCinemachineComponent method.
+
+``CinemachineComponentBase GetCinemachineComponent(Stage stage)``
+
+Get the component set for a specific stage.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **stage** | Stage | The stage for which we want the component.<br>_Possible Values:_<br>- **Body**<br>- **Aim**<br>- **Noise**<br>- **Finalize**<br> |
+
+_Returns:_ The Cinemachine component for that stage, or null if not defined.
+``T GetCinemachineComponent[T]()``
+
+Get an existing component of a specific type from the cinemachine pipeline.
+
+``T AddCinemachineComponent[T]()``
+
+Add a component to the cinemachine pipeline.
+
+``Void DestroyCinemachineComponent[T]()``
+
+Remove a component from the cinemachine pipeline.
+
+``virtual Void OnTargetObjectWarped(Transform target, Vector3 positionDelta)``
+
+This is called to notify the vcam that a target got warped, so that the vcam can update its internal state to make the camera also warp seamlessy.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **target** | Transform | The object that was warped. |
+| **positionDelta** | Vector3 | The amount the target's position changed. |
+
+
+
+### LensSettings
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Describes the FOV and clip planes for a camera. This generally mirrors the Unity Camera's lens settings, and will be used to drive the Unity camera when the vcam is active.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **FieldOfView** | Single | This is the camera view in vertical degrees. For cinematic people, a 50mm lens on a super-35mm sensor would equal a 19.6 degree FOV. |
+| **OrthographicSize** | Single | When using an orthographic camera, this defines the half-height, in world coordinates, of the camera view. |
+| **NearClipPlane** | Single | This defines the near region in the renderable range of the camera frustum. Raising this value will stop the game from drawing things near the camera, which can sometimes come in handy. Larger values will also increase your shadow resolution. |
+| **FarClipPlane** | Single | This defines the far region of the renderable range of the camera frustum. Typically you want to set this value as low as possible without cutting off desired distant objects. |
+| **Dutch** | Single | Camera Z roll, or tilt, in degrees. |
+
+
+#### Methods
+
+``static LensSettings FromCamera(Camera fromCamera)``
+
+Creates a new LensSettings, copying the values from the supplied Camera.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **fromCamera** | Camera | The Camera from which the FoV, near and far clip planes will be copied. |
+
+``static LensSettings Lerp(LensSettings lensA, LensSettings lensB, Single t)``
+
+Linearly blends the fields of two LensSettings and returns the result.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **lensA** | LensSettings | The LensSettings to blend from. |
+| **lensB** | LensSettings | The LensSettings to blend to. |
+| **t** | Single | The interpolation value. Internally clamped to the range [0,1]. |
+
+_Returns:_ Interpolated settings.
+``Void Validate()``
+
+Make sure lens settings are sane. Call this from OnValidate().
+
+
+
+### NoiseSettings
+
+_Type:_ class
+
+_Namespace:_ Cinemachine
+
+_Inherits:_ ScriptableObject
+
+
+This is an asset that defines a noise profile. A noise profile is the shape of the noise as a function of time. You can build arbitrarily complex shapes by combining different base perlin noise frequencies at different amplitudes.
+
+The frequencies and amplitudes should be chosen with care, to ensure an interesting noise quality that is not obviously repetitive.
+
+As a mathematical side-note, any arbitrary periodic curve can be broken down into a series of fixed-amplitude sine-waves added together. This is called fourier decomposition, and is the basis of much signal processing. It doesn't really have much to do with this asset, but it's super interesting!
+
+#### Properties
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **PositionNoise** | TransformNoiseParams[] | _[Get]_ Gets the array of positional noise channels for this NoiseSettings. |
+| **OrientationNoise** | TransformNoiseParams[] | _[Get]_ Gets the array of orientation noise channels for this NoiseSettings. |
+
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **m_Position** | TransformNoiseParams[] | These are the noise channels for the virtual camera's position. Convincing noise setups typically mix low, medium and high frequencies together, so start with a size of 3. |
+| **m_Orientation** | TransformNoiseParams[] | These are the noise channels for the virtual camera's orientation. Convincing noise setups typically mix low, medium and high frequencies together, so start with a size of 3. |
+
+
+#### Methods
+
+``Void CopyFrom(NoiseSettings other)``
+
+Clones the contents of the other asset into this one.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **other** | NoiseSettings | |
+
+``static Vector3 GetCombinedFilterResults(TransformNoiseParams[] noiseParams, Single time, Vector3 timeOffsets)``
+
+Get the noise signal value at a specific time.
+
+
+| _Param_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **noiseParams** | TransformNoiseParams[] | The parameters that define the noise function. |
+| **time** | Single | The time at which to sample the noise function. |
+| **timeOffsets** | Vector3 | Start time offset for each channel. |
+
+_Returns:_ The 3-channel noise signal value at the specified time.
+
+
+### NoiseSettings.NoiseParams
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Describes the behaviour for a channel of noise.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **Amplitude** | Single | The amplitude of the noise for this channel. Larger numbers vibrate higher. |
+| **Frequency** | Single | The frequency of noise for this channel. Higher magnitudes vibrate faster. |
+
+
+
+### NoiseSettings.TransformNoiseParams
+
+_Type:_ struct
+
+_Namespace:_ Cinemachine
+
+
+Contains the behaviour of noise for the noise module for all 3 cardinal axes of the camera.
+
+#### Fields
+
+
+| _Name_ | _Type_ | _Description_ |
+| --- | --- | --- |
+| **X** | NoiseParams | Noise definition for X-axis. |
+| **Y** | NoiseParams | Noise definition for Y-axis. |
+| **Z** | NoiseParams | Noise definition for Z-axis. |
+
+
--- /dev/null
+# Cinemachine Documentation
+
+
+
+Cinemachine is a suite of modules for operating the Unity camera. Cinemachine solves the complex mathematics and logic of tracking targets, composing, blending, and cutting between shots. It is designed to significantly reduce the number of time-consuming manual manipulations and script revisions that take place during development.
+
+The procedural nature of these modules makes Cinemachine bug-resistant. When you make adjustments—for example, change an animation, vehicle speed, terrain, or other GameObjects in your Scene—Cinemachine dynamically adjusts its behavior to make the best shot. There is no need, for example, to re-write camera scripts just because a character turns left instead of right.
+
+Cinemachine works in real time across all genres including FPS, third person, 2D, side-scroller, top down, and RTS. It supports as many shots in your Scene as you need. Its modular system lets you compose sophisticated behaviors.
+
+Cinemachine works well with other Unity tools, acting as a powerful complement to Timeline, animation, and post-processing assets. Create your own [extensions](CinemachineVirtualCameraExtensions.html) or integrate it with your custom camera scripts.
+
+## Requirements
+
+Cinemachine has no external dependencies. Just install it and start using it. If you are also using the Post Processing Stack (version 2), then adapter modules are provided - protected by `ifdef` directives which auto-define if the presence of the Post Processing Stack is detected.
+
+This Cinemachine version 2.2 is compatible with the following versions of the Unity Editor:
+
+* 2017.1 and later
--- /dev/null
+fileFormatVersion: 2
+guid: d8623b6a09cb5ab4ea2c51347a3a074c
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 6b46e8ffe448f084ab12938cb774d063
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineBasicMultiChannelPerlin))]
+ internal sealed class CinemachineBasicMultiChannelPerlinEditor
+ : BaseEditor<CinemachineBasicMultiChannelPerlin>
+ {
+ private void OnEnable()
+ {
+ NoiseSettingsPropertyDrawer.InvalidateProfileList();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (FindProperty(x => x.m_NoiseProfile).objectReferenceValue == null)
+ EditorGUILayout.HelpBox(
+ "A Noise Profile is required. You may choose from among the NoiseSettings assets defined in the project.",
+ MessageType.Warning);
+ DrawRemainingPropertiesInInspector();
+
+ Rect rect = EditorGUILayout.GetControlRect(true);
+ rect.width -= EditorGUIUtility.labelWidth; rect.x += EditorGUIUtility.labelWidth;
+ if (GUI.Button(rect, "New random seed"))
+ Target.ReSeed();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: ee42f1964a0e8224c90be81905946699
+timeCreated: 1484091313
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineBlendListCamera))]
+ internal sealed class CinemachineBlendListCameraEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineBlendListCamera>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_Instructions));
+ return excluded;
+ }
+
+ private UnityEditorInternal.ReorderableList mChildList;
+ private UnityEditorInternal.ReorderableList mInstructionList;
+
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ mChildList = null;
+ mInstructionList = null;
+ }
+
+ protected override void OnDisable()
+ {
+ base.OnDisable();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (mInstructionList == null)
+ SetupInstructionList();
+ if (mChildList == null)
+ SetupChildList();
+
+ // Ordinary properties
+ DrawHeaderInInspector();
+ DrawPropertyInInspector(FindProperty(x => x.m_Priority));
+ DrawTargetsInInspector(FindProperty(x => x.m_Follow), FindProperty(x => x.m_LookAt));
+ DrawRemainingPropertiesInInspector();
+
+ // Instructions
+ UpdateCameraCandidates();
+ EditorGUI.BeginChangeCheck();
+ EditorGUILayout.Separator();
+ mInstructionList.DoLayoutList();
+
+ // vcam children
+ EditorGUILayout.Separator();
+ mChildList.DoLayoutList();
+ if (EditorGUI.EndChangeCheck())
+ {
+ serializedObject.ApplyModifiedProperties();
+ Target.ValidateInstructions();
+ }
+
+ // Extensions
+ DrawExtensionsWidgetInInspector();
+ }
+
+ private string[] mCameraCandidates;
+ private Dictionary<CinemachineVirtualCameraBase, int> mCameraIndexLookup;
+ private void UpdateCameraCandidates()
+ {
+ List<string> vcams = new List<string>();
+ mCameraIndexLookup = new Dictionary<CinemachineVirtualCameraBase, int>();
+ vcams.Add("(none)");
+ CinemachineVirtualCameraBase[] children = Target.ChildCameras;
+ foreach (var c in children)
+ {
+ mCameraIndexLookup[c] = vcams.Count;
+ vcams.Add(c.Name);
+ }
+ mCameraCandidates = vcams.ToArray();
+ }
+
+ private int GetCameraIndex(Object obj)
+ {
+ if (obj == null || mCameraIndexLookup == null)
+ return 0;
+ CinemachineVirtualCameraBase vcam = obj as CinemachineVirtualCameraBase;
+ if (vcam == null)
+ return 0;
+ if (!mCameraIndexLookup.ContainsKey(vcam))
+ return 0;
+ return mCameraIndexLookup[vcam];
+ }
+
+ void SetupInstructionList()
+ {
+ mInstructionList = new UnityEditorInternal.ReorderableList(serializedObject,
+ serializedObject.FindProperty(() => Target.m_Instructions),
+ true, true, true, true);
+
+ // Needed for accessing field names as strings
+ CinemachineBlendListCamera.Instruction def = new CinemachineBlendListCamera.Instruction();
+
+ float vSpace = 2;
+ float hSpace = 3;
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 2.5f;
+ float hBigSpace = EditorGUIUtility.singleLineHeight * 2 / 3;
+ mInstructionList.drawHeaderCallback = (Rect rect) =>
+ {
+ float sharedWidth = rect.width - EditorGUIUtility.singleLineHeight
+ - floatFieldWidth - hSpace - hBigSpace;
+ rect.x += EditorGUIUtility.singleLineHeight; rect.width = sharedWidth / 2;
+ EditorGUI.LabelField(rect, "Child");
+
+ rect.x += rect.width + hSpace;
+ EditorGUI.LabelField(rect, "Blend in");
+
+ rect.x += rect.width + hBigSpace; rect.width = floatFieldWidth;
+ EditorGUI.LabelField(rect, "Hold");
+ };
+
+ mInstructionList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ SerializedProperty instProp = mInstructionList.serializedProperty.GetArrayElementAtIndex(index);
+ float sharedWidth = rect.width - floatFieldWidth - hSpace - hBigSpace;
+ rect.y += vSpace; rect.height = EditorGUIUtility.singleLineHeight;
+
+ rect.width = sharedWidth / 2;
+ SerializedProperty vcamSelProp = instProp.FindPropertyRelative(() => def.m_VirtualCamera);
+ int currentVcam = GetCameraIndex(vcamSelProp.objectReferenceValue);
+ int vcamSelection = EditorGUI.Popup(rect, currentVcam, mCameraCandidates);
+ if (currentVcam != vcamSelection)
+ vcamSelProp.objectReferenceValue = (vcamSelection == 0)
+ ? null : Target.ChildCameras[vcamSelection - 1];
+
+ rect.x += rect.width + hSpace; rect.width = sharedWidth / 2;
+ if (index > 0 || Target.m_Loop)
+ EditorGUI.PropertyField(rect, instProp.FindPropertyRelative(() => def.m_Blend),
+ GUIContent.none);
+
+ if (index < mInstructionList.count - 1 || Target.m_Loop)
+ {
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = hBigSpace;
+
+ rect.x += rect.width; rect.width = floatFieldWidth + hBigSpace;
+ SerializedProperty holdProp = instProp.FindPropertyRelative(() => def.m_Hold);
+ EditorGUI.PropertyField(rect, holdProp, new GUIContent(" ", holdProp.tooltip));
+ holdProp.floatValue = Mathf.Max(holdProp.floatValue, 0);
+
+ EditorGUIUtility.labelWidth = oldWidth;
+ }
+ };
+ }
+
+ void SetupChildList()
+ {
+ float vSpace = 2;
+ mChildList = new UnityEditorInternal.ReorderableList(serializedObject,
+ serializedObject.FindProperty(() => Target.m_ChildCameras),
+ true, true, true, true);
+
+ mChildList.drawHeaderCallback = (Rect rect) =>
+ {
+ EditorGUI.LabelField(rect, "Virtual Camera Children");
+ };
+ mChildList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ rect.y += vSpace;
+ Vector2 pos = rect.position;
+ rect.height = EditorGUIUtility.singleLineHeight;
+ SerializedProperty element
+ = mChildList.serializedProperty.GetArrayElementAtIndex(index);
+ EditorGUI.PropertyField(rect, element, GUIContent.none);
+ };
+ mChildList.onChangedCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ if (l.index < 0 || l.index >= l.serializedProperty.arraySize)
+ return;
+ Object o = l.serializedProperty.GetArrayElementAtIndex(
+ l.index).objectReferenceValue;
+ CinemachineVirtualCameraBase vcam = (o != null)
+ ? (o as CinemachineVirtualCameraBase) : null;
+ if (vcam != null)
+ vcam.transform.SetSiblingIndex(l.index);
+ };
+ mChildList.onAddCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ var index = l.serializedProperty.arraySize;
+ var vcam = CinemachineMenu.CreateDefaultVirtualCamera();
+ Undo.SetTransformParent(vcam.transform, Target.transform, "");
+ vcam.transform.SetSiblingIndex(index);
+ };
+ mChildList.onRemoveCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ Object o = l.serializedProperty.GetArrayElementAtIndex(
+ l.index).objectReferenceValue;
+ CinemachineVirtualCameraBase vcam = (o != null)
+ ? (o as CinemachineVirtualCameraBase) : null;
+ if (vcam != null)
+ Undo.DestroyObjectImmediate(vcam.gameObject);
+ };
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 0181db608628b494d8ae50728e507ce1
+timeCreated: 1509479768
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using UnityEditorInternal;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineBlenderSettings))]
+ internal sealed class CinemachineBlenderSettingsEditor : BaseEditor<CinemachineBlenderSettings>
+ {
+ private ReorderableList mBlendList;
+
+ /// <summary>
+ /// Called when building the Camera popup menus, to get the domain of possible
+ /// cameras. If no delegate is set, will find all top-level (non-slave)
+ /// virtual cameras in the scene.
+ /// </summary>
+ public GetAllVirtualCamerasDelegate GetAllVirtualCameras;
+ public delegate CinemachineVirtualCameraBase[] GetAllVirtualCamerasDelegate();
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_CustomBlends));
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (mBlendList == null)
+ SetupBlendList();
+
+ DrawRemainingPropertiesInInspector();
+
+ UpdateCameraCandidates();
+ mBlendList.DoLayoutList();
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ private string[] mCameraCandidates;
+ private Dictionary<string, int> mCameraIndexLookup;
+ private void UpdateCameraCandidates()
+ {
+ List<string> vcams = new List<string>();
+ mCameraIndexLookup = new Dictionary<string, int>();
+
+ CinemachineVirtualCameraBase[] candidates;
+ if (GetAllVirtualCameras != null)
+ candidates = GetAllVirtualCameras();
+ else
+ {
+ // Get all top-level (i.e. non-slave) virtual cameras
+ candidates = Resources.FindObjectsOfTypeAll(
+ typeof(CinemachineVirtualCameraBase)) as CinemachineVirtualCameraBase[];
+
+ for (int i = 0; i < candidates.Length; ++i)
+ if (candidates[i].ParentCamera != null)
+ candidates[i] = null;
+ }
+ vcams.Add("(none)");
+ vcams.Add(CinemachineBlenderSettings.kBlendFromAnyCameraLabel);
+ foreach (CinemachineVirtualCameraBase c in candidates)
+ if (c != null && !vcams.Contains(c.Name))
+ vcams.Add(c.Name);
+
+ mCameraCandidates = vcams.ToArray();
+ for (int i = 0; i < mCameraCandidates.Length; ++i)
+ mCameraIndexLookup[mCameraCandidates[i]] = i;
+ }
+
+ private int GetCameraIndex(string name)
+ {
+ if (name == null || mCameraIndexLookup == null)
+ return 0;
+ if (!mCameraIndexLookup.ContainsKey(name))
+ return 0;
+ return mCameraIndexLookup[name];
+ }
+
+ void SetupBlendList()
+ {
+ mBlendList = new ReorderableList(serializedObject,
+ serializedObject.FindProperty(() => Target.m_CustomBlends),
+ true, true, true, true);
+
+ // Needed for accessing string names of fields
+ CinemachineBlenderSettings.CustomBlend def = new CinemachineBlenderSettings.CustomBlend();
+ CinemachineBlendDefinition def2 = new CinemachineBlendDefinition();
+
+ float vSpace = 2;
+ float hSpace = 3;
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 2.5f;
+ mBlendList.drawHeaderCallback = (Rect rect) =>
+ {
+ rect.width -= (EditorGUIUtility.singleLineHeight + 2 * hSpace);
+ rect.width /= 3;
+ Vector2 pos = rect.position; pos.x += EditorGUIUtility.singleLineHeight;
+ rect.position = pos;
+ EditorGUI.LabelField(rect, "From");
+
+ pos.x += rect.width + hSpace; rect.position = pos;
+ EditorGUI.LabelField(rect, "To");
+
+ pos.x += rect.width + hSpace; rect.width -= floatFieldWidth + hSpace; rect.position = pos;
+ EditorGUI.LabelField(rect, "Style");
+
+ pos.x += rect.width + hSpace; rect.width = floatFieldWidth; rect.position = pos;
+ EditorGUI.LabelField(rect, "Time");
+ };
+
+ mBlendList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ SerializedProperty element
+ = mBlendList.serializedProperty.GetArrayElementAtIndex(index);
+
+ rect.y += vSpace;
+ rect.height = EditorGUIUtility.singleLineHeight;
+ Vector2 pos = rect.position;
+ rect.width -= 2 * hSpace; rect.width /= 3;
+ SerializedProperty fromProp = element.FindPropertyRelative(() => def.m_From);
+ int current = GetCameraIndex(fromProp.stringValue);
+ int sel = EditorGUI.Popup(rect, current, mCameraCandidates);
+ if (current != sel)
+ fromProp.stringValue = mCameraCandidates[sel];
+
+ pos.x += rect.width + hSpace; rect.position = pos;
+ SerializedProperty toProp = element.FindPropertyRelative(() => def.m_To);
+ current = GetCameraIndex(toProp.stringValue);
+ sel = EditorGUI.Popup(rect, current, mCameraCandidates);
+ if (current != sel)
+ toProp.stringValue = mCameraCandidates[sel];
+
+ SerializedProperty blendProp = element.FindPropertyRelative(() => def.m_Blend);
+ pos.x += rect.width + hSpace; rect.position = pos;
+ EditorGUI.PropertyField(rect, blendProp, GUIContent.none);
+ };
+
+ mBlendList.onAddCallback = (ReorderableList l) =>
+ {
+ var index = l.serializedProperty.arraySize;
+ ++l.serializedProperty.arraySize;
+ SerializedProperty blendProp = l.serializedProperty.GetArrayElementAtIndex(
+ index).FindPropertyRelative(() => def.m_Blend);
+
+ blendProp.FindPropertyRelative(() => def2.m_Style).enumValueIndex
+ = (int)CinemachineBlendDefinition.Style.EaseInOut;
+ blendProp.FindPropertyRelative(() => def2.m_Time).floatValue = 2f;
+ };
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 1ff9d8296ed1f02419bf4f417ff2265e
+timeCreated: 1486495673
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+using System.IO;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineBrain))]
+ public sealed class CinemachineBrainEditor : BaseEditor<CinemachineBrain>
+ {
+ EmbeddeAssetEditor<CinemachineBlenderSettings> m_BlendsEditor;
+ bool mEventsExpanded = false;
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_CameraCutEvent));
+ excluded.Add(FieldPath(x => x.m_CameraActivatedEvent));
+ excluded.Add(FieldPath(x => x.m_CustomBlends));
+ return excluded;
+ }
+
+ private void OnEnable()
+ {
+ m_BlendsEditor = new EmbeddeAssetEditor<CinemachineBlenderSettings>(
+ FieldPath(x => x.m_CustomBlends), this);
+ m_BlendsEditor.OnChanged = (CinemachineBlenderSettings b) =>
+ {
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ };
+ }
+
+ private void OnDisable()
+ {
+ if (m_BlendsEditor != null)
+ m_BlendsEditor.OnDisable();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+
+ // Show the active camera and blend
+ GUI.enabled = false;
+ ICinemachineCamera vcam = Target.ActiveVirtualCamera;
+ Transform activeCam = (vcam != null && vcam.VirtualCameraGameObject != null)
+ ? vcam.VirtualCameraGameObject.transform : null;
+ EditorGUILayout.ObjectField("Live Camera", activeCam, typeof(Transform), true);
+ EditorGUILayout.DelayedTextField(
+ "Live Blend", Target.ActiveBlend != null
+ ? Target.ActiveBlend.Description : string.Empty);
+ GUI.enabled = true;
+
+ // Normal properties
+ DrawRemainingPropertiesInInspector();
+
+ // Blender
+ m_BlendsEditor.DrawEditorCombo(
+ "Create New Blender Asset",
+ Target.gameObject.name + " Blends", "asset", string.Empty,
+ "Custom Blends", false);
+
+ mEventsExpanded = EditorGUILayout.Foldout(mEventsExpanded, "Events", true);
+ if (mEventsExpanded)
+ {
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_CameraCutEvent));
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_CameraActivatedEvent));
+ }
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ [DrawGizmo(GizmoType.Selected | GizmoType.NonSelected, typeof(CinemachineBrain))]
+ private static void DrawBrainGizmos(CinemachineBrain brain, GizmoType drawType)
+ {
+ if (brain.OutputCamera != null && brain.m_ShowCameraFrustum)
+ {
+ DrawCameraFrustumGizmo(
+ brain, LensSettings.FromCamera(brain.OutputCamera),
+ brain.transform.localToWorldMatrix,
+ Color.white); // GML why is this color hardcoded?
+ }
+ }
+
+ internal static void DrawCameraFrustumGizmo(
+ CinemachineBrain brain, LensSettings lens,
+ Matrix4x4 transform, Color color)
+ {
+ float aspect = 1;
+ bool ortho = false;
+ if (brain != null)
+ {
+ aspect = brain.OutputCamera.aspect;
+ ortho = brain.OutputCamera.orthographic;
+ }
+
+ Matrix4x4 originalMatrix = Gizmos.matrix;
+ Color originalGizmoColour = Gizmos.color;
+ Gizmos.color = color;
+ Gizmos.matrix = transform;
+ if (ortho)
+ {
+ Vector3 size = new Vector3(
+ aspect * lens.OrthographicSize * 2,
+ lens.OrthographicSize * 2,
+ lens.NearClipPlane + lens.FarClipPlane);
+ Gizmos.DrawWireCube(
+ new Vector3(0, 0, (size.z / 2) + lens.NearClipPlane), size);
+ }
+ else
+ {
+ Gizmos.DrawFrustum(
+ Vector3.zero, lens.FieldOfView,
+ lens.FarClipPlane, lens.NearClipPlane, aspect);
+ }
+ Gizmos.matrix = originalMatrix;
+ Gizmos.color = originalGizmoColour;
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.InSelectionHierarchy | GizmoType.Pickable, typeof(CinemachineVirtualCameraBase))]
+ public static void DrawVirtualCameraBaseGizmos(CinemachineVirtualCameraBase vcam, GizmoType selectionType)
+ {
+ // Don't draw gizmos on hidden stuff
+ if ((vcam.gameObject.hideFlags & (HideFlags.HideInHierarchy | HideFlags.HideInInspector)) != 0)
+ return;
+
+ if (vcam.ParentCamera != null && (selectionType & GizmoType.Active) == 0)
+ return;
+
+ CameraState state = vcam.State;
+ Gizmos.DrawIcon(state.FinalPosition, kGizmoFileName, true);
+
+ DrawCameraFrustumGizmo(
+ CinemachineCore.Instance.FindPotentialTargetBrain(vcam),
+ state.Lens,
+ Matrix4x4.TRS(
+ state.FinalPosition,
+ UnityQuaternionExtensions.Normalized(state.FinalOrientation), Vector3.one),
+ CinemachineCore.Instance.IsLive(vcam)
+ ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour
+ : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour);
+ }
+
+ static string kGizmoFileName = "Packages/com.unity.cinemachine/Gizmos/cm_logo.png";
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 711aad28b4057bd4783120e26ff2ee25
+timeCreated: 1483406727
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineClearShot))]
+ internal sealed class CinemachineClearShotEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineClearShot>
+ {
+ EmbeddeAssetEditor<CinemachineBlenderSettings> m_BlendsEditor;
+ ColliderState m_ColliderState;
+
+ private UnityEditorInternal.ReorderableList mChildList;
+
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ m_BlendsEditor = new EmbeddeAssetEditor<CinemachineBlenderSettings>(
+ FieldPath(x => x.m_CustomBlends), this);
+ m_BlendsEditor.OnChanged = (CinemachineBlenderSettings b) =>
+ {
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ };
+ m_BlendsEditor.OnCreateEditor = (UnityEditor.Editor ed) =>
+ {
+ CinemachineBlenderSettingsEditor editor = ed as CinemachineBlenderSettingsEditor;
+ if (editor != null)
+ editor.GetAllVirtualCameras = () => { return Target.ChildCameras; };
+ };
+ mChildList = null;
+ }
+
+ protected override void OnDisable()
+ {
+ base.OnDisable();
+ if (m_BlendsEditor != null)
+ m_BlendsEditor.OnDisable();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (mChildList == null)
+ SetupChildList();
+
+ m_ColliderState = GetColliderState();
+ switch (m_ColliderState)
+ {
+ case ColliderState.ColliderOnParent:
+ case ColliderState.ColliderOnAllChildren:
+ break;
+ case ColliderState.NoCollider:
+ EditorGUILayout.HelpBox(
+ "ClearShot requires a Collider extension to rank the shots. Either add one to the ClearShot itself, or to each of the child cameras.",
+ MessageType.Warning);
+ break;
+ case ColliderState.ColliderOnSomeChildren:
+ EditorGUILayout.HelpBox(
+ "Some child cameras do not have a Collider extension. ClearShot requires a Collider on all the child cameras, or alternatively on the ClearShot iself.",
+ MessageType.Warning);
+ break;
+ case ColliderState.ColliderOnChildrenAndParent:
+ EditorGUILayout.HelpBox(
+ "There is a Collider extension on the ClearShot camera, and also on some of its child cameras. You can't have both.",
+ MessageType.Error);
+ break;
+ }
+
+ DrawHeaderInInspector();
+ DrawPropertyInInspector(FindProperty(x => x.m_Priority));
+ DrawTargetsInInspector(FindProperty(x => x.m_Follow), FindProperty(x => x.m_LookAt));
+ DrawRemainingPropertiesInInspector();
+
+ // Blends
+ m_BlendsEditor.DrawEditorCombo(
+ "Create New Blender Asset",
+ Target.gameObject.name + " Blends", "asset", string.Empty,
+ "Custom Blends", false);
+
+ // vcam children
+ EditorGUILayout.Separator();
+ EditorGUI.BeginChangeCheck();
+ mChildList.DoLayoutList();
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+
+ // Extensions
+ DrawExtensionsWidgetInInspector();
+ }
+
+ enum ColliderState
+ {
+ NoCollider,
+ ColliderOnAllChildren,
+ ColliderOnSomeChildren,
+ ColliderOnParent,
+ ColliderOnChildrenAndParent
+ }
+
+ ColliderState GetColliderState()
+ {
+ int numChildren = 0;
+ int numColliderChildren = 0;
+ bool colliderOnParent = ObjectHasCollider(Target);
+
+ var children = Target.m_ChildCameras;
+ numChildren = children == null ? 0 : children.Length;
+ for (int i = 0; i < numChildren; ++i)
+ if (ObjectHasCollider(children[i]))
+ ++numColliderChildren;
+ if (colliderOnParent)
+ return (numColliderChildren > 0)
+ ? ColliderState.ColliderOnChildrenAndParent : ColliderState.ColliderOnParent;
+ if (numColliderChildren > 0)
+ return (numColliderChildren == numChildren)
+ ? ColliderState.ColliderOnAllChildren : ColliderState.ColliderOnSomeChildren;
+ return ColliderState.NoCollider;
+ }
+
+ bool ObjectHasCollider(object obj)
+ {
+ CinemachineVirtualCameraBase vcam = obj as CinemachineVirtualCameraBase;
+ var collider = (vcam == null) ? null : vcam.GetComponent<CinemachineCollider>();
+ return (collider != null && collider.enabled);
+ }
+
+ void SetupChildList()
+ {
+ float vSpace = 2;
+ float hSpace = 3;
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 2.5f;
+
+ mChildList = new UnityEditorInternal.ReorderableList(
+ serializedObject, FindProperty(x => x.m_ChildCameras), true, true, true, true);
+
+ mChildList.drawHeaderCallback = (Rect rect) =>
+ {
+ EditorGUI.LabelField(rect, "Virtual Camera Children");
+ GUIContent priorityText = new GUIContent("Priority");
+ var textDimensions = GUI.skin.label.CalcSize(priorityText);
+ rect.x += rect.width - textDimensions.x;
+ rect.width = textDimensions.x;
+ EditorGUI.LabelField(rect, priorityText);
+ };
+ mChildList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ rect.y += vSpace;
+ rect.width -= floatFieldWidth + hSpace;
+ rect.height = EditorGUIUtility.singleLineHeight;
+ SerializedProperty element = mChildList.serializedProperty.GetArrayElementAtIndex(index);
+ if (m_ColliderState == ColliderState.ColliderOnSomeChildren
+ || m_ColliderState == ColliderState.ColliderOnChildrenAndParent)
+ {
+ bool hasCollider = ObjectHasCollider(element.objectReferenceValue);
+ if ((m_ColliderState == ColliderState.ColliderOnSomeChildren && !hasCollider)
+ || (m_ColliderState == ColliderState.ColliderOnChildrenAndParent && hasCollider))
+ {
+ float width = rect.width;
+ rect.width = rect.height;
+ GUIContent label = new GUIContent("");
+ label.image = EditorGUIUtility.IconContent("console.warnicon.sml").image;
+ EditorGUI.LabelField(rect, label);
+ width -= rect.width; rect.x += rect.width; rect.width = width;
+ }
+ }
+ EditorGUI.PropertyField(rect, element, GUIContent.none);
+
+ SerializedObject obj = new SerializedObject(element.objectReferenceValue);
+ rect.x += rect.width + hSpace; rect.width = floatFieldWidth;
+ SerializedProperty priorityProp = obj.FindProperty(() => Target.m_Priority);
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = hSpace * 2;
+ EditorGUI.PropertyField(rect, priorityProp, new GUIContent(" "));
+ EditorGUIUtility.labelWidth = oldWidth;
+ obj.ApplyModifiedProperties();
+ };
+ mChildList.onChangedCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ if (l.index < 0 || l.index >= l.serializedProperty.arraySize)
+ return;
+ Object o = l.serializedProperty.GetArrayElementAtIndex(
+ l.index).objectReferenceValue;
+ CinemachineVirtualCameraBase vcam = (o != null)
+ ? (o as CinemachineVirtualCameraBase) : null;
+ if (vcam != null)
+ vcam.transform.SetSiblingIndex(l.index);
+ };
+ mChildList.onAddCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ var index = l.serializedProperty.arraySize;
+ var vcam = CinemachineMenu.CreateDefaultVirtualCamera();
+ Undo.SetTransformParent(vcam.transform, Target.transform, "");
+ var collider = Undo.AddComponent<CinemachineCollider>(vcam.gameObject);
+ collider.m_AvoidObstacles = false;
+ Undo.RecordObject(collider, "create ClearShot child");
+ vcam.transform.SetSiblingIndex(index);
+ };
+ mChildList.onRemoveCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ Object o = l.serializedProperty.GetArrayElementAtIndex(
+ l.index).objectReferenceValue;
+ CinemachineVirtualCameraBase vcam = (o != null)
+ ? (o as CinemachineVirtualCameraBase) : null;
+ if (vcam != null)
+ Undo.DestroyObjectImmediate(vcam.gameObject);
+ };
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 6036af5730313e54699c5a693891fe90
+timeCreated: 1484508430
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_PHYSICS
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineCollider))]
+ internal sealed class CinemachineColliderEditor : BaseEditor<CinemachineCollider>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ if (!Target.m_AvoidObstacles)
+ {
+ excluded.Add(FieldPath(x => x.m_DistanceLimit));
+ excluded.Add(FieldPath(x => x.m_CameraRadius));
+ excluded.Add(FieldPath(x => x.m_Strategy));
+ excluded.Add(FieldPath(x => x.m_MaximumEffort));
+ excluded.Add(FieldPath(x => x.m_Damping));
+ excluded.Add(FieldPath(x => x.m_DampingWhenOccluded));
+ excluded.Add(FieldPath(x => x.m_SmoothingTime));
+ }
+ else if (Target.m_Strategy == CinemachineCollider.ResolutionStrategy.PullCameraForward)
+ {
+ excluded.Add(FieldPath(x => x.m_MaximumEffort));
+ }
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+
+ if (Target.m_AvoidObstacles && !Target.VirtualCamera.State.HasLookAt)
+ EditorGUILayout.HelpBox(
+ "Avoid Obstacles requires a LookAt target.",
+ MessageType.Warning);
+
+ DrawRemainingPropertiesInInspector();
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.Selected, typeof(CinemachineCollider))]
+ private static void DrawColliderGizmos(CinemachineCollider collider, GizmoType type)
+ {
+ CinemachineVirtualCameraBase vcam = (collider != null) ? collider.VirtualCamera : null;
+ if (vcam != null && collider.enabled)
+ {
+ Color oldColor = Gizmos.color;
+ Vector3 pos = vcam.State.FinalPosition;
+ if (collider.m_AvoidObstacles && vcam.State.HasLookAt)
+ {
+ Gizmos.color = CinemachineColliderPrefs.FeelerColor;
+ if (collider.m_CameraRadius > 0)
+ Gizmos.DrawWireSphere(pos, collider.m_CameraRadius);
+
+ Vector3 forwardFeelerVector = (vcam.State.ReferenceLookAt - pos).normalized;
+ float distance = collider.m_DistanceLimit;
+ Gizmos.DrawLine(pos, pos + forwardFeelerVector * distance);
+
+ // Show the avoidance path, for debugging
+ List<List<Vector3>> debugPaths = collider.DebugPaths;
+ foreach (var path in debugPaths)
+ {
+ Gizmos.color = CinemachineColliderPrefs.FeelerHitColor;
+ Vector3 p0 = vcam.State.ReferenceLookAt;
+ foreach (var p in path)
+ {
+ Gizmos.DrawLine(p0, p);
+ p0 = p;
+ }
+ Gizmos.DrawLine(p0, pos);
+ }
+ }
+ Gizmos.color = oldColor;
+ }
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: bf34fbe7a6e71634493d770ed0031f9d
+timeCreated: 1486652356
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using Cinemachine.Utility;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineComposer))]
+ internal class CinemachineComposerEditor : BaseEditor<CinemachineComposer>
+ {
+ CinemachineScreenComposerGuides mScreenGuideEditor;
+
+ protected virtual void OnEnable()
+ {
+ mScreenGuideEditor = new CinemachineScreenComposerGuides();
+ mScreenGuideEditor.GetHardGuide = () => { return Target.HardGuideRect; };
+ mScreenGuideEditor.GetSoftGuide = () => { return Target.SoftGuideRect; };
+ mScreenGuideEditor.SetHardGuide = (Rect r) => { Target.HardGuideRect = r; };
+ mScreenGuideEditor.SetSoftGuide = (Rect r) => { Target.SoftGuideRect = r; };
+ mScreenGuideEditor.Target = () => { return serializedObject; };
+
+ CinemachineDebug.OnGUIHandlers -= OnGUI;
+ CinemachineDebug.OnGUIHandlers += OnGUI;
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+
+ protected virtual void OnDisable()
+ {
+ CinemachineDebug.OnGUIHandlers -= OnGUI;
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (Target.LookAtTarget == null)
+ EditorGUILayout.HelpBox(
+ "A LookAt target is required. Change Aim to Do Nothing if you don't want a LookAt target.",
+ MessageType.Warning);
+
+ // First snapshot some settings
+ Rect oldHard = Target.HardGuideRect;
+ Rect oldSoft = Target.SoftGuideRect;
+
+ // Draw the properties
+ DrawRemainingPropertiesInInspector();
+ mScreenGuideEditor.SetNewBounds(oldHard, oldSoft, Target.HardGuideRect, Target.SoftGuideRect);
+ }
+
+ protected virtual void OnGUI()
+ {
+ if (Target == null)
+ return;
+
+ // Draw the camera guides
+ if (!Target.IsValid || !CinemachineSettings.CinemachineCoreSettings.ShowInGameGuides)
+ return;
+
+ var vcam = Target.VirtualCamera;
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(vcam);
+ if (brain == null || (brain.OutputCamera.activeTexture != null && CinemachineCore.Instance.BrainCount > 1))
+ return;
+
+ // Screen guides
+ bool isLive = brain.IsLive(vcam, true);
+ mScreenGuideEditor.OnGUI_DrawGuides(isLive, brain.OutputCamera, Target.VcamState.Lens, true);
+
+ // Draw an on-screen gizmo for the target
+ if (Target.LookAtTarget != null && isLive)
+ {
+ Vector3 targetScreenPosition = brain.OutputCamera.WorldToScreenPoint(Target.TrackedPoint);
+ if (targetScreenPosition.z > 0)
+ {
+ targetScreenPosition.y = Screen.height - targetScreenPosition.y;
+
+ GUI.color = CinemachineSettings.ComposerSettings.TargetColour;
+ Rect r = new Rect(targetScreenPosition, Vector2.zero);
+ float size = (CinemachineSettings.ComposerSettings.TargetSize
+ + CinemachineScreenComposerGuides.kGuideBarWidthPx) / 2;
+ GUI.DrawTexture(r.Inflated(new Vector2(size, size)), Texture2D.whiteTexture);
+ size -= CinemachineScreenComposerGuides.kGuideBarWidthPx;
+ if (size > 0)
+ {
+ Vector4 overlayOpacityScalar
+ = new Vector4(1f, 1f, 1f, CinemachineSettings.ComposerSettings.OverlayOpacity);
+ GUI.color = Color.black * overlayOpacityScalar;
+ GUI.DrawTexture(r.Inflated(new Vector2(size, size)), Texture2D.whiteTexture);
+ }
+ }
+ }
+ }
+#if false
+ // debugging only
+ [DrawGizmo(GizmoType.Active | GizmoType.Selected, typeof(CinemachineComposer))]
+ static void DrawTransposerGizmos(CinemachineComposer target, GizmoType selectionType)
+ {
+ // Draw lookahead path
+ if (target.m_LookaheadTime > 0)
+ {
+ Color originalGizmoColour = Gizmos.color;
+ Gizmos.color = CinemachineSettings.ComposerSettings.TargetColour;
+
+ var p0 = target.m_Predictor.PredictPosition(0);
+ int numSteps = 20;
+ for (int i = 1; i <= numSteps; ++i)
+ {
+ var p1 = target.m_Predictor.PredictPosition(i * target.m_LookaheadTime / numSteps);
+ Gizmos.DrawLine(p0, p1);
+ p0 = p1;
+ }
+ Gizmos.color = originalGizmoColour;
+ }
+ }
+#endif
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 2bb09c3bc24a82648a2e4fc008a28d8b
+timeCreated: 1484088329
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS || CINEMACHINE_PHYSICS_2D
+
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineConfiner))]
+ internal sealed class CinemachineConfinerEditor : BaseEditor<CinemachineConfiner>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(Target.VirtualCamera);
+ bool ortho = brain != null ? brain.OutputCamera.orthographic : false;
+ if (!ortho)
+ excluded.Add(FieldPath(x => x.m_ConfineScreenEdges));
+#if CINEMACHINE_PHYSICS && CINEMACHINE_PHYSICS_2D
+ if (Target.m_ConfineMode == CinemachineConfiner.Mode.Confine2D)
+ excluded.Add(FieldPath(x => x.m_BoundingVolume));
+ else
+ excluded.Add(FieldPath(x => x.m_BoundingShape2D));
+#endif
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+#if CINEMACHINE_PHYSICS && CINEMACHINE_PHYSICS_2D
+ if (Target.m_ConfineMode == CinemachineConfiner.Mode.Confine2D)
+ {
+#endif
+#if CINEMACHINE_PHYSICS_2D
+ if (Target.m_BoundingShape2D == null)
+ EditorGUILayout.HelpBox("A Bounding Shape is required.", MessageType.Warning);
+ else if (Target.m_BoundingShape2D.GetType() != typeof(PolygonCollider2D)
+ && Target.m_BoundingShape2D.GetType() != typeof(CompositeCollider2D))
+ {
+ EditorGUILayout.HelpBox(
+ "Must be a PolygonCollider2D or CompositeCollider2D.",
+ MessageType.Warning);
+ }
+ else if (Target.m_BoundingShape2D.GetType() == typeof(CompositeCollider2D))
+ {
+ CompositeCollider2D poly = Target.m_BoundingShape2D as CompositeCollider2D;
+ if (poly.geometryType != CompositeCollider2D.GeometryType.Polygons)
+ {
+ EditorGUILayout.HelpBox(
+ "CompositeCollider2D geometry type must be Polygons",
+ MessageType.Warning);
+ }
+ }
+#endif
+#if CINEMACHINE_PHYSICS && CINEMACHINE_PHYSICS_2D
+ }
+ else
+ {
+#endif
+#if CINEMACHINE_PHYSICS
+ if (Target.m_BoundingVolume == null)
+ EditorGUILayout.HelpBox("A Bounding Volume is required.", MessageType.Warning);
+ else if (Target.m_BoundingVolume.GetType() != typeof(BoxCollider)
+ && Target.m_BoundingVolume.GetType() != typeof(SphereCollider)
+ && Target.m_BoundingVolume.GetType() != typeof(CapsuleCollider))
+ {
+ EditorGUILayout.HelpBox(
+ "Must be a BoxCollider, SphereCollider, or CapsuleCollider.",
+ MessageType.Warning);
+ }
+#endif
+#if CINEMACHINE_PHYSICS && CINEMACHINE_PHYSICS_2D
+ }
+#endif
+ DrawRemainingPropertiesInInspector();
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.Selected, typeof(CinemachineConfiner))]
+ private static void DrawColliderGizmos(CinemachineConfiner confiner, GizmoType type)
+ {
+ CinemachineVirtualCameraBase vcam = (confiner != null) ? confiner.VirtualCamera : null;
+ if (vcam != null && confiner.IsValid)
+ {
+ Matrix4x4 oldMatrix = Gizmos.matrix;
+ Color oldColor = Gizmos.color;
+ Gizmos.color = Color.yellow;
+
+#if CINEMACHINE_PHYSICS && CINEMACHINE_PHYSICS_2D
+ if (confiner.m_ConfineMode == CinemachineConfiner.Mode.Confine3D)
+ {
+#endif
+#if CINEMACHINE_PHYSICS
+ Transform t = confiner.m_BoundingVolume.transform;
+ Gizmos.matrix = Matrix4x4.TRS(t.position, t.rotation, t.lossyScale);
+
+ Type colliderType = confiner.m_BoundingVolume.GetType();
+ if (colliderType == typeof(BoxCollider))
+ {
+ BoxCollider c = confiner.m_BoundingVolume as BoxCollider;
+ Gizmos.DrawWireCube(c.center, c.size);
+ }
+ else if (colliderType == typeof(SphereCollider))
+ {
+ SphereCollider c = confiner.m_BoundingVolume as SphereCollider;
+ Gizmos.DrawWireSphere(c.center, c.radius);
+ }
+ else if (colliderType == typeof(CapsuleCollider))
+ {
+ CapsuleCollider c = confiner.m_BoundingVolume as CapsuleCollider;
+ Vector3 size = Vector3.one * c.radius * 2;
+ switch (c.direction)
+ {
+ case 0: size.x = c.height; break;
+ case 1: size.y = c.height; break;
+ case 2: size.z = c.height; break;
+ }
+ Gizmos.DrawWireCube(c.center, size);
+ }
+ else if (colliderType == typeof(MeshCollider))
+ {
+ MeshCollider c = confiner.m_BoundingVolume as MeshCollider;
+ Gizmos.DrawWireMesh(c.sharedMesh);
+ }
+ else
+ {
+ // Just draw an AABB - not very nice!
+ Gizmos.matrix = oldMatrix;
+ Bounds bounds = confiner.m_BoundingVolume.bounds;
+ Gizmos.DrawWireCube(t.position, bounds.extents * 2);
+ }
+#endif
+#if CINEMACHINE_PHYSICS && CINEMACHINE_PHYSICS_2D
+ }
+ else
+ {
+#endif
+#if CINEMACHINE_PHYSICS_2D
+ Transform t = confiner.m_BoundingShape2D.transform;
+ Gizmos.matrix = Matrix4x4.TRS(t.position, t.rotation, t.lossyScale);
+
+ Type colliderType = confiner.m_BoundingShape2D.GetType();
+ if (colliderType == typeof(PolygonCollider2D))
+ {
+ PolygonCollider2D poly = confiner.m_BoundingShape2D as PolygonCollider2D;
+ for (int i = 0; i < poly.pathCount; ++i)
+ DrawPath(poly.GetPath(i), -1);
+ }
+ else if (colliderType == typeof(CompositeCollider2D))
+ {
+ CompositeCollider2D poly = confiner.m_BoundingShape2D as CompositeCollider2D;
+ Vector2[] path = new Vector2[poly.pointCount];
+ for (int i = 0; i < poly.pathCount; ++i)
+ {
+ int numPoints = poly.GetPath(i, path);
+ DrawPath(path, numPoints);
+ }
+ }
+#endif
+#if CINEMACHINE_PHYSICS && CINEMACHINE_PHYSICS_2D
+ }
+#endif
+ Gizmos.color = oldColor;
+ Gizmos.matrix = oldMatrix;
+ }
+ }
+
+ static void DrawPath(Vector2[] path, int numPoints)
+ {
+ if (numPoints < 0)
+ numPoints = path.Length;
+ if (numPoints > 0)
+ {
+ Vector2 v0 = path[numPoints-1];
+ for (int j = 0; j < numPoints; ++j)
+ {
+ Vector2 v = path[j];
+ Gizmos.DrawLine(v0, v);
+ v0 = v;
+ }
+ }
+ }
+ }
+}
+
+#endif
+
--- /dev/null
+fileFormatVersion: 2
+guid: 3f7c779802a73d5448e38af7c39fbaa5
+timeCreated: 1503423096
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineExternalCamera))]
+ internal class CinemachineExternalCameraEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineExternalCamera>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add("Extensions");
+ return excluded;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 3226d9f88577be74197693bd17cff8c3
+timeCreated: 1506455627
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using Cinemachine.Utility;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineFramingTransposer))]
+ internal class CinemachineFramingTransposerEditor : BaseEditor<CinemachineFramingTransposer>
+ {
+ CinemachineScreenComposerGuides mScreenGuideEditor;
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ if (Target.m_UnlimitedSoftZone)
+ {
+ excluded.Add(FieldPath(x => x.m_SoftZoneWidth));
+ excluded.Add(FieldPath(x => x.m_SoftZoneHeight));
+ excluded.Add(FieldPath(x => x.m_BiasX));
+ excluded.Add(FieldPath(x => x.m_BiasY));
+ }
+ CinemachineTargetGroup group = Target.FollowTargetGroup;
+ if (group == null || Target.m_GroupFramingMode == CinemachineFramingTransposer.FramingMode.None)
+ {
+ excluded.Add(FieldPath(x => x.m_GroupFramingSize));
+ excluded.Add(FieldPath(x => x.m_AdjustmentMode));
+ excluded.Add(FieldPath(x => x.m_MaxDollyIn));
+ excluded.Add(FieldPath(x => x.m_MaxDollyOut));
+ excluded.Add(FieldPath(x => x.m_MinimumDistance));
+ excluded.Add(FieldPath(x => x.m_MaximumDistance));
+ excluded.Add(FieldPath(x => x.m_MinimumFOV));
+ excluded.Add(FieldPath(x => x.m_MaximumFOV));
+ excluded.Add(FieldPath(x => x.m_MinimumOrthoSize));
+ excluded.Add(FieldPath(x => x.m_MaximumOrthoSize));
+ if (group == null)
+ excluded.Add(FieldPath(x => x.m_GroupFramingMode));
+ }
+ else
+ {
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(Target.VirtualCamera);
+ bool ortho = brain != null ? brain.OutputCamera.orthographic : false;
+ if (ortho)
+ {
+ excluded.Add(FieldPath(x => x.m_AdjustmentMode));
+ excluded.Add(FieldPath(x => x.m_MaxDollyIn));
+ excluded.Add(FieldPath(x => x.m_MaxDollyOut));
+ excluded.Add(FieldPath(x => x.m_MinimumDistance));
+ excluded.Add(FieldPath(x => x.m_MaximumDistance));
+ excluded.Add(FieldPath(x => x.m_MinimumFOV));
+ excluded.Add(FieldPath(x => x.m_MaximumFOV));
+ }
+ else
+ {
+ excluded.Add(FieldPath(x => x.m_MinimumOrthoSize));
+ excluded.Add(FieldPath(x => x.m_MaximumOrthoSize));
+ switch (Target.m_AdjustmentMode)
+ {
+ case CinemachineFramingTransposer.AdjustmentMode.DollyOnly:
+ excluded.Add(FieldPath(x => x.m_MinimumFOV));
+ excluded.Add(FieldPath(x => x.m_MaximumFOV));
+ break;
+ case CinemachineFramingTransposer.AdjustmentMode.ZoomOnly:
+ excluded.Add(FieldPath(x => x.m_MaxDollyIn));
+ excluded.Add(FieldPath(x => x.m_MaxDollyOut));
+ excluded.Add(FieldPath(x => x.m_MinimumDistance));
+ excluded.Add(FieldPath(x => x.m_MaximumDistance));
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ return excluded;
+ }
+
+ protected virtual void OnEnable()
+ {
+ mScreenGuideEditor = new CinemachineScreenComposerGuides();
+ mScreenGuideEditor.GetHardGuide = () => { return Target.HardGuideRect; };
+ mScreenGuideEditor.GetSoftGuide = () => { return Target.SoftGuideRect; };
+ mScreenGuideEditor.SetHardGuide = (Rect r) => { Target.HardGuideRect = r; };
+ mScreenGuideEditor.SetSoftGuide = (Rect r) => { Target.SoftGuideRect = r; };
+ mScreenGuideEditor.Target = () => { return serializedObject; };
+
+ CinemachineDebug.OnGUIHandlers -= OnGUI;
+ CinemachineDebug.OnGUIHandlers += OnGUI;
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+
+ protected virtual void OnDisable()
+ {
+ CinemachineDebug.OnGUIHandlers -= OnGUI;
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (Target.FollowTarget == null)
+ EditorGUILayout.HelpBox(
+ "Framing Transposer requires a Follow target. Change Body to Do Nothing if you don't want a Follow target.",
+ MessageType.Warning);
+
+ // First snapshot some settings
+ Rect oldHard = Target.HardGuideRect;
+ Rect oldSoft = Target.SoftGuideRect;
+
+ // Draw the properties
+ DrawRemainingPropertiesInInspector();
+ mScreenGuideEditor.SetNewBounds(oldHard, oldSoft, Target.HardGuideRect, Target.SoftGuideRect);
+ }
+
+ protected virtual void OnGUI()
+ {
+ if (Target == null)
+ return;
+
+ // Draw the camera guides
+ if (!Target.IsValid || !CinemachineSettings.CinemachineCoreSettings.ShowInGameGuides)
+ return;
+
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(Target.VirtualCamera);
+ if (brain == null || (brain.OutputCamera.activeTexture != null && CinemachineCore.Instance.BrainCount > 1))
+ return;
+
+ bool isLive = CinemachineCore.Instance.IsLive(Target.VirtualCamera);
+
+ // Screen guides
+ mScreenGuideEditor.OnGUI_DrawGuides(isLive, brain.OutputCamera, Target.VcamState.Lens, !Target.m_UnlimitedSoftZone);
+
+ // Draw an on-screen gizmo for the target
+ if (Target.FollowTarget != null && isLive)
+ {
+ Vector3 targetScreenPosition = brain.OutputCamera.WorldToScreenPoint(Target.TrackedPoint);
+ if (targetScreenPosition.z > 0)
+ {
+ targetScreenPosition.y = Screen.height - targetScreenPosition.y;
+
+ GUI.color = CinemachineSettings.ComposerSettings.TargetColour;
+ Rect r = new Rect(targetScreenPosition, Vector2.zero);
+ float size = (CinemachineSettings.ComposerSettings.TargetSize
+ + CinemachineScreenComposerGuides.kGuideBarWidthPx) / 2;
+ GUI.DrawTexture(r.Inflated(new Vector2(size, size)), Texture2D.whiteTexture);
+ size -= CinemachineScreenComposerGuides.kGuideBarWidthPx;
+ if (size > 0)
+ {
+ Vector4 overlayOpacityScalar
+ = new Vector4(1f, 1f, 1f, CinemachineSettings.ComposerSettings.OverlayOpacity);
+ GUI.color = Color.black * overlayOpacityScalar;
+ GUI.DrawTexture(r.Inflated(new Vector2(size, size)), Texture2D.whiteTexture);
+ }
+ }
+ }
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.InSelectionHierarchy, typeof(CinemachineFramingTransposer))]
+ private static void DrawGroupComposerGizmos(CinemachineFramingTransposer target, GizmoType selectionType)
+ {
+ // Show the group bounding box, as viewed from the camera position
+ if (target.FollowTargetGroup != null
+ && target.m_GroupFramingMode != CinemachineFramingTransposer.FramingMode.None)
+ {
+ Matrix4x4 m = Gizmos.matrix;
+ Bounds b = target.LastBounds;
+ Gizmos.matrix = target.LastBoundsMatrix;
+ Gizmos.color = Color.yellow;
+ if (target.VcamState.Lens.Orthographic)
+ Gizmos.DrawWireCube(b.center, b.size);
+ else
+ {
+ float z = b.center.z;
+ Vector3 e = b.extents;
+ Gizmos.DrawFrustum(
+ Vector3.zero,
+ Mathf.Atan2(e.y, z) * Mathf.Rad2Deg * 2,
+ z + e.z, z - e.z, e.x / e.y);
+ }
+ Gizmos.matrix = m;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 620aee1bd928b2a4981896c6b4e1bf0d
+timeCreated: 1502046367
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using Cinemachine.Editor;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ [CustomEditor(typeof(CinemachineFreeLook))]
+ internal sealed class CinemachineFreeLookEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineFreeLook>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_Orbits));
+ if (!Target.m_CommonLens)
+ excluded.Add(FieldPath(x => x.m_Lens));
+ if (Target.m_BindingMode == CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp)
+ {
+ excluded.Add(FieldPath(x => x.m_Heading));
+ excluded.Add(FieldPath(x => x.m_RecenterToTargetHeading));
+ }
+ return excluded;
+ }
+
+ protected override void OnDisable()
+ {
+ base.OnDisable();
+
+ // Must destroy child editors or we get exceptions
+ if (m_editors != null)
+ foreach (UnityEditor.Editor e in m_editors)
+ if (e != null)
+ UnityEngine.Object.DestroyImmediate(e);
+ }
+
+ public override void OnInspectorGUI()
+ {
+ Target.m_XAxis.ValueRangeLocked
+ = (Target.m_BindingMode == CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp);
+
+ // Ordinary properties
+ BeginInspector();
+ DrawHeaderInInspector();
+ DrawPropertyInInspector(FindProperty(x => x.m_Priority));
+ DrawTargetsInInspector(FindProperty(x => x.m_Follow), FindProperty(x => x.m_LookAt));
+ DrawRemainingPropertiesInInspector();
+
+ // Orbits
+ EditorGUI.BeginChangeCheck();
+ SerializedProperty orbits = FindProperty(x => x.m_Orbits);
+ for (int i = 0; i < CinemachineFreeLook.RigNames.Length; ++i)
+ {
+ Rect rect = EditorGUILayout.GetControlRect(true);
+ SerializedProperty orbit = orbits.GetArrayElementAtIndex(i);
+ InspectorUtility.MultiPropertyOnLine(rect,
+ new GUIContent(CinemachineFreeLook.RigNames[i]),
+ new [] { orbit.FindPropertyRelative(() => Target.m_Orbits[i].m_Height),
+ orbit.FindPropertyRelative(() => Target.m_Orbits[i].m_Radius) },
+ null);
+ }
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+
+ // Rigs
+ UpdateRigEditors();
+ for (int i = 0; i < m_editors.Length; ++i)
+ {
+ if (m_editors[i] == null)
+ continue;
+ EditorGUILayout.Separator();
+ EditorGUILayout.BeginVertical(GUI.skin.box);
+ EditorGUILayout.LabelField(RigNames[i], EditorStyles.boldLabel);
+ ++EditorGUI.indentLevel;
+ m_editors[i].OnInspectorGUI();
+ --EditorGUI.indentLevel;
+ EditorGUILayout.EndVertical();
+ }
+
+ // Extensions
+ DrawExtensionsWidgetInInspector();
+ }
+
+ string[] RigNames;
+ CinemachineVirtualCameraBase[] m_rigs;
+ UnityEditor.Editor[] m_editors;
+ void UpdateRigEditors()
+ {
+ RigNames = CinemachineFreeLook.RigNames;
+ if (m_rigs == null)
+ m_rigs = new CinemachineVirtualCameraBase[RigNames.Length];
+ if (m_editors == null)
+ m_editors = new UnityEditor.Editor[RigNames.Length];
+ for (int i = 0; i < RigNames.Length; ++i)
+ {
+ CinemachineVirtualCamera rig = Target.GetRig(i);
+ if (rig == null || rig != m_rigs[i])
+ {
+ m_rigs[i] = rig;
+ if (m_editors[i] != null)
+ UnityEngine.Object.DestroyImmediate(m_editors[i]);
+ m_editors[i] = null;
+ if (rig != null)
+ CreateCachedEditor(rig, null, ref m_editors[i]);
+ }
+ }
+ }
+
+ /// <summary>
+ /// Register with CinemachineFreeLook to create the pipeline in an undo-friendly manner
+ /// </summary>
+ [InitializeOnLoad]
+ class CreateRigWithUndo
+ {
+ static CreateRigWithUndo()
+ {
+ CinemachineFreeLook.CreateRigOverride
+ = (CinemachineFreeLook vcam, string name, CinemachineVirtualCamera copyFrom) =>
+ {
+ // Create a new rig with default components
+ GameObject go = InspectorUtility.CreateGameObject(name);
+ Undo.RegisterCreatedObjectUndo(go, "created rig");
+ Undo.SetTransformParent(go.transform, vcam.transform, "parenting rig");
+ CinemachineVirtualCamera rig = Undo.AddComponent<CinemachineVirtualCamera>(go);
+ Undo.RecordObject(rig, "creating rig");
+ if (copyFrom != null)
+ ReflectionHelpers.CopyFields(copyFrom, rig);
+ else
+ {
+ go = rig.GetComponentOwner().gameObject;
+ Undo.RecordObject(Undo.AddComponent<CinemachineOrbitalTransposer>(go), "creating rig");
+ Undo.RecordObject(Undo.AddComponent<CinemachineComposer>(go), "creating rig");
+ }
+ return rig;
+ };
+ CinemachineFreeLook.DestroyRigOverride = (GameObject rig) =>
+ {
+ Undo.DestroyObjectImmediate(rig);
+ };
+ }
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.Selected, typeof(CinemachineFreeLook))]
+ private static void DrawFreeLookGizmos(CinemachineFreeLook vcam, GizmoType selectionType)
+ {
+ // Standard frustum and logo
+ CinemachineBrainEditor.DrawVirtualCameraBaseGizmos(vcam, selectionType);
+
+ Color originalGizmoColour = Gizmos.color;
+ bool isActiveVirtualCam = CinemachineCore.Instance.IsLive(vcam);
+ Gizmos.color = isActiveVirtualCam
+ ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour
+ : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour;
+
+ if (vcam.Follow != null)
+ {
+ Vector3 pos = vcam.Follow.position;
+ Vector3 up = Vector3.up;
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(vcam);
+ if (brain != null)
+ up = brain.DefaultWorldUp;
+
+ var MiddleRig = vcam.GetRig(1).GetCinemachineComponent<CinemachineOrbitalTransposer>();
+ if (MiddleRig != null)
+ {
+ Quaternion orient = MiddleRig.GetReferenceOrientation(up);
+ up = orient * Vector3.up;
+ float rotation = vcam.m_XAxis.Value + vcam.m_Heading.m_Bias;
+ orient = Quaternion.AngleAxis(rotation, up) * orient;
+
+ CinemachineOrbitalTransposerEditor.DrawCircleAtPointWithRadius(
+ pos + up * vcam.m_Orbits[0].m_Height, orient, vcam.m_Orbits[0].m_Radius);
+ CinemachineOrbitalTransposerEditor.DrawCircleAtPointWithRadius(
+ pos + up * vcam.m_Orbits[1].m_Height, orient, vcam.m_Orbits[1].m_Radius);
+ CinemachineOrbitalTransposerEditor.DrawCircleAtPointWithRadius(
+ pos + up * vcam.m_Orbits[2].m_Height, orient, vcam.m_Orbits[2].m_Radius);
+
+ DrawCameraPath(pos, orient, vcam);
+ }
+ }
+
+ Gizmos.color = originalGizmoColour;
+ }
+
+ private static void DrawCameraPath(Vector3 atPos, Quaternion orient, CinemachineFreeLook vcam)
+ {
+ Matrix4x4 prevMatrix = Gizmos.matrix;
+ Gizmos.matrix = Matrix4x4.TRS(atPos, orient, Vector3.one);
+
+ const int kNumSteps = 20;
+ Vector3 currPos = vcam.GetLocalPositionForCameraFromInput(0f);
+ for (int i = 1; i < kNumSteps + 1; ++i)
+ {
+ float t = (float)i / (float)kNumSteps;
+ Vector3 nextPos = vcam.GetLocalPositionForCameraFromInput(t);
+ Gizmos.DrawLine(currPos, nextPos);
+ currPos = nextPos;
+ }
+ Gizmos.matrix = prevMatrix;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 04e6f1d86089cda409e925cd975436d9
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using UnityEditor;
+using UnityEngine;
+using Cinemachine.Utility;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineGroupComposer))]
+ internal class CinemachineGroupComposerEditor : CinemachineComposerEditor
+ {
+ // Specialization
+ private CinemachineGroupComposer MyTarget { get { return target as CinemachineGroupComposer; } }
+ protected string FieldPath<TValue>(Expression<Func<CinemachineGroupComposer, TValue>> expr)
+ {
+ return ReflectionHelpers.GetFieldPath(expr);
+ }
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(MyTarget.VirtualCamera);
+ bool ortho = brain != null ? brain.OutputCamera.orthographic : false;
+ if (ortho)
+ {
+ excluded.Add(FieldPath(x => x.m_AdjustmentMode));
+ excluded.Add(FieldPath(x => x.m_MinimumFOV));
+ excluded.Add(FieldPath(x => x.m_MaximumFOV));
+ excluded.Add(FieldPath(x => x.m_MaxDollyIn));
+ excluded.Add(FieldPath(x => x.m_MaxDollyOut));
+ excluded.Add(FieldPath(x => x.m_MinimumDistance));
+ excluded.Add(FieldPath(x => x.m_MaximumDistance));
+ }
+ else
+ {
+ excluded.Add(FieldPath(x => x.m_MinimumOrthoSize));
+ excluded.Add(FieldPath(x => x.m_MaximumOrthoSize));
+ switch (MyTarget.m_AdjustmentMode)
+ {
+ case CinemachineGroupComposer.AdjustmentMode.DollyOnly:
+ excluded.Add(FieldPath(x => x.m_MinimumFOV));
+ excluded.Add(FieldPath(x => x.m_MaximumFOV));
+ break;
+ case CinemachineGroupComposer.AdjustmentMode.ZoomOnly:
+ excluded.Add(FieldPath(x => x.m_MaxDollyIn));
+ excluded.Add(FieldPath(x => x.m_MaxDollyOut));
+ excluded.Add(FieldPath(x => x.m_MinimumDistance));
+ excluded.Add(FieldPath(x => x.m_MaximumDistance));
+ break;
+ default:
+ break;
+ }
+ }
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ if (MyTarget.IsValid && MyTarget.LookAtTargetGroup == null)
+ EditorGUILayout.HelpBox(
+ "The Framing settings will be ignored because the LookAt target is not a kind of CinemachineTargetGroup",
+ MessageType.Info);
+
+ base.OnInspectorGUI();
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.InSelectionHierarchy, typeof(CinemachineGroupComposer))]
+ private static void DrawGroupComposerGizmos(CinemachineGroupComposer target, GizmoType selectionType)
+ {
+ // Show the group bounding box, as viewed from the camera position
+ if (target.LookAtTargetGroup != null)
+ {
+ Matrix4x4 m = Gizmos.matrix;
+ Bounds b = target.LastBounds;
+ Gizmos.matrix = target.LastBoundsMatrix;
+ Gizmos.color = Color.yellow;
+
+ if (target.VcamState.Lens.Orthographic)
+ Gizmos.DrawWireCube(b.center, b.size);
+ else
+ {
+ float z = b.center.z;
+ Vector3 e = b.extents;
+ Gizmos.DrawFrustum(
+ Vector3.zero,
+ Mathf.Atan2(e.y, z) * Mathf.Rad2Deg * 2,
+ z + e.z, z - e.z, e.x / e.y);
+ }
+ Gizmos.matrix = m;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: c5da6ce9225f948438f7d6a072499ecd
+timeCreated: 1496702989
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using UnityEngine;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineHardLockToTarget))]
+ internal sealed class CinemachineHardLockToTargetEditor : BaseEditor<CinemachineHardLockToTarget>
+ {
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (Target.FollowTarget == null)
+ EditorGUILayout.HelpBox(
+ "Hard Lock requires a Follow Target. Change Body to Do Nothing if you don't want a Follow target.",
+ MessageType.Warning);
+ EditorGUI.BeginChangeCheck();
+ GUI.enabled = false;
+ EditorGUILayout.LabelField(" ", "No additional settings", EditorStyles.miniLabel);
+ GUI.enabled = true;
+ DrawRemainingPropertiesInInspector();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: e44b92e217bfdf24d99acb4344918eeb
+timeCreated: 1506541599
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using UnityEngine;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineHardLookAt))]
+ internal sealed class CinemachineHardLookAtEditor : BaseEditor<CinemachineHardLookAt>
+ {
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (Target.LookAtTarget == null)
+ EditorGUILayout.HelpBox(
+ "Hard Look At requires a LookAt target. Change Aim to Do Nothing if you don't want a LookAt target.",
+ MessageType.Warning);
+ EditorGUI.BeginChangeCheck();
+ GUI.enabled = false;
+ EditorGUILayout.LabelField(" ", "No additional settings", EditorStyles.miniLabel);
+ GUI.enabled = true;
+ DrawRemainingPropertiesInInspector();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 9ce16cd7e31794b48b2843381cd87d31
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using UnityEngine;
+using Cinemachine.Utility;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineMixingCamera))]
+ internal sealed class CinemachineMixingCameraEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineMixingCamera>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ for (int i = 0; i < CinemachineMixingCamera.MaxCameras; ++i)
+ excluded.Add(WeightPropertyName(i));
+ return excluded;
+ }
+
+ static string WeightPropertyName(int i) { return "m_Weight" + i; }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ DrawHeaderInInspector();
+ DrawRemainingPropertiesInInspector();
+
+ float totalWeight = 0;
+ CinemachineVirtualCameraBase[] children = Target.ChildCameras;
+ int numCameras = Mathf.Min(CinemachineMixingCamera.MaxCameras, children.Length);
+ for (int i = 0; i < numCameras; ++i)
+ if (children[i].isActiveAndEnabled)
+ totalWeight += Target.GetWeight(i);
+
+ if (numCameras == 0)
+ EditorGUILayout.HelpBox("There are no Virtual Camera children", MessageType.Warning);
+ else
+ {
+ EditorGUILayout.Separator();
+ EditorGUILayout.LabelField("Child Camera Weights", EditorStyles.boldLabel);
+ for (int i = 0; i < numCameras; ++i)
+ {
+ SerializedProperty prop = serializedObject.FindProperty(WeightPropertyName(i));
+ if (prop != null)
+ EditorGUILayout.PropertyField(prop, new GUIContent(children[i].Name));
+ }
+ serializedObject.ApplyModifiedProperties();
+
+ if (totalWeight <= UnityVectorExtensions.Epsilon)
+ EditorGUILayout.HelpBox("No input channels are active", MessageType.Warning);
+
+ if (children.Length > numCameras)
+ EditorGUILayout.HelpBox(
+ "There are " + children.Length
+ + " child cameras. A maximum of " + numCameras + " is supported.",
+ MessageType.Warning);
+
+ // Camera proportion indicator
+ EditorGUILayout.Separator();
+ EditorGUILayout.LabelField("Mix Result", EditorStyles.boldLabel);
+ DrawProportionIndicator(children, numCameras, totalWeight);
+ }
+
+ // Extensions
+ DrawExtensionsWidgetInInspector();
+ }
+
+ void DrawProportionIndicator(
+ CinemachineVirtualCameraBase[] children, int numCameras, float totalWeight)
+ {
+ GUIStyle style = EditorStyles.centeredGreyMiniLabel;
+ Color bkg = new Color(0.27f, 0.27f, 0.27f); // ack! no better way than this?
+ Color fg = Color.Lerp(CinemachineBrain.GetSoloGUIColor(), bkg, 0.8f);
+ float totalHeight = (style.lineHeight + style.margin.vertical) * numCameras;
+ Rect r = EditorGUILayout.GetControlRect(true, totalHeight);
+ r.height /= numCameras; r.height -= 1;
+ float fullWidth = r.width;
+ for (int i = 0; i < numCameras; ++i)
+ {
+ float p = 0;
+ string label = children[i].Name;
+ if (totalWeight > UnityVectorExtensions.Epsilon)
+ {
+ if (children[i].isActiveAndEnabled)
+ p = Target.GetWeight(i) / totalWeight;
+ else
+ label += " (disabled)";
+ }
+ r.width = fullWidth * p;
+ EditorGUI.DrawRect(r, fg);
+
+ Rect r2 = r;
+ r2.x += r.width;
+ r2.width = fullWidth - r.width;
+ EditorGUI.DrawRect(r2, bkg);
+
+ r.width = fullWidth;
+ EditorGUI.LabelField(r, label, style);
+
+ r.y += r.height + 1;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 8ad60cb17f7694c43a8190c617281753
+timeCreated: 1502201539
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using UnityEngine;
+using UnityEditorInternal;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(NoiseSettings))]
+ internal sealed class NoiseSettingsEditor : BaseEditor<NoiseSettings>
+ {
+ private const float vSpace = 2;
+ private const float hSpace = 3;
+
+ // Needed for accessing string names of fields
+ #pragma warning disable 0649 // assigned but never used
+ private NoiseSettings.TransformNoiseParams tpDef;
+ private NoiseSettings.NoiseParams npDef;
+
+ private static float mPreviewTime = 2;
+ private static float mPreviewHeight = 5;
+ private float mNoiseOffsetBase = 0;
+ private float mNoiseOffset = 0;
+ private bool mAnimatedPreview = false;
+ GUIContent mAnimatedLabel = new GUIContent("Animated", "Animate the noise signal preview");
+
+
+ private ReorderableList[] mPosChannels;
+ private ReorderableList[] mRotChannels;
+ private static GUIContent[] mPoslabels = new GUIContent[]
+ {
+ new GUIContent("Position X"),
+ new GUIContent("Position Y"),
+ new GUIContent("Position Z")
+ };
+ private static GUIContent[] mRotlabels = new GUIContent[]
+ {
+ new GUIContent("Rotation X"),
+ new GUIContent("Rotation Y"),
+ new GUIContent("Rotation Z")
+ };
+ private static bool[] mPosExpanded = new bool[3];
+ private static bool[] mRotExpanded = new bool[3];
+
+ private void OnEnable()
+ {
+ mNoiseOffsetBase = Time.realtimeSinceStartup;
+ mNoiseOffset = 0;
+ }
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ var excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => Target.PositionNoise));
+ excluded.Add(FieldPath(x => Target.OrientationNoise));
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ if (mPosChannels == null)
+ mPosChannels = SetupReorderableLists(
+ serializedObject.FindProperty(() => Target.PositionNoise), mPoslabels);
+ if (mRotChannels == null)
+ mRotChannels = SetupReorderableLists(
+ serializedObject.FindProperty(() => Target.OrientationNoise), mRotlabels);
+
+ BeginInspector();
+
+ Rect r = EditorGUILayout.GetControlRect();
+ mPreviewTime = EditorGUI.Slider(r, "Preview Time", mPreviewTime, 0.01f, 10f);
+ r = EditorGUILayout.GetControlRect();
+ float labelWidth = GUI.skin.label.CalcSize(mAnimatedLabel).x + EditorGUIUtility.singleLineHeight;
+ r.width -= labelWidth + hSpace;
+ mPreviewHeight = EditorGUI.Slider(r, "Preview Height", mPreviewHeight, 1f, 10f);
+ r.x += r.width + hSpace; r.width = labelWidth;
+ mAnimatedPreview = EditorGUI.ToggleLeft(r, mAnimatedLabel, mAnimatedPreview);
+ EditorGUILayout.Separator();
+
+ r = EditorGUILayout.GetControlRect();
+ EditorGUI.LabelField(r, "Position Noise - amplitudes are in Distance units", EditorStyles.boldLabel);
+ r = EditorGUILayout.GetControlRect(true, mPreviewHeight * EditorGUIUtility.singleLineHeight);
+ if (Event.current.type == EventType.Repaint)
+ {
+ mSampleCachePos.SnapshotSample(r.size, Target.PositionNoise, mNoiseOffset, mAnimatedPreview);
+ mSampleCachePos.DrawSamplePreview(r, 7);
+ }
+ for (int i = 0; i < mPosChannels.Length; ++i)
+ {
+ r = EditorGUILayout.GetControlRect();
+ mPosExpanded[i] = EditorGUI.Foldout(r, mPosExpanded[i], mPoslabels[i], true);
+ if (mPosExpanded[i])
+ {
+ r = EditorGUILayout.GetControlRect(true, mPreviewHeight * EditorGUIUtility.singleLineHeight);
+ if (Event.current.type == EventType.Repaint)
+ mSampleCachePos.DrawSamplePreview(r, 1 << i);
+ mPosChannels[i].DoLayoutList();
+ }
+ }
+ EditorGUILayout.Separator();
+
+ r = EditorGUILayout.GetControlRect();
+ EditorGUI.LabelField(r, "Rotation Noise - amplitude units are degrees", EditorStyles.boldLabel);
+ r = EditorGUILayout.GetControlRect(true, mPreviewHeight * EditorGUIUtility.singleLineHeight);
+ if (Event.current.type == EventType.Repaint)
+ {
+ mSampleCacheRot.SnapshotSample(r.size, Target.OrientationNoise, mNoiseOffset, mAnimatedPreview);
+ mSampleCacheRot.DrawSamplePreview(r, 7);
+ }
+ for (int i = 0; i < mPosChannels.Length; ++i)
+ {
+ r = EditorGUILayout.GetControlRect();
+ mRotExpanded[i] = EditorGUI.Foldout(r, mRotExpanded[i], mRotlabels[i], true);
+ if (mRotExpanded[i])
+ {
+ r = EditorGUILayout.GetControlRect(true, mPreviewHeight * EditorGUIUtility.singleLineHeight);
+ if (Event.current.type == EventType.Repaint)
+ mSampleCacheRot.DrawSamplePreview(r, 1 << i);
+ mRotChannels[i].DoLayoutList();
+ }
+ }
+
+ serializedObject.ApplyModifiedProperties();
+
+ // Make it live!
+ if (mAnimatedPreview && Event.current.type == EventType.Repaint)
+ {
+ mNoiseOffset += Time.realtimeSinceStartup - mNoiseOffsetBase;
+ Repaint();
+ }
+ mNoiseOffsetBase = Time.realtimeSinceStartup;
+ }
+
+ class SampleCache
+ {
+ private List<Vector3> mSampleCurveX = new List<Vector3>();
+ private List<Vector3> mSampleCurveY = new List<Vector3>();
+ private List<Vector3> mSampleCurveZ = new List<Vector3>();
+ private List<Vector3> mSampleNoise = new List<Vector3>();
+
+ public void SnapshotSample(
+ Vector2 areaSize, NoiseSettings.TransformNoiseParams[] signal, float noiseOffset, bool animated)
+ {
+ // These values give a smoother curve, more-or-less fitting in the window
+ int numSamples = Mathf.RoundToInt(areaSize.x);
+ if (animated)
+ numSamples *= 2;
+ const float signalScale = 0.75f;
+
+ float maxVal = 0;
+ for (int i = 0; i < signal.Length; ++i)
+ {
+ maxVal = Mathf.Max(maxVal, Mathf.Abs(signal[i].X.Amplitude * signalScale));
+ maxVal = Mathf.Max(maxVal, Mathf.Abs(signal[i].Y.Amplitude * signalScale));
+ maxVal = Mathf.Max(maxVal, Mathf.Abs(signal[i].Z.Amplitude * signalScale));
+ }
+ mSampleNoise.Clear();
+ for (int i = 0; i < numSamples; ++i)
+ {
+ float t = (float)i / (numSamples - 1) * mPreviewTime + noiseOffset;
+ Vector3 p = NoiseSettings.GetCombinedFilterResults(signal, t, Vector3.zero);
+ mSampleNoise.Add(p);
+ }
+ mSampleCurveX.Clear();
+ mSampleCurveY.Clear();
+ mSampleCurveZ.Clear();
+ float halfHeight = areaSize.y / 2;
+ float yOffset = halfHeight;
+ for (int i = 0; i < numSamples; ++i)
+ {
+ float t = (float)i / (numSamples - 1);
+ Vector3 p = mSampleNoise[i];
+ mSampleCurveX.Add(new Vector3(areaSize.x * t, halfHeight * Mathf.Clamp(-p.x / maxVal, -1, 1) + yOffset, 0));
+ mSampleCurveY.Add(new Vector3(areaSize.x * t, halfHeight * Mathf.Clamp(-p.y / maxVal, -1, 1) + yOffset, 0));
+ mSampleCurveZ.Add(new Vector3(areaSize.x * t, halfHeight * Mathf.Clamp(-p.z / maxVal, -1, 1) + yOffset, 0));
+ }
+ }
+
+ public void DrawSamplePreview(Rect r, int channelMask)
+ {
+ EditorGUI.DrawRect(r, Color.black);
+ var oldMatrix = Handles.matrix;
+ Handles.matrix = Handles.matrix * Matrix4x4.Translate(r.position);
+ if ((channelMask & 1) != 0)
+ {
+ Handles.color = new Color(1, 0.5f, 0, 0.8f);
+ Handles.DrawPolyLine(mSampleCurveX.ToArray());
+ }
+ if ((channelMask & 2) != 0)
+ {
+ Handles.color = new Color(0, 1, 0, 0.8f);
+ Handles.DrawPolyLine(mSampleCurveY.ToArray());
+ }
+ if ((channelMask & 4) != 0)
+ {
+ Handles.color = new Color(0, 0.5f, 1, 0.8f);
+ Handles.DrawPolyLine(mSampleCurveZ.ToArray());
+ }
+ Handles.color = Color.black;
+ Handles.DrawLine(new Vector3(1, 0, 0), new Vector3(r.width, 0, 0));
+ Handles.DrawLine(new Vector3(0, r.height, 0), new Vector3(r.width, r.height, 0));
+ Handles.matrix = oldMatrix;
+ }
+ }
+ SampleCache mSampleCachePos = new SampleCache();
+ SampleCache mSampleCacheRot = new SampleCache();
+
+ private ReorderableList[] SetupReorderableLists(
+ SerializedProperty property, GUIContent[] titles)
+ {
+ ReorderableList[] lists = new ReorderableList[3];
+ for (int i = 0; i < 3; ++i)
+ lists[i] = SetupReorderableList(property, i, new GUIContent("Components"));
+ return lists;
+ }
+
+ private ReorderableList SetupReorderableList(
+ SerializedProperty property, int channel, GUIContent title)
+ {
+ ChannelList list = new ChannelList(
+ property.serializedObject, property, channel, title);
+
+ list.drawHeaderCallback = (Rect rect) =>
+ {
+ GUIContent steadyLabel = new GUIContent("(non-random wave if checked)");
+ float steadyLabelWidth = GUI.skin.label.CalcSize(steadyLabel).x;
+
+ Rect r = rect;
+ EditorGUI.LabelField(r, list.mTitle);
+ r.x = rect.x + rect.width - steadyLabelWidth; r.width = steadyLabelWidth;
+ EditorGUI.LabelField(r, steadyLabel);
+ };
+
+ list.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ SerializedProperty element = list.serializedProperty.GetArrayElementAtIndex(index);
+ switch (list.mChannel)
+ {
+ case 0: DrawNoiseChannel(rect, element.FindPropertyRelative(() => tpDef.X)); break;
+ case 1: DrawNoiseChannel(rect, element.FindPropertyRelative(() => tpDef.Y)); break;
+ case 2: DrawNoiseChannel(rect, element.FindPropertyRelative(() => tpDef.Z)); break;
+ default: break;
+ }
+ };
+
+ list.onAddCallback = (ReorderableList l) =>
+ {
+ var index = l.serializedProperty.arraySize;
+ ++l.serializedProperty.arraySize;
+ SerializedProperty p = l.serializedProperty.GetArrayElementAtIndex(index);
+ ClearComponent(p.FindPropertyRelative(() => tpDef.X));
+ ClearComponent(p.FindPropertyRelative(() => tpDef.Y));
+ ClearComponent(p.FindPropertyRelative(() => tpDef.Z));
+ };
+
+ list.onRemoveCallback = (ReorderableList l) =>
+ {
+ // Can't just delete because the component arrays are connected
+ SerializedProperty p = l.serializedProperty.GetArrayElementAtIndex(l.index);
+ bool IsClear
+ = (list.mChannel == 0 || IsClearComponent(p.FindPropertyRelative(() => tpDef.X)))
+ && (list.mChannel == 1 || IsClearComponent(p.FindPropertyRelative(() => tpDef.Y)))
+ && (list.mChannel == 2 || IsClearComponent(p.FindPropertyRelative(() => tpDef.Z)));
+ if (IsClear)
+ l.serializedProperty.DeleteArrayElementAtIndex(l.index);
+ else switch (list.mChannel)
+ {
+ case 0: ClearComponent(p.FindPropertyRelative(() => tpDef.X)); break;
+ case 1: ClearComponent(p.FindPropertyRelative(() => tpDef.Y)); break;
+ case 2: ClearComponent(p.FindPropertyRelative(() => tpDef.Z)); break;
+ default: break;
+ }
+ };
+
+ return list;
+ }
+
+ class ChannelList : ReorderableList
+ {
+ public int mChannel;
+ public GUIContent mTitle;
+
+ public ChannelList(
+ SerializedObject serializedObject,
+ SerializedProperty elements,
+ int channel, GUIContent title)
+ : base(serializedObject, elements, true, true, true, true)
+ {
+ mChannel = channel;
+ mTitle = title;
+ }
+ };
+
+ private GUIContent steadyLabel;
+ private GUIContent freqLabel;
+ private float freqLabelWidth;
+ private GUIContent ampLabel;
+ private float ampLabelWidth;
+
+ private void InitializeLabels(SerializedProperty property)
+ {
+ if (steadyLabel == null)
+ {
+ SerializedProperty p = property.FindPropertyRelative(() => npDef.Constant);
+ steadyLabel = new GUIContent(p.displayName, p.tooltip) { text = " " };
+ }
+ if (freqLabel == null)
+ {
+ SerializedProperty p = property.FindPropertyRelative(() => npDef.Frequency);
+ freqLabel = new GUIContent(p.displayName, p.tooltip);
+ freqLabelWidth = GUI.skin.label.CalcSize(freqLabel).x;
+ }
+ if (ampLabel == null)
+ {
+ SerializedProperty p = property.FindPropertyRelative(() => npDef.Amplitude);
+ ampLabel = new GUIContent(p.displayName, p.tooltip);
+ ampLabelWidth = GUI.skin.label.CalcSize(ampLabel).x;
+ }
+ }
+
+ private void DrawNoiseChannel(Rect rect, SerializedProperty property)
+ {
+ InitializeLabels(property);
+
+ Rect r = rect;
+ r.height -= vSpace;
+ r.width -= EditorGUIUtility.singleLineHeight + hSpace;
+ r.width /= 2;
+
+ float oldLabelWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = freqLabelWidth;
+ EditorGUI.PropertyField(r, property.FindPropertyRelative(() => npDef.Frequency), freqLabel);
+
+ r.x += r.width + hSpace;
+ EditorGUIUtility.labelWidth = ampLabelWidth;
+ EditorGUI.PropertyField(r, property.FindPropertyRelative(() => npDef.Amplitude), ampLabel);
+
+ r.y -= 1;
+ r.x += r.width + hSpace; r.width = EditorGUIUtility.singleLineHeight + hSpace;
+ EditorGUIUtility.labelWidth = hSpace;
+ EditorGUI.PropertyField(r, property.FindPropertyRelative(() => npDef.Constant), steadyLabel);
+
+ EditorGUIUtility.labelWidth = oldLabelWidth;
+ }
+
+ // SerializedProperty is a NoiseSettings.NoiseParam
+ void ClearComponent(SerializedProperty p)
+ {
+ p.FindPropertyRelative(() => npDef.Amplitude).floatValue = 0;
+ p.FindPropertyRelative(() => npDef.Frequency).floatValue = 0;
+ p.FindPropertyRelative(() => npDef.Constant).boolValue = false;
+ }
+
+ // SerializedProperty is a NoiseSettings.NoiseParam
+ bool IsClearComponent(SerializedProperty p)
+ {
+ return p.FindPropertyRelative(() => npDef.Amplitude).floatValue == 0
+ && p.FindPropertyRelative(() => npDef.Frequency).floatValue == 0;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 8000e8170b5e1374c9503b5255ccc7e8
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineOrbitalTransposer))]
+ internal class CinemachineOrbitalTransposerEditor : BaseEditor<CinemachineOrbitalTransposer>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ if (Target.m_HeadingIsSlave)
+ {
+ excluded.Add(FieldPath(x => x.m_FollowOffset));
+ excluded.Add(FieldPath(x => x.m_BindingMode));
+ excluded.Add(FieldPath(x => x.m_Heading));
+ excluded.Add(FieldPath(x => x.m_XAxis));
+ excluded.Add(FieldPath(x => x.m_RecenterToTargetHeading));
+ }
+ if (Target.HideOffsetInInspector)
+ excluded.Add(FieldPath(x => x.m_FollowOffset));
+
+ switch (Target.m_BindingMode)
+ {
+ default:
+ case CinemachineTransposer.BindingMode.LockToTarget:
+ if (Target.m_AngularDampingMode == CinemachineTransposer.AngularDampingMode.Euler)
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ else
+ {
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_YawDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ }
+ break;
+ case CinemachineTransposer.BindingMode.LockToTargetNoRoll:
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDampingMode));
+ break;
+ case CinemachineTransposer.BindingMode.LockToTargetWithWorldUp:
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDampingMode));
+ break;
+ case CinemachineTransposer.BindingMode.LockToTargetOnAssign:
+ case CinemachineTransposer.BindingMode.WorldSpace:
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_YawDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDampingMode));
+ break;
+ case CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp:
+ excluded.Add(FieldPath(x => x.m_XDamping));
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_YawDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDampingMode));
+ excluded.Add(FieldPath(x => x.m_Heading));
+ excluded.Add(FieldPath(x => x.m_RecenterToTargetHeading));
+ break;
+ }
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (Target.FollowTarget == null)
+ EditorGUILayout.HelpBox(
+ "Orbital Transposer requires a Follow target.",
+ MessageType.Warning);
+ Target.m_XAxis.ValueRangeLocked
+ = (Target.m_BindingMode == CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp);
+ DrawRemainingPropertiesInInspector();
+ }
+
+ /// Process a position drag from the user.
+ /// Called "magically" by the vcam editor, so don't change the signature.
+ private void OnVcamPositionDragged(Vector3 delta)
+ {
+ Undo.RegisterCompleteObjectUndo(Target, "Camera drag"); // GML do we need this?
+ Quaternion targetOrientation = Target.GetReferenceOrientation(Target.VcamState.ReferenceUp);
+ targetOrientation = targetOrientation * Quaternion.Euler(0, Target.m_Heading.m_Bias, 0);
+ Vector3 localOffset = Quaternion.Inverse(targetOrientation) * delta;
+ localOffset.x = 0;
+ FindProperty(x => x.m_FollowOffset).vector3Value += localOffset;
+ serializedObject.ApplyModifiedProperties();
+ FindProperty(x => x.m_FollowOffset).vector3Value = Target.EffectiveOffset;
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.Selected, typeof(CinemachineOrbitalTransposer))]
+ static void DrawTransposerGizmos(CinemachineOrbitalTransposer target, GizmoType selectionType)
+ {
+ if (target.IsValid && !target.HideOffsetInInspector)
+ {
+ Color originalGizmoColour = Gizmos.color;
+ Gizmos.color = CinemachineCore.Instance.IsLive(target.VirtualCamera)
+ ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour
+ : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour;
+
+ Vector3 up = Vector3.up;
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(target.VirtualCamera);
+ if (brain != null)
+ up = brain.DefaultWorldUp;
+ Vector3 pos = target.FollowTargetPosition;
+
+ Quaternion orient = target.GetReferenceOrientation(up);
+ up = orient * Vector3.up;
+ DrawCircleAtPointWithRadius
+ (pos + up * target.m_FollowOffset.y, orient, target.m_FollowOffset.z);
+
+ Gizmos.color = originalGizmoColour;
+ }
+ }
+
+ public static void DrawCircleAtPointWithRadius(Vector3 point, Quaternion orient, float radius)
+ {
+ Matrix4x4 prevMatrix = Gizmos.matrix;
+ Gizmos.matrix = Matrix4x4.TRS(point, orient, radius * Vector3.one);
+
+ const int kNumPoints = 25;
+ Vector3 currPoint = Vector3.forward;
+ Quaternion rot = Quaternion.AngleAxis(360f / (float)kNumPoints, Vector3.up);
+ for (int i = 0; i < kNumPoints + 1; ++i)
+ {
+ Vector3 nextPoint = rot * currPoint;
+ Gizmos.DrawLine(currPoint, nextPoint);
+ currPoint = nextPoint;
+ }
+ Gizmos.matrix = prevMatrix;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 247be52eadac5044e9f8b7b4d8d0ada9
+timeCreated: 1485443456
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachinePOV))]
+ internal sealed class CinemachinePOVEditor : BaseEditor<CinemachinePOV>
+ {
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 1186b8795dc3fc84e8ec53bd314d8e91
+timeCreated: 1504801965
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using UnityEngine;
+using System.Collections.Generic;
+using UnityEditorInternal;
+using Cinemachine.Utility;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachinePath))]
+ internal sealed class CinemachinePathEditor : BaseEditor<CinemachinePath>
+ {
+ private ReorderableList mWaypointList;
+ static bool mWaypointsExpanded;
+ static bool mPreferHandleSelection = true;
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_Waypoints));
+ return excluded;
+ }
+
+ void OnEnable()
+ {
+ mWaypointList = null;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (mWaypointList == null)
+ SetupWaypointList();
+ if (mWaypointList.index >= mWaypointList.count)
+ mWaypointList.index = mWaypointList.count - 1;
+
+ // Ordinary properties
+ DrawRemainingPropertiesInInspector();
+
+ // Path length
+ EditorGUILayout.LabelField("Path Length", Target.PathLength.ToString());
+
+ GUILayout.Label(new GUIContent("Selected Waypoint:"));
+ EditorGUILayout.BeginVertical(GUI.skin.box);
+ Rect rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight * 3 + 10);
+ if (mWaypointList.index >= 0)
+ {
+ DrawWaypointEditor(rect, mWaypointList.index);
+ serializedObject.ApplyModifiedProperties();
+ }
+ else
+ {
+ if (Target.m_Waypoints.Length > 0)
+ {
+ EditorGUI.HelpBox(rect,
+ "Click on a waypoint in the scene view\nor in the Path Details list",
+ MessageType.Info);
+ }
+ else if (GUI.Button(rect, new GUIContent("Add a waypoint to the path")))
+ {
+ InsertWaypointAtIndex(mWaypointList.index);
+ mWaypointList.index = 0;
+ }
+ }
+ EditorGUILayout.EndVertical();
+
+ mPreferHandleSelection = EditorGUILayout.Toggle(
+ new GUIContent("Prefer Tangent Drag",
+ "When editing the path, if waypoint position and tangent coincide, dragging will apply preferentially to the tangent"),
+ mPreferHandleSelection);
+
+ mWaypointsExpanded = EditorGUILayout.Foldout(mWaypointsExpanded, "Path Details", true);
+ if (mWaypointsExpanded)
+ {
+ EditorGUI.BeginChangeCheck();
+ mWaypointList.DoLayoutList();
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+ }
+ }
+
+ void SetupWaypointList()
+ {
+ mWaypointList = new ReorderableList(
+ serializedObject, FindProperty(x => x.m_Waypoints),
+ true, true, true, true);
+ mWaypointList.elementHeight *= 3;
+
+ mWaypointList.drawHeaderCallback = (Rect rect) =>
+ {
+ EditorGUI.LabelField(rect, "Waypoints");
+ };
+
+ mWaypointList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ DrawWaypointEditor(rect, index);
+ };
+
+ mWaypointList.onAddCallback = (ReorderableList l) =>
+ {
+ InsertWaypointAtIndex(l.index);
+ };
+ }
+
+ void DrawWaypointEditor(Rect rect, int index)
+ {
+ // Needed for accessing string names of fields
+ CinemachinePath.Waypoint def = new CinemachinePath.Waypoint();
+
+ Vector2 numberDimension = GUI.skin.button.CalcSize(new GUIContent("999"));
+ Vector2 labelDimension = GUI.skin.label.CalcSize(new GUIContent("Position"));
+ Vector2 addButtonDimension = new Vector2(labelDimension.y + 5, labelDimension.y + 1);
+ float vSpace = 2;
+ float hSpace = 3;
+
+ SerializedProperty element = mWaypointList.serializedProperty.GetArrayElementAtIndex(index);
+ rect.y += vSpace / 2;
+
+ Rect r = new Rect(rect.position, numberDimension);
+ Color color = GUI.color;
+ // GUI.color = Target.m_Appearance.pathColor;
+ if (GUI.Button(r, new GUIContent(index.ToString(), "Go to the waypoint in the scene view")))
+ {
+ if (SceneView.lastActiveSceneView != null)
+ {
+ mWaypointList.index = index;
+ SceneView.lastActiveSceneView.pivot = Target.EvaluatePosition(index);
+ SceneView.lastActiveSceneView.size = 3;
+ SceneView.lastActiveSceneView.Repaint();
+ }
+ }
+ GUI.color = color;
+
+ r = new Rect(rect.position, labelDimension);
+ r.x += hSpace + numberDimension.x;
+ EditorGUI.LabelField(r, "Position");
+ r.x += hSpace + r.width;
+ r.width = rect.width - (numberDimension.x + hSpace + r.width + hSpace + addButtonDimension.x + hSpace);
+ EditorGUI.PropertyField(r, element.FindPropertyRelative(() => def.position), GUIContent.none);
+ r.x += r.width + hSpace;
+ r.size = addButtonDimension;
+ GUIContent buttonContent = EditorGUIUtility.IconContent("d_RectTransform Icon");
+ buttonContent.tooltip = "Set to scene-view camera position";
+ GUIStyle style = new GUIStyle(GUI.skin.label);
+ style.alignment = TextAnchor.MiddleCenter;
+ if (GUI.Button(r, buttonContent, style) && SceneView.lastActiveSceneView != null)
+ {
+ Undo.RecordObject(Target, "Set waypoint");
+ CinemachinePath.Waypoint wp = Target.m_Waypoints[index];
+ Vector3 pos = SceneView.lastActiveSceneView.camera.transform.position;
+ wp.position = Target.transform.InverseTransformPoint(pos);
+ Target.m_Waypoints[index] = wp;
+ }
+
+ r = new Rect(rect.position, labelDimension);
+ r.y += numberDimension.y + vSpace;
+ r.x += hSpace + numberDimension.x; r.width = labelDimension.x;
+ EditorGUI.LabelField(r, "Tangent");
+ r.x += hSpace + r.width;
+ r.width = rect.width - (numberDimension.x + hSpace + r.width + hSpace + addButtonDimension.x + hSpace);
+ EditorGUI.PropertyField(r, element.FindPropertyRelative(() => def.tangent), GUIContent.none);
+ r.x += r.width + hSpace;
+ r.size = addButtonDimension;
+ buttonContent = EditorGUIUtility.IconContent("ol minus@2x");
+ buttonContent.tooltip = "Remove this waypoint";
+ if (GUI.Button(r, buttonContent, style))
+ {
+ Undo.RecordObject(Target, "Delete waypoint");
+ var list = new List<CinemachinePath.Waypoint>(Target.m_Waypoints);
+ list.RemoveAt(index);
+ Target.m_Waypoints = list.ToArray();
+ if (index == Target.m_Waypoints.Length)
+ mWaypointList.index = index - 1;
+ }
+
+ r = new Rect(rect.position, labelDimension);
+ r.y += 2 * (numberDimension.y + vSpace);
+ r.x += hSpace + numberDimension.x; r.width = labelDimension.x;
+ EditorGUI.LabelField(r, "Roll");
+ r.x += hSpace + labelDimension.x;
+ r.width = rect.width
+ - (numberDimension.x + hSpace)
+ - (labelDimension.x + hSpace)
+ - (addButtonDimension.x + hSpace);
+ r.width /= 3;
+ EditorGUI.MultiPropertyField(r, new GUIContent[] { new GUIContent(" ") },
+ element.FindPropertyRelative(() => def.roll));
+
+ r.x = rect.x + rect.width - addButtonDimension.x;
+ r.size = addButtonDimension;
+ buttonContent = EditorGUIUtility.IconContent("ol plus@2x");
+ buttonContent.tooltip = "Add a new waypoint after this one";
+ if (GUI.Button(r, buttonContent, style))
+ {
+ mWaypointList.index = index;
+ InsertWaypointAtIndex(index);
+ }
+ }
+
+ void InsertWaypointAtIndex(int indexA)
+ {
+ Vector3 pos = Vector3.forward;
+ Vector3 tangent = Vector3.right;
+ float roll = 0;
+
+ // Get new values from the current indexA (if any)
+ int numWaypoints = Target.m_Waypoints.Length;
+ if (indexA < 0)
+ indexA = numWaypoints - 1;
+ if (indexA >= 0)
+ {
+ int indexB = indexA + 1;
+ if (Target.m_Looped && indexB >= numWaypoints)
+ indexB = 0;
+ if (indexB >= numWaypoints)
+ {
+ // Extrapolate the end
+ if (!Target.m_Waypoints[indexA].tangent.AlmostZero())
+ tangent = Target.m_Waypoints[indexA].tangent;
+ pos = Target.m_Waypoints[indexA].position + tangent;
+ roll = Target.m_Waypoints[indexA].roll;
+ }
+ else
+ {
+ // Interpolate
+ pos = Target.transform.InverseTransformPoint(
+ Target.EvaluatePosition(0.5f + indexA));
+ tangent = Target.transform.InverseTransformDirection(
+ Target.EvaluateTangent(0.5f + indexA).normalized);
+ roll = Mathf.Lerp(
+ Target.m_Waypoints[indexA].roll, Target.m_Waypoints[indexB].roll, 0.5f);
+ }
+ }
+ Undo.RecordObject(Target, "Add waypoint");
+ var wp = new CinemachinePath.Waypoint();
+ wp.position = pos;
+ wp.tangent = tangent;
+ wp.roll = roll;
+ var list = new List<CinemachinePath.Waypoint>(Target.m_Waypoints);
+ list.Insert(indexA + 1, wp);
+ Target.m_Waypoints = list.ToArray();
+ Target.InvalidateDistanceCache();
+ mWaypointList.index = indexA + 1; // select it
+ }
+
+ void OnSceneGUI()
+ {
+ if (mWaypointList == null)
+ SetupWaypointList();
+
+ if (Tools.current == Tool.Move)
+ {
+ Color colorOld = Handles.color;
+ var localToWorld = Target.transform.localToWorldMatrix;
+ var localRotation = Target.transform.rotation;
+ for (int i = 0; i < Target.m_Waypoints.Length; ++i)
+ {
+ DrawSelectionHandle(i, localToWorld);
+ if (mWaypointList.index == i)
+ {
+ // Waypoint is selected
+ if (mPreferHandleSelection)
+ {
+ DrawPositionControl(i, localToWorld, localRotation);
+ DrawTangentControl(i, localToWorld, localRotation);
+ }
+ else
+ {
+ DrawTangentControl(i, localToWorld, localRotation);
+ DrawPositionControl(i, localToWorld, localRotation);
+ }
+ }
+ }
+ Handles.color = colorOld;
+ }
+ }
+
+ void DrawSelectionHandle(int i, Matrix4x4 localToWorld)
+ {
+ if (Event.current.button != 1)
+ {
+ Vector3 pos = localToWorld.MultiplyPoint(Target.m_Waypoints[i].position);
+ float size = HandleUtility.GetHandleSize(pos) * 0.2f;
+ Handles.color = Color.white;
+ if (Handles.Button(pos, Quaternion.identity, size, size, Handles.SphereHandleCap)
+ && mWaypointList.index != i)
+ {
+ mWaypointList.index = i;
+ InternalEditorUtility.RepaintAllViews();
+ }
+ // Label it
+ Handles.BeginGUI();
+ Vector2 labelSize = new Vector2(
+ EditorGUIUtility.singleLineHeight * 2, EditorGUIUtility.singleLineHeight);
+ Vector2 labelPos = HandleUtility.WorldToGUIPoint(pos);
+ labelPos.y -= labelSize.y / 2;
+ labelPos.x -= labelSize.x / 2;
+ GUILayout.BeginArea(new Rect(labelPos, labelSize));
+ GUIStyle style = new GUIStyle();
+ style.normal.textColor = Color.black;
+ style.alignment = TextAnchor.MiddleCenter;
+ GUILayout.Label(new GUIContent(i.ToString(), "Waypoint " + i), style);
+ GUILayout.EndArea();
+ Handles.EndGUI();
+ }
+ }
+
+ void DrawTangentControl(int i, Matrix4x4 localToWorld, Quaternion localRotation)
+ {
+ CinemachinePath.Waypoint wp = Target.m_Waypoints[i];
+ Vector3 hPos = localToWorld.MultiplyPoint(wp.position + wp.tangent);
+
+ Handles.color = Color.yellow;
+ Handles.DrawLine(localToWorld.MultiplyPoint(wp.position), hPos);
+
+ EditorGUI.BeginChangeCheck();
+ Quaternion rotation = (Tools.pivotRotation == PivotRotation.Local)
+ ? localRotation : Quaternion.identity;
+ float size = HandleUtility.GetHandleSize(hPos) * 0.1f;
+ Handles.SphereHandleCap(0, hPos, rotation, size, EventType.Repaint);
+ Vector3 newPos = Handles.PositionHandle(hPos, rotation);
+ if (EditorGUI.EndChangeCheck())
+ {
+ Undo.RecordObject(target, "Change Waypoint Tangent");
+ newPos = Matrix4x4.Inverse(localToWorld).MultiplyPoint(newPos);
+ wp.tangent = newPos - wp.position;
+ Target.m_Waypoints[i] = wp;
+ Target.InvalidateDistanceCache();
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+ }
+
+ void DrawPositionControl(int i, Matrix4x4 localToWorld, Quaternion localRotation)
+ {
+ CinemachinePath.Waypoint wp = Target.m_Waypoints[i];
+ Vector3 pos = localToWorld.MultiplyPoint(wp.position);
+ EditorGUI.BeginChangeCheck();
+ Handles.color = Target.m_Appearance.pathColor;
+ Quaternion rotation = (Tools.pivotRotation == PivotRotation.Local)
+ ? localRotation : Quaternion.identity;
+ float size = HandleUtility.GetHandleSize(pos) * 0.1f;
+ Handles.SphereHandleCap(0, pos, rotation, size, EventType.Repaint);
+ pos = Handles.PositionHandle(pos, rotation);
+ if (EditorGUI.EndChangeCheck())
+ {
+ Undo.RecordObject(target, "Move Waypoint");
+ wp.position = Matrix4x4.Inverse(localToWorld).MultiplyPoint(pos);;
+ Target.m_Waypoints[i] = wp;
+ Target.InvalidateDistanceCache();
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+ }
+
+ public static void DrawPathGizmo(CinemachinePathBase path, Color pathColor)
+ {
+ // Draw the path
+ Color colorOld = Gizmos.color;
+ Gizmos.color = pathColor;
+ float step = 1f / path.m_Resolution;
+ Vector3 lastPos = path.EvaluatePosition(path.MinPos);
+ Vector3 lastW = (path.EvaluateOrientation(path.MinPos)
+ * Vector3.right) * path.m_Appearance.width / 2;
+ for (float t = path.MinPos + step; t <= path.MaxPos + step / 2; t += step)
+ {
+ Vector3 p = path.EvaluatePosition(t);
+ Quaternion q = path.EvaluateOrientation(t);
+ Vector3 w = (q * Vector3.right) * path.m_Appearance.width / 2;
+ Vector3 w2 = w * 1.2f;
+ Vector3 p0 = p - w2;
+ Vector3 p1 = p + w2;
+ Gizmos.DrawLine(p0, p1);
+ Gizmos.DrawLine(lastPos - lastW, p - w);
+ Gizmos.DrawLine(lastPos + lastW, p + w);
+#if false
+ // Show the normals, for debugging
+ Gizmos.color = Color.red;
+ Vector3 y = (q * Vector3.up) * path.m_Appearance.width / 2;
+ Gizmos.DrawLine(p, p + y);
+ Gizmos.color = pathColor;
+#endif
+ lastPos = p;
+ lastW = w;
+ }
+ Gizmos.color = colorOld;
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.NotInSelectionHierarchy
+ | GizmoType.InSelectionHierarchy | GizmoType.Pickable, typeof(CinemachinePath))]
+ static void DrawGizmos(CinemachinePath path, GizmoType selectionType)
+ {
+ DrawPathGizmo(path,
+ (Selection.activeGameObject == path.gameObject)
+ ? path.m_Appearance.pathColor : path.m_Appearance.inactivePathColor);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: c88d2a04cc828c044b0fcc133fd481e6
+timeCreated: 1493316676
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using UnityEngine;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineSameAsFollowTarget))]
+ internal sealed class CinemachineSameAsFollowTargetEditor : BaseEditor<CinemachineSameAsFollowTarget>
+ {
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (Target.FollowTarget == null)
+ EditorGUILayout.HelpBox(
+ "Same As Follow Target requires a Follow target. It will set the virtual camera's rotation to be the same as that of the Follow Target.",
+ MessageType.Warning);
+ EditorGUI.BeginChangeCheck();
+ GUI.enabled = false;
+ EditorGUILayout.LabelField(" ", "No additional settings", EditorStyles.miniLabel);
+ GUI.enabled = true;
+ DrawRemainingPropertiesInInspector();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: fc54afb14b6b01a4dabc4c8831cb7bf7
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using Cinemachine.Utility;
+
+namespace Cinemachine.Editor
+{
+ public class CinemachineScreenComposerGuides
+ {
+ public delegate Rect RectGetter();
+ public delegate void RectSetter(Rect r);
+ public delegate SerializedObject ObjectGetter();
+
+ // Clients MUST implement all of these
+ public RectGetter GetHardGuide;
+ public RectGetter GetSoftGuide;
+ public RectSetter SetHardGuide;
+ public RectSetter SetSoftGuide;
+ public ObjectGetter Target;
+
+ public const float kGuideBarWidthPx = 3f;
+
+ public void SetNewBounds(Rect oldHard, Rect oldSoft, Rect newHard, Rect newSoft)
+ {
+ if ((oldSoft != newSoft) || (oldHard != newHard))
+ {
+ Undo.RecordObject(Target().targetObject, "Composer Bounds");
+ if (oldSoft != newSoft)
+ SetSoftGuide(newSoft);
+ if (oldHard != newHard)
+ SetHardGuide(newHard);
+ Target().ApplyModifiedProperties();
+ }
+ }
+
+ public void OnGUI_DrawGuides(bool isLive, Camera outputCamera, LensSettings lens, bool showHardGuides)
+ {
+ Rect gateRect = outputCamera.pixelRect;
+ Rect cameraRect = gateRect;
+ float screenWidth = cameraRect.width;
+ float screenHeight = screenWidth / lens.Aspect;
+ cameraRect.yMax = Screen.height - gateRect.yMin;
+ cameraRect.yMin = cameraRect.yMax - gateRect.height;
+
+ // Shift the guides along with the lens
+ cameraRect.position += new Vector2(
+ -screenWidth * lens.LensShift.x, screenHeight * lens.LensShift.y);
+
+ // Rotate the guides along with the dutch
+ Matrix4x4 oldMatrix = GUI.matrix;
+ GUI.matrix = Matrix4x4.Translate(cameraRect.min);
+ GUIUtility.RotateAroundPivot(lens.Dutch, cameraRect.center);
+ Color hardBarsColour = CinemachineSettings.ComposerSettings.HardBoundsOverlayColour;
+ Color softBarsColour = CinemachineSettings.ComposerSettings.SoftBoundsOverlayColour;
+ float overlayOpacity = CinemachineSettings.ComposerSettings.OverlayOpacity;
+ if (!isLive)
+ {
+ softBarsColour = CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour;
+ hardBarsColour = Color.Lerp(softBarsColour, Color.black, 0.5f);
+ overlayOpacity /= 2;
+ }
+ hardBarsColour.a *= overlayOpacity;
+ softBarsColour.a *= overlayOpacity;
+
+ Rect r = showHardGuides ? GetHardGuide() : new Rect(-2, -2, 4, 4);
+ float hardEdgeLeft = r.xMin * screenWidth;
+ float hardEdgeTop = r.yMin * screenHeight;
+ float hardEdgeRight = r.xMax * screenWidth;
+ float hardEdgeBottom = r.yMax * screenHeight;
+
+ mDragBars[(int)DragBar.HardBarLineLeft] = new Rect(hardEdgeLeft - kGuideBarWidthPx / 2f, 0f, kGuideBarWidthPx, screenHeight);
+ mDragBars[(int)DragBar.HardBarLineTop] = new Rect(0f, hardEdgeTop - kGuideBarWidthPx / 2f, screenWidth, kGuideBarWidthPx);
+ mDragBars[(int)DragBar.HardBarLineRight] = new Rect(hardEdgeRight - kGuideBarWidthPx / 2f, 0f, kGuideBarWidthPx, screenHeight);
+ mDragBars[(int)DragBar.HardBarLineBottom] = new Rect(0f, hardEdgeBottom - kGuideBarWidthPx / 2f, screenWidth, kGuideBarWidthPx);
+
+ r = GetSoftGuide();
+ float softEdgeLeft = r.xMin * screenWidth;
+ float softEdgeTop = r.yMin * screenHeight;
+ float softEdgeRight = r.xMax * screenWidth;
+ float softEdgeBottom = r.yMax * screenHeight;
+
+ mDragBars[(int)DragBar.SoftBarLineLeft] = new Rect(softEdgeLeft - kGuideBarWidthPx / 2f, 0f, kGuideBarWidthPx, screenHeight);
+ mDragBars[(int)DragBar.SoftBarLineTop] = new Rect(0f, softEdgeTop - kGuideBarWidthPx / 2f, screenWidth, kGuideBarWidthPx);
+ mDragBars[(int)DragBar.SoftBarLineRight] = new Rect(softEdgeRight - kGuideBarWidthPx / 2f, 0f, kGuideBarWidthPx, screenHeight);
+ mDragBars[(int)DragBar.SoftBarLineBottom] = new Rect(0f, softEdgeBottom - kGuideBarWidthPx / 2f, screenWidth, kGuideBarWidthPx);
+
+ mDragBars[(int)DragBar.Center] = new Rect(softEdgeLeft, softEdgeTop, softEdgeRight - softEdgeLeft, softEdgeBottom - softEdgeTop);
+
+ // Handle dragging bars
+ if (isLive)
+ OnGuiHandleBarDragging(screenWidth, screenHeight);
+
+ // Draw the masks
+ GUI.color = hardBarsColour;
+ Rect hardBarLeft = new Rect(0, hardEdgeTop, Mathf.Max(0, hardEdgeLeft), hardEdgeBottom - hardEdgeTop);
+ Rect hardBarRight = new Rect(hardEdgeRight, hardEdgeTop,
+ Mathf.Max(0, screenWidth - hardEdgeRight), hardEdgeBottom - hardEdgeTop);
+ Rect hardBarTop = new Rect(Mathf.Min(0, hardEdgeLeft), 0,
+ Mathf.Max(screenWidth, hardEdgeRight) - Mathf.Min(0, hardEdgeLeft), Mathf.Max(0, hardEdgeTop));
+ Rect hardBarBottom = new Rect(Mathf.Min(0, hardEdgeLeft), hardEdgeBottom,
+ Mathf.Max(screenWidth, hardEdgeRight) - Mathf.Min(0, hardEdgeLeft),
+ Mathf.Max(0, screenHeight - hardEdgeBottom));
+ GUI.DrawTexture(hardBarLeft, Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(hardBarTop, Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(hardBarRight, Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(hardBarBottom, Texture2D.whiteTexture, ScaleMode.StretchToFill);
+
+ GUI.color = softBarsColour;
+ Rect softBarLeft = new Rect(hardEdgeLeft, softEdgeTop, softEdgeLeft - hardEdgeLeft, softEdgeBottom - softEdgeTop);
+ Rect softBarTop = new Rect(hardEdgeLeft, hardEdgeTop, hardEdgeRight - hardEdgeLeft, softEdgeTop - hardEdgeTop);
+ Rect softBarRight = new Rect(softEdgeRight, softEdgeTop, hardEdgeRight - softEdgeRight, softEdgeBottom - softEdgeTop);
+ Rect softBarBottom = new Rect(hardEdgeLeft, softEdgeBottom, hardEdgeRight - hardEdgeLeft, hardEdgeBottom - softEdgeBottom);
+ GUI.DrawTexture(softBarLeft, Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(softBarTop, Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(softBarRight, Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(softBarBottom, Texture2D.whiteTexture, ScaleMode.StretchToFill);
+
+ // Draw the drag bars
+ GUI.DrawTexture(mDragBars[(int)DragBar.SoftBarLineLeft], Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(mDragBars[(int)DragBar.SoftBarLineTop], Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(mDragBars[(int)DragBar.SoftBarLineRight], Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(mDragBars[(int)DragBar.SoftBarLineBottom], Texture2D.whiteTexture, ScaleMode.StretchToFill);
+
+ GUI.color = hardBarsColour;
+ GUI.DrawTexture(mDragBars[(int)DragBar.HardBarLineLeft], Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(mDragBars[(int)DragBar.HardBarLineTop], Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(mDragBars[(int)DragBar.HardBarLineRight], Texture2D.whiteTexture, ScaleMode.StretchToFill);
+ GUI.DrawTexture(mDragBars[(int)DragBar.HardBarLineBottom], Texture2D.whiteTexture, ScaleMode.StretchToFill);
+
+ GUI.matrix = oldMatrix;
+ }
+
+ // For dragging the bars - order defines precedence
+ private enum DragBar
+ {
+ Center,
+ SoftBarLineLeft, SoftBarLineTop, SoftBarLineRight, SoftBarLineBottom,
+ HardBarLineLeft, HardBarLineTop, HardBarLineRight, HardBarLineBottom,
+ NONE
+ };
+ private DragBar mDragging = DragBar.NONE;
+ private Rect[] mDragBars = new Rect[9];
+
+ private void OnGuiHandleBarDragging(float screenWidth, float screenHeight)
+ {
+ if (Event.current.type == EventType.MouseUp)
+ mDragging = DragBar.NONE;
+ if (Event.current.type == EventType.MouseDown)
+ {
+ mDragging = DragBar.NONE;
+ for (DragBar i = DragBar.Center; i < DragBar.NONE && mDragging == DragBar.NONE; ++i)
+ {
+ Vector2 slop = new Vector2(5f, 5f);
+ if (i == DragBar.Center)
+ {
+ if (mDragBars[(int)i].width > 3f * slop.x)
+ slop.x = -slop.x;
+ if (mDragBars[(int)i].height > 3f * slop.y)
+ slop.y = -slop.y;
+ }
+ Rect r = mDragBars[(int)i].Inflated(slop);
+ if (r.Contains(Event.current.mousePosition))
+ mDragging = i;
+ }
+ }
+
+ if (mDragging != DragBar.NONE && Event.current.type == EventType.MouseDrag)
+ {
+ Vector2 d = new Vector2(
+ Event.current.delta.x / screenWidth,
+ Event.current.delta.y / screenHeight);
+
+ // First snapshot some settings
+ Rect newHard = GetHardGuide();
+ Rect newSoft = GetSoftGuide();
+ Vector2 changed = Vector2.zero;
+ switch (mDragging)
+ {
+ case DragBar.Center: newSoft.position += d; break;
+ case DragBar.SoftBarLineLeft: newSoft = newSoft.Inflated(new Vector2(-d.x, 0)); break;
+ case DragBar.SoftBarLineRight: newSoft = newSoft.Inflated(new Vector2(d.x, 0)); break;
+ case DragBar.SoftBarLineTop: newSoft = newSoft.Inflated(new Vector2(0, -d.y)); break;
+ case DragBar.SoftBarLineBottom: newSoft = newSoft.Inflated(new Vector2(0, d.y)); break;
+ case DragBar.HardBarLineLeft: newHard = newHard.Inflated(new Vector2(-d.x, 0)); break;
+ case DragBar.HardBarLineRight: newHard = newHard.Inflated(new Vector2(d.x, 0)); break;
+ case DragBar.HardBarLineBottom: newHard = newHard.Inflated(new Vector2(0, d.y)); break;
+ case DragBar.HardBarLineTop: newHard = newHard.Inflated(new Vector2(0, -d.y)); break;
+ }
+
+ // Apply the changes, enforcing the bounds
+ SetNewBounds(GetHardGuide(), GetSoftGuide(), newHard, newSoft);
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 2a15a1e455bcc7543872f50762449739
+timeCreated: 1502028239
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using UnityEngine;
+using System.Collections.Generic;
+using UnityEditorInternal;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineSmoothPath))]
+ internal sealed class CinemachineSmoothPathEditor : BaseEditor<CinemachineSmoothPath>
+ {
+ private ReorderableList mWaypointList;
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_Waypoints));
+ return excluded;
+ }
+
+ void OnEnable()
+ {
+ mWaypointList = null;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (mWaypointList == null)
+ SetupWaypointList();
+
+ if (mWaypointList.index >= mWaypointList.count)
+ mWaypointList.index = mWaypointList.count - 1;
+
+ // Ordinary properties
+ DrawRemainingPropertiesInInspector();
+
+ // Path length
+ EditorGUILayout.LabelField("Path Length", Target.PathLength.ToString());
+
+ // Waypoints
+ EditorGUI.BeginChangeCheck();
+ mWaypointList.DoLayoutList();
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ void SetupWaypointList()
+ {
+ mWaypointList = new ReorderableList(
+ serializedObject, FindProperty(x => x.m_Waypoints),
+ true, true, true, true);
+
+ mWaypointList.drawHeaderCallback = (Rect rect) =>
+ { EditorGUI.LabelField(rect, "Waypoints"); };
+
+ mWaypointList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ { DrawWaypointEditor(rect, index); };
+
+ mWaypointList.onAddCallback = (ReorderableList l) =>
+ { InsertWaypointAtIndex(l.index); };
+ }
+
+ void DrawWaypointEditor(Rect rect, int index)
+ {
+ // Needed for accessing string names of fields
+ CinemachineSmoothPath.Waypoint def = new CinemachineSmoothPath.Waypoint();
+ SerializedProperty element = mWaypointList.serializedProperty.GetArrayElementAtIndex(index);
+
+ float hSpace = 3;
+ rect.width -= hSpace; rect.y += 1;
+ Vector2 numberDimension = GUI.skin.label.CalcSize(new GUIContent("999"));
+ Rect r = new Rect(rect.position, numberDimension);
+ if (GUI.Button(r, new GUIContent(index.ToString(), "Go to the waypoint in the scene view")))
+ {
+ if (SceneView.lastActiveSceneView != null)
+ {
+ mWaypointList.index = index;
+ SceneView.lastActiveSceneView.pivot = Target.EvaluatePosition(index);
+ SceneView.lastActiveSceneView.size = 4;
+ SceneView.lastActiveSceneView.Repaint();
+ }
+ }
+
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 2f;
+ GUIContent rollLabel = new GUIContent("Roll");
+ Vector2 labelDimension = GUI.skin.label.CalcSize(rollLabel);
+ float rollWidth = labelDimension.x + floatFieldWidth;
+ r.x += r.width + hSpace; r.width = rect.width - (r.width + hSpace + rollWidth) - (r.height + hSpace);
+ EditorGUI.PropertyField(r, element.FindPropertyRelative(() => def.position), GUIContent.none);
+
+ r.x += r.width + hSpace; r.width = rollWidth;
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = labelDimension.x;
+ EditorGUI.PropertyField(r, element.FindPropertyRelative(() => def.roll), rollLabel);
+ EditorGUIUtility.labelWidth = oldWidth;
+
+ r.x += r.width + hSpace; r.height += 1; r.width = r.height;
+ GUIContent setButtonContent = EditorGUIUtility.IconContent("d_RectTransform Icon");
+ setButtonContent.tooltip = "Set to scene-view camera position";
+ if (GUI.Button(r, setButtonContent, GUI.skin.label) && SceneView.lastActiveSceneView != null)
+ {
+ Undo.RecordObject(Target, "Set waypoint");
+ CinemachineSmoothPath.Waypoint wp = Target.m_Waypoints[index];
+ Vector3 pos = SceneView.lastActiveSceneView.camera.transform.position;
+ wp.position = Target.transform.InverseTransformPoint(pos);
+ Target.m_Waypoints[index] = wp;
+ }
+ }
+
+ void InsertWaypointAtIndex(int indexA)
+ {
+ Vector3 pos = Vector3.right;
+ float roll = 0;
+
+ // Get new values from the current indexA (if any)
+ int numWaypoints = Target.m_Waypoints.Length;
+ if (indexA < 0)
+ indexA = numWaypoints - 1;
+ if (indexA >= 0)
+ {
+ int indexB = indexA + 1;
+ if (Target.m_Looped && indexB >= numWaypoints)
+ indexB = 0;
+ if (indexB >= numWaypoints)
+ {
+ Vector3 delta = Vector3.right;
+ if (indexA > 0)
+ delta = Target.m_Waypoints[indexA].position - Target.m_Waypoints[indexA-1].position;
+ pos = Target.m_Waypoints[indexA].position + delta;
+ roll = Target.m_Waypoints[indexA].roll;
+ }
+ else
+ {
+ // Interpolate
+ pos = Target.transform.InverseTransformPoint(Target.EvaluatePosition(0.5f + indexA));
+ roll = Mathf.Lerp(Target.m_Waypoints[indexA].roll, Target.m_Waypoints[indexB].roll, 0.5f);
+ }
+ }
+ Undo.RecordObject(Target, "Add waypoint");
+ var wp = new CinemachineSmoothPath.Waypoint();
+ wp.position = pos;
+ wp.roll = roll;
+ var list = new List<CinemachineSmoothPath.Waypoint>(Target.m_Waypoints);
+ list.Insert(indexA + 1, wp);
+ Target.m_Waypoints = list.ToArray();
+ Target.InvalidateDistanceCache();
+ InternalEditorUtility.RepaintAllViews();
+ mWaypointList.index = indexA + 1; // select it
+ }
+
+ void OnSceneGUI()
+ {
+ if (mWaypointList == null)
+ SetupWaypointList();
+
+ if (Tools.current == Tool.Move)
+ {
+ Color colorOld = Handles.color;
+ var localToWorld = Target.transform.localToWorldMatrix;
+ for (int i = 0; i < Target.m_Waypoints.Length; ++i)
+ {
+ DrawSelectionHandle(i, localToWorld);
+ if (mWaypointList.index == i)
+ DrawPositionControl(i, localToWorld, Target.transform.rotation); // Waypoint is selected
+ }
+ Handles.color = colorOld;
+ }
+ }
+
+ void DrawSelectionHandle(int i, Matrix4x4 localToWorld)
+ {
+ if (Event.current.button != 1)
+ {
+ Vector3 pos = localToWorld.MultiplyPoint(Target.m_Waypoints[i].position);
+ float size = HandleUtility.GetHandleSize(pos) * 0.2f;
+ Handles.color = Color.white;
+ if (Handles.Button(pos, Quaternion.identity, size, size, Handles.SphereHandleCap)
+ && mWaypointList.index != i)
+ {
+ mWaypointList.index = i;
+ InternalEditorUtility.RepaintAllViews();
+ }
+ // Label it
+ Handles.BeginGUI();
+ Vector2 labelSize = new Vector2(
+ EditorGUIUtility.singleLineHeight * 2, EditorGUIUtility.singleLineHeight);
+ Vector2 labelPos = HandleUtility.WorldToGUIPoint(pos);
+ labelPos.y -= labelSize.y / 2;
+ labelPos.x -= labelSize.x / 2;
+ GUILayout.BeginArea(new Rect(labelPos, labelSize));
+ GUIStyle style = new GUIStyle();
+ style.normal.textColor = Color.black;
+ style.alignment = TextAnchor.MiddleCenter;
+ GUILayout.Label(new GUIContent(i.ToString(), "Waypoint " + i), style);
+ GUILayout.EndArea();
+ Handles.EndGUI();
+ }
+ }
+
+ void DrawPositionControl(int i, Matrix4x4 localToWorld, Quaternion localRotation)
+ {
+ CinemachineSmoothPath.Waypoint wp = Target.m_Waypoints[i];
+ Vector3 pos = localToWorld.MultiplyPoint(wp.position);
+ EditorGUI.BeginChangeCheck();
+ Handles.color = Target.m_Appearance.pathColor;
+ Quaternion rotation = (Tools.pivotRotation == PivotRotation.Local)
+ ? localRotation : Quaternion.identity;
+ float size = HandleUtility.GetHandleSize(pos) * 0.1f;
+ Handles.SphereHandleCap(0, pos, rotation, size, EventType.Repaint);
+ pos = Handles.PositionHandle(pos, rotation);
+ if (EditorGUI.EndChangeCheck())
+ {
+ Undo.RecordObject(target, "Move Waypoint");
+ wp.position = Matrix4x4.Inverse(localToWorld).MultiplyPoint(pos);
+ Target.m_Waypoints[i] = wp;
+ Target.InvalidateDistanceCache();
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.NotInSelectionHierarchy
+ | GizmoType.InSelectionHierarchy | GizmoType.Pickable, typeof(CinemachineSmoothPath))]
+ static void DrawGizmos(CinemachineSmoothPath path, GizmoType selectionType)
+ {
+ CinemachinePathEditor.DrawPathGizmo(path,
+ (Selection.activeGameObject == path.gameObject)
+ ? path.m_Appearance.pathColor : path.m_Appearance.inactivePathColor);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 1123a444101eb774ba7490990b50736a
+timeCreated: 1505831686
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+using UnityEditor.Animations;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineStateDrivenCamera))]
+ internal sealed class CinemachineStateDrivenCameraEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineStateDrivenCamera>
+ {
+ EmbeddeAssetEditor<CinemachineBlenderSettings> m_BlendsEditor;
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_CustomBlends));
+ excluded.Add(FieldPath(x => x.m_Instructions));
+ return excluded;
+ }
+
+ private UnityEditorInternal.ReorderableList mChildList;
+ private UnityEditorInternal.ReorderableList mInstructionList;
+
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ m_BlendsEditor = new EmbeddeAssetEditor<CinemachineBlenderSettings>(
+ FieldPath(x => x.m_CustomBlends), this);
+ m_BlendsEditor.OnChanged = (CinemachineBlenderSettings b) =>
+ {
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ };
+ m_BlendsEditor.OnCreateEditor = (UnityEditor.Editor ed) =>
+ {
+ CinemachineBlenderSettingsEditor editor = ed as CinemachineBlenderSettingsEditor;
+ if (editor != null)
+ editor.GetAllVirtualCameras = () => { return Target.ChildCameras; };
+ };
+ mChildList = null;
+ mInstructionList = null;
+ }
+
+ protected override void OnDisable()
+ {
+ base.OnDisable();
+ if (m_BlendsEditor != null)
+ m_BlendsEditor.OnDisable();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (mInstructionList == null)
+ SetupInstructionList();
+ if (mChildList == null)
+ SetupChildList();
+
+ if (Target.m_AnimatedTarget == null)
+ EditorGUILayout.HelpBox("An Animated Target is required", MessageType.Warning);
+
+ // Ordinary properties
+ DrawHeaderInInspector();
+ DrawPropertyInInspector(FindProperty(x => x.m_Priority));
+ DrawTargetsInInspector(FindProperty(x => x.m_Follow), FindProperty(x => x.m_LookAt));
+ DrawPropertyInInspector(FindProperty(x => x.m_AnimatedTarget));
+
+ // Layer index
+ EditorGUI.BeginChangeCheck();
+ UpdateTargetStates();
+ UpdateCameraCandidates();
+ SerializedProperty layerProp = FindAndExcludeProperty(x => x.m_LayerIndex);
+ int currentLayer = layerProp.intValue;
+ int layerSelection = EditorGUILayout.Popup("Layer", currentLayer, mLayerNames);
+ if (currentLayer != layerSelection)
+ layerProp.intValue = layerSelection;
+ if (EditorGUI.EndChangeCheck())
+ {
+ serializedObject.ApplyModifiedProperties();
+ Target.ValidateInstructions();
+ }
+
+ DrawRemainingPropertiesInInspector();
+
+ // Blends
+ m_BlendsEditor.DrawEditorCombo(
+ "Create New Blender Asset",
+ Target.gameObject.name + " Blends", "asset", string.Empty,
+ "Custom Blends", false);
+
+ // Instructions
+ EditorGUI.BeginChangeCheck();
+ EditorGUILayout.Separator();
+ mInstructionList.DoLayoutList();
+
+ // vcam children
+ EditorGUILayout.Separator();
+ mChildList.DoLayoutList();
+ if (EditorGUI.EndChangeCheck())
+ {
+ serializedObject.ApplyModifiedProperties();
+ Target.ValidateInstructions();
+ }
+
+ // Extensions
+ DrawExtensionsWidgetInInspector();
+ }
+
+ static AnimatorController GetControllerFromAnimator(Animator animator)
+ {
+ if (animator == null)
+ return null;
+ var ovr = animator.runtimeAnimatorController as AnimatorOverrideController;
+ if (ovr)
+ return ovr.runtimeAnimatorController as AnimatorController;
+ return animator.runtimeAnimatorController as AnimatorController;
+ }
+
+ private string[] mLayerNames;
+ private int[] mTargetStates;
+ private string[] mTargetStateNames;
+ private Dictionary<int, int> mStateIndexLookup;
+ private void UpdateTargetStates()
+ {
+ // Scrape the Animator Controller for states
+ AnimatorController ac = GetControllerFromAnimator(Target.m_AnimatedTarget);
+ StateCollector collector = new StateCollector();
+ collector.CollectStates(ac, Target.m_LayerIndex);
+ mTargetStates = collector.mStates.ToArray();
+ mTargetStateNames = collector.mStateNames.ToArray();
+ mStateIndexLookup = collector.mStateIndexLookup;
+
+ if (ac == null)
+ mLayerNames = new string[0];
+ else
+ {
+ mLayerNames = new string[ac.layers.Length];
+ for (int i = 0; i < ac.layers.Length; ++i)
+ mLayerNames[i] = ac.layers[i].name;
+ }
+
+ // Create the parent map in the target
+ List<CinemachineStateDrivenCamera.ParentHash> parents
+ = new List<CinemachineStateDrivenCamera.ParentHash>();
+ foreach (var i in collector.mStateParentLookup)
+ parents.Add(new CinemachineStateDrivenCamera.ParentHash(i.Key, i.Value));
+ Target.m_ParentHash = parents.ToArray();
+ }
+
+ class StateCollector
+ {
+ public List<int> mStates;
+ public List<string> mStateNames;
+ public Dictionary<int, int> mStateIndexLookup;
+ public Dictionary<int, int> mStateParentLookup;
+
+ public void CollectStates(AnimatorController ac, int layerIndex)
+ {
+ mStates = new List<int>();
+ mStateNames = new List<string>();
+ mStateIndexLookup = new Dictionary<int, int>();
+ mStateParentLookup = new Dictionary<int, int>();
+
+ mStateIndexLookup[0] = mStates.Count;
+ mStateNames.Add("(default)");
+ mStates.Add(0);
+
+ if (ac != null && layerIndex >= 0 && layerIndex < ac.layers.Length)
+ {
+ AnimatorStateMachine fsm = ac.layers[layerIndex].stateMachine;
+ string name = fsm.name;
+ int hash = Animator.StringToHash(name);
+ CollectStatesFromFSM(fsm, name + ".", hash, string.Empty);
+ }
+ }
+
+ void CollectStatesFromFSM(
+ AnimatorStateMachine fsm, string hashPrefix, int parentHash, string displayPrefix)
+ {
+ ChildAnimatorState[] states = fsm.states;
+ for (int i = 0; i < states.Length; i++)
+ {
+ AnimatorState state = states[i].state;
+ int hash = AddState(Animator.StringToHash(hashPrefix + state.name),
+ parentHash, displayPrefix + state.name);
+
+ // Also process clips as pseudo-states, if more than 1 is present.
+ // Since they don't have hashes, we can manufacture some.
+ var clips = CollectClips(state.motion);
+ if (clips.Count > 1)
+ {
+ string substatePrefix = displayPrefix + state.name + ".";
+ foreach (AnimationClip c in clips)
+ AddState(
+ CinemachineStateDrivenCamera.CreateFakeHash(hash, c),
+ hash, substatePrefix + c.name);
+ }
+ }
+
+ ChildAnimatorStateMachine[] fsmChildren = fsm.stateMachines;
+ foreach (var child in fsmChildren)
+ {
+ string name = hashPrefix + child.stateMachine.name;
+ string displayName = displayPrefix + child.stateMachine.name;
+ int hash = AddState(Animator.StringToHash(name), parentHash, displayName);
+ CollectStatesFromFSM(child.stateMachine, name + ".", hash, displayName + ".");
+ }
+ }
+
+ List<AnimationClip> CollectClips(Motion motion)
+ {
+ var clips = new List<AnimationClip>();
+ AnimationClip clip = motion as AnimationClip;
+ if (clip != null)
+ clips.Add(clip);
+ BlendTree tree = motion as BlendTree;
+ if (tree != null)
+ {
+ ChildMotion[] children = tree.children;
+ foreach (var child in children)
+ clips.AddRange(CollectClips(child.motion));
+ }
+ return clips;
+ }
+
+ int AddState(int hash, int parentHash, string displayName)
+ {
+ if (parentHash != 0)
+ mStateParentLookup[hash] = parentHash;
+ mStateIndexLookup[hash] = mStates.Count;
+ mStateNames.Add(displayName);
+ mStates.Add(hash);
+ return hash;
+ }
+ }
+
+ private int GetStateHashIndex(int stateHash)
+ {
+ if (stateHash == 0)
+ return 0;
+ if (!mStateIndexLookup.ContainsKey(stateHash))
+ return 0;
+ return mStateIndexLookup[stateHash];
+ }
+
+ private string[] mCameraCandidates;
+ private Dictionary<CinemachineVirtualCameraBase, int> mCameraIndexLookup;
+ private void UpdateCameraCandidates()
+ {
+ List<string> vcams = new List<string>();
+ mCameraIndexLookup = new Dictionary<CinemachineVirtualCameraBase, int>();
+ vcams.Add("(none)");
+ CinemachineVirtualCameraBase[] children = Target.ChildCameras;
+ foreach (var c in children)
+ {
+ mCameraIndexLookup[c] = vcams.Count;
+ vcams.Add(c.Name);
+ }
+ mCameraCandidates = vcams.ToArray();
+ }
+
+ private int GetCameraIndex(Object obj)
+ {
+ if (obj == null || mCameraIndexLookup == null)
+ return 0;
+ CinemachineVirtualCameraBase vcam = obj as CinemachineVirtualCameraBase;
+ if (vcam == null)
+ return 0;
+ if (!mCameraIndexLookup.ContainsKey(vcam))
+ return 0;
+ return mCameraIndexLookup[vcam];
+ }
+
+ void SetupInstructionList()
+ {
+ mInstructionList = new UnityEditorInternal.ReorderableList(serializedObject,
+ serializedObject.FindProperty(() => Target.m_Instructions),
+ true, true, true, true);
+
+ // Needed for accessing field names as strings
+ CinemachineStateDrivenCamera.Instruction def = new CinemachineStateDrivenCamera.Instruction();
+
+ float vSpace = 2;
+ float hSpace = 3;
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 2.5f;
+ float hBigSpace = EditorGUIUtility.singleLineHeight * 2 / 3;
+ mInstructionList.drawHeaderCallback = (Rect rect) =>
+ {
+ float sharedWidth = rect.width - EditorGUIUtility.singleLineHeight
+ - 2 * (hBigSpace + floatFieldWidth) - hSpace;
+ rect.x += EditorGUIUtility.singleLineHeight; rect.width = sharedWidth / 2;
+ EditorGUI.LabelField(rect, "State");
+
+ rect.x += rect.width + hSpace;
+ EditorGUI.LabelField(rect, "Camera");
+
+ rect.x += rect.width + hBigSpace; rect.width = floatFieldWidth;
+ EditorGUI.LabelField(rect, "Wait");
+
+ rect.x += rect.width + hBigSpace;
+ EditorGUI.LabelField(rect, "Min");
+ };
+
+ mInstructionList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ SerializedProperty instProp
+ = mInstructionList.serializedProperty.GetArrayElementAtIndex(index);
+ float sharedWidth = rect.width - 2 * (hBigSpace + floatFieldWidth) - hSpace;
+ rect.y += vSpace; rect.height = EditorGUIUtility.singleLineHeight;
+
+ rect.width = sharedWidth / 2;
+ SerializedProperty stateSelProp = instProp.FindPropertyRelative(() => def.m_FullHash);
+ int currentState = GetStateHashIndex(stateSelProp.intValue);
+ int stateSelection = EditorGUI.Popup(rect, currentState, mTargetStateNames);
+ if (currentState != stateSelection)
+ stateSelProp.intValue = mTargetStates[stateSelection];
+
+ rect.x += rect.width + hSpace;
+ SerializedProperty vcamSelProp = instProp.FindPropertyRelative(() => def.m_VirtualCamera);
+ int currentVcam = GetCameraIndex(vcamSelProp.objectReferenceValue);
+ int vcamSelection = EditorGUI.Popup(rect, currentVcam, mCameraCandidates);
+ if (currentVcam != vcamSelection)
+ vcamSelProp.objectReferenceValue = (vcamSelection == 0)
+ ? null : Target.ChildCameras[vcamSelection - 1];
+
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = hBigSpace;
+
+ rect.x += rect.width; rect.width = floatFieldWidth + hBigSpace;
+ SerializedProperty activeAfterProp = instProp.FindPropertyRelative(() => def.m_ActivateAfter);
+ EditorGUI.PropertyField(rect, activeAfterProp, new GUIContent(" ", activeAfterProp.tooltip));
+
+ rect.x += rect.width;
+ SerializedProperty minDurationProp = instProp.FindPropertyRelative(() => def.m_MinDuration);
+ EditorGUI.PropertyField(rect, minDurationProp, new GUIContent(" ", minDurationProp.tooltip));
+
+ EditorGUIUtility.labelWidth = oldWidth;
+ };
+
+ mInstructionList.onAddDropdownCallback = (Rect buttonRect, UnityEditorInternal.ReorderableList l) =>
+ {
+ var menu = new GenericMenu();
+ menu.AddItem(new GUIContent("New State"),
+ false, (object data) =>
+ {
+ ++mInstructionList.serializedProperty.arraySize;
+ serializedObject.ApplyModifiedProperties();
+ Target.ValidateInstructions();
+ },
+ null);
+ menu.AddItem(new GUIContent("All Unhandled States"),
+ false, (object data) =>
+ {
+ CinemachineStateDrivenCamera target = Target;
+ int len = mInstructionList.serializedProperty.arraySize;
+ for (int i = 0; i < mTargetStates.Length; ++i)
+ {
+ int hash = mTargetStates[i];
+ if (hash == 0)
+ continue;
+ bool alreadyThere = false;
+ for (int j = 0; j < len; ++j)
+ {
+ if (target.m_Instructions[j].m_FullHash == hash)
+ {
+ alreadyThere = true;
+ break;
+ }
+ }
+ if (!alreadyThere)
+ {
+ int index = mInstructionList.serializedProperty.arraySize;
+ ++mInstructionList.serializedProperty.arraySize;
+ SerializedProperty p = mInstructionList.serializedProperty.GetArrayElementAtIndex(index);
+ p.FindPropertyRelative(() => def.m_FullHash).intValue = hash;
+ }
+ }
+ serializedObject.ApplyModifiedProperties();
+ Target.ValidateInstructions();
+ },
+ null);
+ menu.ShowAsContext();
+ };
+ }
+
+ void SetupChildList()
+ {
+ float vSpace = 2;
+ float hSpace = 3;
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 2.5f;
+ float hBigSpace = EditorGUIUtility.singleLineHeight * 2 / 3;
+
+ mChildList = new UnityEditorInternal.ReorderableList(serializedObject,
+ serializedObject.FindProperty(() => Target.m_ChildCameras),
+ true, true, true, true);
+
+ mChildList.drawHeaderCallback = (Rect rect) =>
+ {
+ EditorGUI.LabelField(rect, "Virtual Camera Children");
+ GUIContent priorityText = new GUIContent("Priority");
+ var textDimensions = GUI.skin.label.CalcSize(priorityText);
+ rect.x += rect.width - textDimensions.x;
+ rect.width = textDimensions.x;
+ EditorGUI.LabelField(rect, priorityText);
+ };
+ mChildList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ rect.y += vSpace; rect.height = EditorGUIUtility.singleLineHeight;
+ rect.width -= floatFieldWidth + hBigSpace;
+ SerializedProperty element = mChildList.serializedProperty.GetArrayElementAtIndex(index);
+ EditorGUI.PropertyField(rect, element, GUIContent.none);
+
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = hBigSpace;
+ SerializedObject obj = new SerializedObject(element.objectReferenceValue);
+ rect.x += rect.width + hSpace; rect.width = floatFieldWidth + hBigSpace;
+ SerializedProperty priorityProp = obj.FindProperty(() => Target.m_Priority);
+ EditorGUI.PropertyField(rect, priorityProp, new GUIContent(" ", priorityProp.tooltip));
+ EditorGUIUtility.labelWidth = oldWidth;
+ obj.ApplyModifiedProperties();
+ };
+ mChildList.onChangedCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ if (l.index < 0 || l.index >= l.serializedProperty.arraySize)
+ return;
+ Object o = l.serializedProperty.GetArrayElementAtIndex(
+ l.index).objectReferenceValue;
+ CinemachineVirtualCameraBase vcam = (o != null)
+ ? (o as CinemachineVirtualCameraBase) : null;
+ if (vcam != null)
+ vcam.transform.SetSiblingIndex(l.index);
+ };
+ mChildList.onAddCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ var index = l.serializedProperty.arraySize;
+ var vcam = CinemachineMenu.CreateDefaultVirtualCamera();
+ Undo.SetTransformParent(vcam.transform, Target.transform, "");
+ vcam.transform.SetSiblingIndex(index);
+ };
+ mChildList.onRemoveCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ Object o = l.serializedProperty.GetArrayElementAtIndex(
+ l.index).objectReferenceValue;
+ CinemachineVirtualCameraBase vcam = (o != null)
+ ? (o as CinemachineVirtualCameraBase) : null;
+ if (vcam != null)
+ Undo.DestroyObjectImmediate(vcam.gameObject);
+ };
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 0eb9f23cde3a1734da334cfa0831dd25
+timeCreated: 1486062933
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_UGUI
+using UnityEngine;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineStoryboard))]
+ internal sealed class CinemachineStoryboardEditor : BaseEditor<CinemachineStoryboard>
+ {
+ public void OnDisable()
+ {
+ WaveformWindow.SetDefaultUpdateInterval();
+ }
+
+ const float FastWaveformUpdateInterval = 0.1f;
+ float mLastSplitScreenEventTime = 0;
+
+ public override void OnInspectorGUI()
+ {
+ float now = Time.realtimeSinceStartup;
+ if (now - mLastSplitScreenEventTime > FastWaveformUpdateInterval * 5)
+ WaveformWindow.SetDefaultUpdateInterval();
+
+ BeginInspector();
+ Rect rect = EditorGUILayout.GetControlRect(true);
+ EditorGUI.BeginChangeCheck();
+ {
+ float width = rect.width;
+ rect.width = EditorGUIUtility.labelWidth + rect.height;
+ EditorGUI.PropertyField(rect, FindProperty(x => x.m_ShowImage));
+
+ rect.x += rect.width; rect.width = width - rect.width;
+ EditorGUI.PropertyField(rect, FindProperty(x => x.m_Image), GUIContent.none);
+
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_Aspect));
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_Alpha));
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_Center));
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_Rotation));
+
+ rect = EditorGUILayout.GetControlRect(true);
+ EditorGUI.LabelField(rect, "Scale");
+ rect.x += EditorGUIUtility.labelWidth; rect.width -= EditorGUIUtility.labelWidth;
+ rect.width /= 3;
+ var prop = FindProperty(x => x.m_SyncScale);
+ GUIContent syncLabel = new GUIContent("Sync", prop.tooltip);
+ prop.boolValue = EditorGUI.ToggleLeft(rect, syncLabel, prop.boolValue);
+ rect.x += rect.width;
+ if (prop.boolValue)
+ {
+ prop = FindProperty(x => x.m_Scale);
+ float[] values = new float[1] { prop.vector2Value.x };
+ EditorGUI.MultiFloatField(rect, new GUIContent[1] { new GUIContent("X") }, values);
+ prop.vector2Value = new Vector2(values[0], values[0]);
+ }
+ else
+ {
+ rect.width *= 2;
+ EditorGUI.PropertyField(rect, FindProperty(x => x.m_Scale), GUIContent.none);
+ }
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_MuteCamera));
+ }
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+
+ EditorGUILayout.Space();
+ EditorGUI.BeginChangeCheck();
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_SplitView));
+ if (EditorGUI.EndChangeCheck())
+ {
+ mLastSplitScreenEventTime = now;
+ WaveformWindow.UpdateInterval = FastWaveformUpdateInterval;
+ serializedObject.ApplyModifiedProperties();
+ }
+ rect = EditorGUILayout.GetControlRect(true);
+ GUI.Label(new Rect(rect.x, rect.y, EditorGUIUtility.labelWidth, rect.height),
+ "Waveform Monitor");
+ rect.width -= EditorGUIUtility.labelWidth; rect.width /= 2;
+ rect.x += EditorGUIUtility.labelWidth;
+ if (GUI.Button(rect, "Open"))
+ WaveformWindow.OpenWindow();
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: a9e63e62da42ce141b35602019323584
+timeCreated: 1516812054
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineTargetGroup))]
+ internal sealed class CinemachineTargetGroupEditor : BaseEditor<CinemachineTargetGroup>
+ {
+ private UnityEditorInternal.ReorderableList mTargetList;
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_Targets));
+ return excluded;
+ }
+
+ void OnEnable()
+ {
+ mTargetList = null;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ DrawRemainingPropertiesInInspector();
+
+ if (mTargetList == null)
+ SetupTargetList();
+ EditorGUI.BeginChangeCheck();
+ mTargetList.DoLayoutList();
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ void SetupTargetList()
+ {
+ float vSpace = 2;
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 3f;
+ float hBigSpace = EditorGUIUtility.singleLineHeight * 2 / 3;
+
+ mTargetList = new UnityEditorInternal.ReorderableList(
+ serializedObject, FindProperty(x => x.m_Targets),
+ true, true, true, true);
+
+ // Needed for accessing field names as strings
+ CinemachineTargetGroup.Target def = new CinemachineTargetGroup.Target();
+
+ mTargetList.drawHeaderCallback = (Rect rect) =>
+ {
+ rect.width -= EditorGUIUtility.singleLineHeight + 2 * (floatFieldWidth + hBigSpace);
+ Vector2 pos = rect.position; pos.x += EditorGUIUtility.singleLineHeight;
+ rect.position = pos;
+ EditorGUI.LabelField(rect, "Target");
+
+ pos.x += rect.width + hBigSpace; rect.width = floatFieldWidth; rect.position = pos;
+ EditorGUI.LabelField(rect, "Weight");
+
+ pos.x += rect.width + hBigSpace; rect.position = pos;
+ EditorGUI.LabelField(rect, "Radius");
+ };
+
+ mTargetList.drawElementCallback
+ = (Rect rect, int index, bool isActive, bool isFocused) =>
+ {
+ SerializedProperty elemProp = mTargetList.serializedProperty.GetArrayElementAtIndex(index);
+
+ rect.y += vSpace;
+ rect.height = EditorGUIUtility.singleLineHeight;
+ Vector2 pos = rect.position;
+ //rect.width -= hSpace + 2 * EditorGUIUtility.singleLineHeight;
+ rect.width -= 2 * (floatFieldWidth + hBigSpace);
+ EditorGUI.PropertyField(rect, elemProp.FindPropertyRelative(() => def.target), GUIContent.none);
+
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = EditorGUIUtility.singleLineHeight;
+ pos.x += rect.width; rect.width = floatFieldWidth + hBigSpace; rect.position = pos;
+ EditorGUI.PropertyField(rect, elemProp.FindPropertyRelative(() => def.weight), new GUIContent(" "));
+ pos.x += rect.width; rect.position = pos;
+ EditorGUI.PropertyField(rect, elemProp.FindPropertyRelative(() => def.radius), new GUIContent(" "));
+ EditorGUIUtility.labelWidth = oldWidth;
+ };
+
+ mTargetList.onAddCallback = (UnityEditorInternal.ReorderableList l) =>
+ {
+ var index = l.serializedProperty.arraySize;
+ ++l.serializedProperty.arraySize;
+ SerializedProperty elemProp = mTargetList.serializedProperty.GetArrayElementAtIndex(index);
+ elemProp.FindPropertyRelative(() => def.weight).floatValue = 1;
+ };
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: eb8e037cb3f873743a725427c8c22342
+timeCreated: 1496424406
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineTrackedDolly))]
+ internal sealed class CinemachineTrackedDollyEditor : BaseEditor<CinemachineTrackedDolly>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ switch (Target.m_CameraUp)
+ {
+ default:
+ break;
+ case CinemachineTrackedDolly.CameraUpMode.PathNoRoll:
+ case CinemachineTrackedDolly.CameraUpMode.FollowTargetNoRoll:
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ break;
+ case CinemachineTrackedDolly.CameraUpMode.Default:
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_YawDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ break;
+ }
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (Target.m_Path == null)
+ EditorGUILayout.HelpBox("A Path is required", MessageType.Warning);
+ if (Target.m_AutoDolly.m_Enabled && Target.FollowTarget == null)
+ EditorGUILayout.HelpBox("AutoDolly requires a Follow Target", MessageType.Warning);
+ DrawRemainingPropertiesInInspector();
+ }
+
+ /// Process a position drag from the user.
+ /// Called "magically" by the vcam editor, so don't change the signature.
+ public void OnVcamPositionDragged(Vector3 delta)
+ {
+ Undo.RegisterCompleteObjectUndo(Target, "Camera drag"); // GML do we need this?
+ Quaternion targetOrientation = Target.m_Path.EvaluateOrientationAtUnit(
+ Target.m_PathPosition, Target.m_PositionUnits);
+ Vector3 localOffset = Quaternion.Inverse(targetOrientation) * delta;
+ FindProperty(x => x.m_PathOffset).vector3Value += localOffset;
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.InSelectionHierarchy, typeof(CinemachineTrackedDolly))]
+ private static void DrawTrackeDollyGizmos(CinemachineTrackedDolly target, GizmoType selectionType)
+ {
+ if (target.IsValid)
+ {
+ CinemachinePathBase path = target.m_Path;
+ if (path != null)
+ {
+ CinemachinePathEditor.DrawPathGizmo(path, path.m_Appearance.pathColor);
+ Vector3 pos = path.EvaluatePositionAtUnit(target.m_PathPosition, target.m_PositionUnits);
+ Color oldColor = Gizmos.color;
+ Gizmos.color = CinemachineCore.Instance.IsLive(target.VirtualCamera)
+ ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour
+ : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour;
+ Gizmos.DrawLine(pos, target.transform.position);
+ Gizmos.color = oldColor;
+ }
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: d4a408a1b506d0046875061c677944d8
+timeCreated: 1493318518
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineTransposer))]
+ internal sealed class CinemachineTransposerEditor : BaseEditor<CinemachineTransposer>
+ {
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+
+ switch (Target.m_BindingMode)
+ {
+ default:
+ case CinemachineTransposer.BindingMode.LockToTarget:
+ if (Target.m_AngularDampingMode == CinemachineTransposer.AngularDampingMode.Euler)
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ else
+ {
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_YawDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ }
+ break;
+ case CinemachineTransposer.BindingMode.LockToTargetNoRoll:
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDampingMode));
+ break;
+ case CinemachineTransposer.BindingMode.LockToTargetWithWorldUp:
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDampingMode));
+ break;
+ case CinemachineTransposer.BindingMode.LockToTargetOnAssign:
+ case CinemachineTransposer.BindingMode.WorldSpace:
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_YawDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDampingMode));
+ break;
+ case CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp:
+ excluded.Add(FieldPath(x => x.m_XDamping));
+ excluded.Add(FieldPath(x => x.m_PitchDamping));
+ excluded.Add(FieldPath(x => x.m_YawDamping));
+ excluded.Add(FieldPath(x => x.m_RollDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDamping));
+ excluded.Add(FieldPath(x => x.m_AngularDampingMode));
+ break;
+ }
+ if (Target.HideOffsetInInspector)
+ excluded.Add(FieldPath(x => x.m_FollowOffset));
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ if (Target.FollowTarget == null)
+ EditorGUILayout.HelpBox(
+ "Transposer requires a Follow Target. Change Body to Do Nothing if you don't want a Follow target.",
+ MessageType.Warning);
+ DrawRemainingPropertiesInInspector();
+ }
+
+ /// Process a position drag from the user.
+ /// Called "magically" by the vcam editor, so don't change the signature.
+ public void OnVcamPositionDragged(Vector3 delta)
+ {
+ Undo.RegisterCompleteObjectUndo(Target, "Camera drag"); // GML do we need this?
+ Quaternion targetOrientation = Target.GetReferenceOrientation(Target.VcamState.ReferenceUp);
+ Vector3 localOffset = Quaternion.Inverse(targetOrientation) * delta;
+ FindProperty(x => x.m_FollowOffset).vector3Value += localOffset;
+ serializedObject.ApplyModifiedProperties();
+ FindProperty(x => x.m_FollowOffset).vector3Value = Target.EffectiveOffset;
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.Selected, typeof(CinemachineTransposer))]
+ static void DrawTransposerGizmos(CinemachineTransposer target, GizmoType selectionType)
+ {
+ if (target.IsValid & !target.HideOffsetInInspector)
+ {
+ Color originalGizmoColour = Gizmos.color;
+ Gizmos.color = CinemachineCore.Instance.IsLive(target.VirtualCamera)
+ ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour
+ : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour;
+
+ Vector3 up = Vector3.up;
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(target.VirtualCamera);
+ if (brain != null)
+ up = brain.DefaultWorldUp;
+ Vector3 targetPos = target.FollowTargetPosition;
+ Vector3 desiredPos = target.GetTargetCameraPosition(up);
+ Gizmos.DrawLine(targetPos, desiredPos);
+ //Gizmos.DrawWireSphere(desiredPos, HandleUtility.GetHandleSize(desiredPos) / 20);
+ Gizmos.color = originalGizmoColour;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: f34e35dc1dc67c54c841b728548d69cc
+timeCreated: 1484088330
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+
+namespace Cinemachine.Editor
+{
+ /// <summary>
+ /// Base class for virtual camera editors.
+ /// Handles drawing the header and the basic properties.
+ /// </summary>
+ public class CinemachineVirtualCameraBaseEditor<T>
+ : BaseEditor<T> where T : CinemachineVirtualCameraBase
+ {
+ static Type[] sExtensionTypes; // First entry is null
+ static string[] sExtensionNames;
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ var excluded = base.GetExcludedPropertiesInInspector();
+ if (Target.m_ExcludedPropertiesInInspector != null)
+ excluded.AddRange(Target.m_ExcludedPropertiesInInspector);
+ return excluded;
+ }
+
+ protected virtual void OnEnable()
+ {
+ if (sExtensionTypes == null)
+ {
+ // Populate the extension list
+ List<Type> exts = new List<Type>();
+ List<string> names = new List<string>();
+ exts.Add(null);
+ names.Add("(select)");
+ var allExtensions
+ = ReflectionHelpers.GetTypesInAllDependentAssemblies(
+ (Type t) => typeof(CinemachineExtension).IsAssignableFrom(t));
+ foreach (Type t in allExtensions)
+ {
+ exts.Add(t);
+ names.Add(t.Name);
+ }
+ sExtensionTypes = exts.ToArray();
+ sExtensionNames = names.ToArray();
+ }
+ }
+
+ protected virtual void OnDisable()
+ {
+ if (CinemachineBrain.SoloCamera == (ICinemachineCamera)Target)
+ {
+ CinemachineBrain.SoloCamera = null;
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ DrawHeaderInInspector();
+ DrawRemainingPropertiesInInspector();
+ DrawExtensionsWidgetInInspector();
+ }
+
+ protected void DrawHeaderInInspector()
+ {
+ List<string> excluded = GetExcludedPropertiesInInspector();
+ if (!excluded.Contains("Header"))
+ {
+ DrawCameraStatusInInspector();
+ DrawGlobalControlsInInspector();
+ }
+ ExcludeProperty("Header");
+ }
+
+ protected void DrawTargetsInInspector(
+ SerializedProperty followTarget, SerializedProperty lookAtTarget)
+ {
+ List<string> excluded = GetExcludedPropertiesInInspector();
+ EditorGUI.BeginChangeCheck();
+ if (!excluded.Contains(followTarget.name))
+ {
+ if (Target.ParentCamera == null || Target.ParentCamera.Follow == null)
+ EditorGUILayout.PropertyField(followTarget);
+ else
+ EditorGUILayout.PropertyField(followTarget,
+ new GUIContent(followTarget.displayName + " Override"));
+ ExcludeProperty(followTarget.name);
+ }
+ if (!excluded.Contains(lookAtTarget.name))
+ {
+ if (Target.ParentCamera == null || Target.ParentCamera.LookAt == null)
+ EditorGUILayout.PropertyField(lookAtTarget);
+ else
+ EditorGUILayout.PropertyField(lookAtTarget,
+ new GUIContent(lookAtTarget.displayName + " Override"));
+ ExcludeProperty(lookAtTarget.name);
+ }
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ protected void DrawExtensionsWidgetInInspector()
+ {
+ List<string> excluded = GetExcludedPropertiesInInspector();
+ if (!excluded.Contains("Extensions"))
+ {
+ EditorGUILayout.Space();
+ EditorGUILayout.LabelField("Extensions", EditorStyles.boldLabel);
+ Rect rect = EditorGUILayout.GetControlRect(true, EditorGUIUtility.singleLineHeight);
+ rect = EditorGUI.PrefixLabel(rect, new GUIContent("Add Extension"));
+
+ int selection = EditorGUI.Popup(rect, 0, sExtensionNames);
+ if (selection > 0)
+ {
+ Type extType = sExtensionTypes[selection];
+ if (Target.GetComponent(extType) == null)
+ Undo.AddComponent(Target.gameObject, extType);
+ }
+ ExcludeProperty("Extensions");
+ }
+ }
+
+ protected void DrawCameraStatusInInspector()
+ {
+ // Is the camera navel-gazing?
+ CameraState state = Target.State;
+ if (state.HasLookAt && (state.ReferenceLookAt - state.CorrectedPosition).AlmostZero())
+ EditorGUILayout.HelpBox(
+ "The camera is positioned on the same point at which it is trying to look.",
+ MessageType.Warning);
+
+ // Active status and Solo button
+ Rect rect = EditorGUILayout.GetControlRect(true);
+ Rect rectLabel = new Rect(rect.x, rect.y, EditorGUIUtility.labelWidth, rect.height);
+ rect.width -= rectLabel.width;
+ rect.x += rectLabel.width;
+
+ Color color = GUI.color;
+ bool isSolo = (CinemachineBrain.SoloCamera == (ICinemachineCamera)Target);
+ if (isSolo)
+ GUI.color = CinemachineBrain.GetSoloGUIColor();
+
+ bool isLive = CinemachineCore.Instance.IsLive(Target);
+ GUI.enabled = isLive;
+ GUI.Label(rectLabel, isLive ? "Status: Live"
+ : (Target.isActiveAndEnabled ? "Status: Standby" : "Status: Disabled"));
+ GUI.enabled = true;
+
+ float labelWidth = 0;
+ GUIContent updateText = GUIContent.none;
+ UpdateTracker.UpdateClock updateMode = CinemachineCore.Instance.GetVcamUpdateStatus(Target);
+ if (Application.isPlaying)
+ {
+ updateText = new GUIContent(
+ updateMode == UpdateTracker.UpdateClock.Fixed ? " Fixed Update" : " Late Update");
+ var textDimensions = GUI.skin.label.CalcSize(updateText);
+ labelWidth = textDimensions.x;
+ }
+ rect.width -= labelWidth;
+ if (GUI.Button(rect, "Solo", "Button"))
+ {
+ isSolo = !isSolo;
+ CinemachineBrain.SoloCamera = isSolo ? Target : null;
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+ GUI.color = color;
+ if (isSolo && !Application.isPlaying)
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+
+ if (labelWidth > 0)
+ {
+ GUI.enabled = false;
+ rect.x += rect.width; rect.width = labelWidth;
+ GUI.Label(rect, updateText);
+ GUI.enabled = true;
+ }
+ }
+
+ protected void DrawGlobalControlsInInspector()
+ {
+ CinemachineSettings.CinemachineCoreSettings.ShowInGameGuides
+ = EditorGUILayout.Toggle(
+ new GUIContent(
+ "Game Window Guides",
+ "Enable the display of overlays in the Game window. You can adjust colours and opacity in Edit/Preferences/Cinemachine."),
+ CinemachineSettings.CinemachineCoreSettings.ShowInGameGuides);
+
+ SaveDuringPlay.SaveDuringPlay.Enabled
+ = EditorGUILayout.Toggle(
+ new GUIContent(
+ "Save During Play",
+ "If checked, Virtual Camera settings changes made during Play Mode will be propagated back to the scene when Play Mode is exited."),
+ SaveDuringPlay.SaveDuringPlay.Enabled);
+
+ if (Application.isPlaying && SaveDuringPlay.SaveDuringPlay.Enabled)
+ EditorGUILayout.HelpBox(
+ " Virtual Camera settings changes made during Play Mode will be propagated back to the scene when Play Mode is exited.",
+ MessageType.Info);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 211d719bb25901043833928f50e9d0ea
+timeCreated: 1506603196
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+using System.Reflection;
+using System.Linq;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineVirtualCamera))]
+ internal class CinemachineVirtualCameraEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineVirtualCamera>
+ {
+ // Static state and caches - Call UpdateStaticData() to refresh this
+ struct StageData
+ {
+ string ExpandedKey { get { return "CNMCN_Core_Vcam_Expanded_" + Name; } }
+ public bool IsExpanded
+ {
+ get { return EditorPrefs.GetBool(ExpandedKey, false); }
+ set { EditorPrefs.SetBool(ExpandedKey, value); }
+ }
+ public string Name;
+ public Type[] types; // first entry is null
+ public GUIContent[] PopupOptions;
+ }
+ static StageData[] sStageData = null;
+
+ // Instance data - call UpdateInstanceData() to refresh this
+ int[] m_stageState = null;
+ bool[] m_stageError = null;
+ CinemachineComponentBase[] m_components;
+ UnityEditor.Editor[] m_componentEditors = new UnityEditor.Editor[0];
+
+ protected override void OnEnable()
+ {
+ // Build static menu arrays via reflection
+ base.OnEnable();
+ UpdateStaticData();
+ }
+
+ protected override void OnDisable()
+ {
+ base.OnDisable();
+ // Must destroy editors or we get exceptions
+ if (m_componentEditors != null)
+ foreach (UnityEditor.Editor e in m_componentEditors)
+ if (e != null)
+ UnityEngine.Object.DestroyImmediate(e);
+ }
+
+ Vector3 mPreviousPosition;
+ private void OnSceneGUI()
+ {
+ if (!Target.UserIsDragging)
+ mPreviousPosition = Target.transform.position;
+ if (Selection.Contains(Target.gameObject) && Tools.current == Tool.Move
+ && Event.current.type == EventType.MouseDrag)
+ {
+ // User might be dragging our position handle
+ Target.UserIsDragging = true;
+ Vector3 delta = Target.transform.position - mPreviousPosition;
+ if (!delta.AlmostZero())
+ {
+ OnPositionDragged(delta);
+ mPreviousPosition = Target.transform.position;
+ }
+ }
+ else if (GUIUtility.hotControl == 0 && Target.UserIsDragging)
+ {
+ // We're not dragging anything now, but we were
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ Target.UserIsDragging = false;
+ }
+ }
+
+
+ void OnPositionDragged(Vector3 delta)
+ {
+ if (m_componentEditors != null)
+ {
+ foreach (UnityEditor.Editor e in m_componentEditors)
+ {
+ if (e != null)
+ {
+ MethodInfo mi = e.GetType().GetMethod("OnVcamPositionDragged"
+ , BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
+ if (mi != null && e.target != null)
+ {
+ mi.Invoke(e, new object[] { delta } );
+ }
+ }
+ }
+ }
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ DrawHeaderInInspector();
+ DrawPropertyInInspector(FindProperty(x => x.m_Priority));
+ DrawTargetsInInspector(FindProperty(x => x.m_Follow), FindProperty(x => x.m_LookAt));
+ DrawRemainingPropertiesInInspector();
+ DrawPipelineInInspector();
+ DrawExtensionsWidgetInInspector();
+ }
+
+ protected void DrawPipelineInInspector()
+ {
+ UpdateInstanceData();
+ foreach (CinemachineCore.Stage stage in Enum.GetValues(typeof(CinemachineCore.Stage)))
+ {
+ int index = (int)stage;
+
+ // Skip pipeline stages that have no implementations
+ if (sStageData[index].PopupOptions.Length <= 1)
+ continue;
+
+ const float indentOffset = 4;
+
+ GUIStyle stageBoxStyle = GUI.skin.box;
+ EditorGUILayout.BeginVertical(stageBoxStyle);
+ Rect rect = EditorGUILayout.GetControlRect(true);
+
+ // Don't use PrefixLabel() because it will link the enabled status of field and label
+ GUIContent label = new GUIContent(InspectorUtility.NicifyClassName(stage.ToString()));
+ if (m_stageError[index])
+ label.image = EditorGUIUtility.IconContent("console.warnicon.sml").image;
+ float labelWidth = EditorGUIUtility.labelWidth - (indentOffset + EditorGUI.indentLevel * 15);
+ Rect r = rect; r.width = labelWidth;
+ EditorGUI.LabelField(r, label);
+ r = rect; r.width -= labelWidth; r.x += labelWidth;
+ GUI.enabled = !StageIsLocked(stage);
+ int newSelection = EditorGUI.Popup(r, m_stageState[index], sStageData[index].PopupOptions);
+ GUI.enabled = true;
+
+ Type type = sStageData[index].types[newSelection];
+ if (newSelection != m_stageState[index])
+ {
+ SetPipelineStage(stage, type);
+ if (newSelection != 0)
+ sStageData[index].IsExpanded = true;
+ UpdateInstanceData(); // because we changed it
+ return;
+ }
+ if (type != null)
+ {
+ Rect stageRect = new Rect(
+ rect.x - indentOffset, rect.y, rect.width + indentOffset, rect.height);
+ sStageData[index].IsExpanded = EditorGUI.Foldout(
+ stageRect, sStageData[index].IsExpanded, GUIContent.none, true);
+ if (sStageData[index].IsExpanded)
+ {
+ // Make the editor for that stage
+ UnityEditor.Editor e = GetEditorForPipelineStage(stage);
+ if (e != null)
+ {
+ ++EditorGUI.indentLevel;
+ EditorGUILayout.Separator();
+ e.OnInspectorGUI();
+ EditorGUILayout.Separator();
+ --EditorGUI.indentLevel;
+ }
+ }
+ }
+ EditorGUILayout.EndVertical();
+ }
+ }
+
+ bool StageIsLocked(CinemachineCore.Stage stage)
+ {
+ CinemachineCore.Stage[] locked = Target.m_LockStageInInspector;
+ if (locked != null)
+ for (int i = 0; i < locked.Length; ++i)
+ if (locked[i] == stage)
+ return true;
+ return false;
+ }
+
+ UnityEditor.Editor GetEditorForPipelineStage(CinemachineCore.Stage stage)
+ {
+ if (m_componentEditors != null)
+ {
+ foreach (UnityEditor.Editor e in m_componentEditors)
+ {
+ if (e != null)
+ {
+ CinemachineComponentBase c = e.target as CinemachineComponentBase;
+ if (c != null && c.Stage == stage)
+ return e;
+ }
+ }
+ }
+ return null;
+ }
+
+ /// <summary>
+ /// Register with CinemachineVirtualCamera to create the pipeline in an undo-friendly manner
+ /// </summary>
+ [InitializeOnLoad]
+ class CreatePipelineWithUndo
+ {
+ static CreatePipelineWithUndo()
+ {
+ CinemachineVirtualCamera.CreatePipelineOverride =
+ (CinemachineVirtualCamera vcam, string name, CinemachineComponentBase[] copyFrom) =>
+ {
+ // Create a new pipeline
+ GameObject go = InspectorUtility.CreateGameObject(name);
+ Undo.RegisterCreatedObjectUndo(go, "created pipeline");
+ Undo.SetTransformParent(go.transform, vcam.transform, "parenting pipeline");
+ Undo.AddComponent<CinemachinePipeline>(go);
+
+ // If copying, transfer the components
+ if (copyFrom != null)
+ {
+ foreach (Component c in copyFrom)
+ {
+ Component copy = Undo.AddComponent(go, c.GetType());
+ Undo.RecordObject(copy, "copying pipeline");
+ ReflectionHelpers.CopyFields(c, copy);
+ }
+ }
+ return go.transform;
+ };
+ CinemachineVirtualCamera.DestroyPipelineOverride = (GameObject pipeline) =>
+ {
+ Undo.DestroyObjectImmediate(pipeline);
+ };
+ }
+ }
+
+ void SetPipelineStage(CinemachineCore.Stage stage, Type type)
+ {
+ Undo.SetCurrentGroupName("Cinemachine pipeline change");
+
+ // Get the existing components
+ Transform owner = Target.GetComponentOwner();
+
+ CinemachineComponentBase[] components = owner.GetComponents<CinemachineComponentBase>();
+ if (components == null)
+ components = new CinemachineComponentBase[0];
+
+ // Find an appropriate insertion point
+ int numComponents = components.Length;
+ int insertPoint = 0;
+ for (insertPoint = 0; insertPoint < numComponents; ++insertPoint)
+ if (components[insertPoint].Stage >= stage)
+ break;
+
+ // Remove the existing components at that stage
+ for (int i = numComponents - 1; i >= 0; --i)
+ {
+ if (components[i].Stage == stage)
+ {
+ Undo.DestroyObjectImmediate(components[i]);
+ components[i] = null;
+ --numComponents;
+ if (i < insertPoint)
+ --insertPoint;
+ }
+ }
+
+ // Add the new stage
+ if (type != null)
+ {
+ MonoBehaviour b = Undo.AddComponent(owner.gameObject, type) as MonoBehaviour;
+ while (numComponents-- > insertPoint)
+ UnityEditorInternal.ComponentUtility.MoveComponentDown(b);
+ }
+ }
+
+ // This code dynamically discovers eligible classes and builds the menu
+ // data for the various component pipeline stages.
+ static void UpdateStaticData()
+ {
+ if (sStageData != null)
+ return;
+ sStageData = new StageData[Enum.GetValues(typeof(CinemachineCore.Stage)).Length];
+
+ var stageTypes = new List<Type>[Enum.GetValues(typeof(CinemachineCore.Stage)).Length];
+ for (int i = 0; i < stageTypes.Length; ++i)
+ {
+ sStageData[i].Name = ((CinemachineCore.Stage)i).ToString();
+ stageTypes[i] = new List<Type>();
+ }
+
+ // Get all ICinemachineComponents
+ var allTypes
+ = ReflectionHelpers.GetTypesInAllDependentAssemblies(
+ (Type t) => typeof(CinemachineComponentBase).IsAssignableFrom(t) && !t.IsAbstract);
+
+ // Create a temp game object so we can instance behaviours
+ GameObject go = new GameObject("Cinemachine Temp Object");
+ go.hideFlags = HideFlags.DontSaveInBuild | HideFlags.DontSaveInEditor;
+ foreach (Type t in allTypes)
+ {
+ MonoBehaviour b = go.AddComponent(t) as MonoBehaviour;
+ CinemachineComponentBase c = b != null ? (CinemachineComponentBase)b : null;
+ if (c != null)
+ {
+ CinemachineCore.Stage stage = c.Stage;
+ stageTypes[(int)stage].Add(t);
+ }
+ }
+ GameObject.DestroyImmediate(go);
+
+ // Create the static lists
+ for (int i = 0; i < stageTypes.Length; ++i)
+ {
+ stageTypes[i].Insert(0, null); // first item is "none"
+ sStageData[i].types = stageTypes[i].ToArray();
+ GUIContent[] names = new GUIContent[sStageData[i].types.Length];
+ for (int n = 0; n < names.Length; ++n)
+ {
+ if (n == 0)
+ {
+ bool useSimple
+ = (i == (int)CinemachineCore.Stage.Aim)
+ || (i == (int)CinemachineCore.Stage.Body);
+ names[n] = new GUIContent((useSimple) ? "Do nothing" : "none");
+ }
+ else
+ names[n] = new GUIContent(InspectorUtility.NicifyClassName(sStageData[i].types[n].Name));
+ }
+ sStageData[i].PopupOptions = names;
+ }
+ }
+
+ void UpdateInstanceData()
+ {
+ // Invalidate the target's cache - this is to support Undo
+ Target.InvalidateComponentPipeline();
+ UpdateComponentEditors();
+ UpdateStageState(m_components);
+ }
+
+ // This code dynamically builds editors for the pipeline components.
+ // Expansion state is cached statically to preserve foldout state.
+ void UpdateComponentEditors()
+ {
+ CinemachineComponentBase[] components = Target.GetComponentPipeline();
+ int numComponents = components != null ? components.Length : 0;
+ if (m_components == null || m_components.Length != numComponents)
+ m_components = new CinemachineComponentBase[numComponents];
+ bool dirty = (numComponents == 0);
+ for (int i = 0; i < numComponents; ++i)
+ {
+ if (components[i] != m_components[i])
+ {
+ dirty = true;
+ m_components[i] = components[i];
+ }
+ }
+ if (dirty)
+ {
+ // Destroy the subeditors
+ if (m_componentEditors != null)
+ foreach (UnityEditor.Editor e in m_componentEditors)
+ if (e != null)
+ UnityEngine.Object.DestroyImmediate(e);
+
+ // Create new editors
+ m_componentEditors = new UnityEditor.Editor[numComponents];
+ for (int i = 0; i < numComponents; ++i)
+ {
+ MonoBehaviour b = components[i] as MonoBehaviour;
+ if (b != null)
+ CreateCachedEditor(b, null, ref m_componentEditors[i]);
+ }
+ }
+ }
+
+ void UpdateStageState(CinemachineComponentBase[] components)
+ {
+ m_stageState = new int[Enum.GetValues(typeof(CinemachineCore.Stage)).Length];
+ m_stageError = new bool[Enum.GetValues(typeof(CinemachineCore.Stage)).Length];
+ foreach (var c in components)
+ {
+ CinemachineCore.Stage stage = c.Stage;
+ int index = 0;
+ for (index = sStageData[(int)stage].types.Length - 1; index > 0; --index)
+ if (sStageData[(int)stage].types[index] == c.GetType())
+ break;
+ m_stageState[(int)stage] = index;
+ m_stageError[(int)stage] = !c.IsValid;
+ }
+ }
+
+ // Because the cinemachine components are attached to hidden objects, their
+ // gizmos don't get drawn by default. We have to do it explicitly.
+ [InitializeOnLoad]
+ static class CollectGizmoDrawers
+ {
+ static CollectGizmoDrawers()
+ {
+ m_GizmoDrawers = new Dictionary<Type, MethodInfo>();
+ string definedIn = typeof(CinemachineComponentBase).Assembly.GetName().Name;
+ Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
+ foreach (Assembly assembly in assemblies)
+ {
+ // Note that we have to call GetName().Name. Just GetName() will not work.
+ if ((!assembly.GlobalAssemblyCache)
+ && ((assembly.GetName().Name == definedIn)
+ || assembly.GetReferencedAssemblies().Any(a => a.Name == definedIn)))
+ {
+ try
+ {
+ foreach (var type in assembly.GetTypes())
+ {
+ try
+ {
+ bool added = false;
+ foreach (var method in type.GetMethods(
+ BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static))
+ {
+ if (added)
+ break;
+ if (!method.IsStatic)
+ continue;
+ var attributes = method.GetCustomAttributes(typeof(DrawGizmo), true) as DrawGizmo[];
+ foreach (var a in attributes)
+ {
+ if (typeof(CinemachineComponentBase).IsAssignableFrom(a.drawnType) && !a.drawnType.IsAbstract)
+ {
+ m_GizmoDrawers.Add(a.drawnType, method);
+ added = true;
+ break;
+ }
+ }
+ }
+ }
+ catch (System.Exception) {} // Just skip uncooperative types
+ }
+ }
+ catch (System.Exception) {} // Just skip uncooperative assemblies
+ }
+ }
+ }
+ public static Dictionary<Type, MethodInfo> m_GizmoDrawers;
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.InSelectionHierarchy, typeof(CinemachineVirtualCamera))]
+ internal static void DrawVirtualCameraGizmos(CinemachineVirtualCamera vcam, GizmoType selectionType)
+ {
+ var pipeline = vcam.GetComponentPipeline();
+ foreach (var c in pipeline)
+ {
+ MethodInfo method;
+ if (CollectGizmoDrawers.m_GizmoDrawers.TryGetValue(c.GetType(), out method))
+ {
+ if (method != null)
+ method.Invoke(null, new object[] { c, selectionType });
+ }
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: a63f9f2267c36684e855add13ad5499f
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 3ee56510c2623c54daa99a3748f6f438
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS || CINEMACHINE_PHYSICS_2D
+
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+using UnityEngine.Playables;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineTriggerAction))]
+ internal class CinemachineTriggerActionEditor : BaseEditor<CinemachineTriggerAction>
+ {
+ const int vSpace = 2;
+ CinemachineTriggerAction.ActionSettings def
+ = new CinemachineTriggerAction.ActionSettings(); // to access name strings
+
+ static bool mEnterExpanded;
+ static bool mExitExpanded;
+
+ SerializedProperty[] mRepeatProperties = new SerializedProperty[2];
+ GUIContent mRepeatLabel;
+ GUIContent[] mRepeatSubLabels = new GUIContent[2];
+
+ GUIStyle mFoldoutStyle;
+
+ private void OnEnable()
+ {
+ mRepeatProperties[0] = FindProperty(x => x.m_SkipFirst);
+ mRepeatProperties[1] = FindProperty(x => x.m_Repeating);
+ mRepeatLabel = new GUIContent(
+ mRepeatProperties[0].displayName, mRepeatProperties[0].tooltip);
+ mRepeatSubLabels[0] = GUIContent.none;
+ mRepeatSubLabels[1] = new GUIContent(
+ mRepeatProperties[1].displayName, mRepeatProperties[1].tooltip);
+ }
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_SkipFirst));
+ excluded.Add(FieldPath(x => x.m_Repeating));
+ excluded.Add(FieldPath(x => x.m_OnObjectEnter));
+ excluded.Add(FieldPath(x => x.m_OnObjectExit));
+ return excluded;
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ DrawRemainingPropertiesInInspector();
+ InspectorUtility.MultiPropertyOnLine(
+ EditorGUILayout.GetControlRect(), mRepeatLabel,
+ mRepeatProperties, mRepeatSubLabels);
+ EditorGUILayout.Space();
+ mEnterExpanded = DrawActionSettings(FindProperty(x => x.m_OnObjectEnter), mEnterExpanded);
+ mExitExpanded = DrawActionSettings(FindProperty(x => x.m_OnObjectExit), mExitExpanded);
+ }
+
+ bool DrawActionSettings(SerializedProperty property, bool expanded)
+ {
+ if (mFoldoutStyle == null)
+ mFoldoutStyle = new GUIStyle(EditorStyles.foldout) { fontStyle = FontStyle.Bold };
+
+ Rect r = EditorGUILayout.GetControlRect();
+ expanded = EditorGUI.Foldout(r, expanded, property.displayName, true, mFoldoutStyle);
+ if (expanded)
+ {
+ SerializedProperty actionProp = property.FindPropertyRelative(() => def.m_Action);
+ EditorGUILayout.PropertyField(actionProp);
+
+ SerializedProperty targetProp = property.FindPropertyRelative(() => def.m_Target);
+ bool isCustom = (actionProp.intValue == (int)CinemachineTriggerAction.ActionSettings.Mode.Custom);
+ if (!isCustom)
+ EditorGUILayout.PropertyField(targetProp);
+
+ bool isBoost = actionProp.intValue == (int)CinemachineTriggerAction.ActionSettings.Mode.PriorityBoost;
+ if (isBoost)
+ EditorGUILayout.PropertyField(property.FindPropertyRelative(() => def.m_BoostAmount));
+
+ bool isPlay = actionProp.intValue == (int)CinemachineTriggerAction.ActionSettings.Mode.Play;
+ if (isPlay)
+ {
+ SerializedProperty[] props = new SerializedProperty[2]
+ {
+ property.FindPropertyRelative(() => def.m_StartTime),
+ property.FindPropertyRelative(() => def.m_Mode)
+ };
+ GUIContent[] sublabels = new GUIContent[2]
+ {
+ GUIContent.none, new GUIContent("s", props[1].tooltip)
+ };
+ InspectorUtility.MultiPropertyOnLine(
+ EditorGUILayout.GetControlRect(), null, props, sublabels);
+ }
+
+ if (actionProp.intValue == (int)CinemachineTriggerAction.ActionSettings.Mode.Custom)
+ {
+ EditorGUILayout.HelpBox("Use the Event() list below to call custom methods", MessageType.Info);
+ }
+
+ if (isBoost)
+ {
+ if (GetTargetComponent<CinemachineVirtualCameraBase>(targetProp.objectReferenceValue) == null)
+ EditorGUILayout.HelpBox("Target must be a CinemachineVirtualCameraBase in order to boost priority", MessageType.Warning);
+ }
+
+ bool isEnableDisable = (actionProp.intValue == (int)CinemachineTriggerAction.ActionSettings.Mode.Enable
+ || actionProp.intValue == (int)CinemachineTriggerAction.ActionSettings.Mode.Disable);
+ if (isEnableDisable)
+ {
+ var value = targetProp.objectReferenceValue;
+ if (value != null && (value as Behaviour) == null)
+ EditorGUILayout.HelpBox("Target must be a Behaviour in order to Enable/Disable", MessageType.Warning);
+ }
+
+ bool isPlayStop = isPlay
+ || actionProp.intValue == (int)CinemachineTriggerAction.ActionSettings.Mode.Stop;
+ if (isPlayStop)
+ {
+ if (GetTargetComponent<Animator>(targetProp.objectReferenceValue) == null
+ && GetTargetComponent<PlayableDirector>(targetProp.objectReferenceValue) == null)
+ {
+ EditorGUILayout.HelpBox("Target must have a PlayableDirector or Animator in order to Play/Stop", MessageType.Warning);
+ }
+ }
+
+ if (!isCustom && targetProp.objectReferenceValue == null)
+ EditorGUILayout.HelpBox("No action will be taken because target is not valid", MessageType.Info);
+
+ EditorGUILayout.Space();
+ EditorGUILayout.LabelField("This event will be invoked. Add calls to custom methods here:");
+ EditorGUILayout.PropertyField(property.FindPropertyRelative(() => def.m_Event));
+ }
+ property.serializedObject.ApplyModifiedProperties();
+ return expanded;
+ }
+
+ T GetTargetComponent<T>(UnityEngine.Object obj) where T : Behaviour
+ {
+ UnityEngine.Object currentTarget = obj;
+ if (currentTarget != null)
+ {
+ GameObject targetGameObject = currentTarget as GameObject;
+ Behaviour targetBehaviour = currentTarget as Behaviour;
+ if (targetBehaviour != null)
+ targetGameObject = targetBehaviour.gameObject;
+ if (targetBehaviour is T)
+ return targetBehaviour as T;
+ if (targetGameObject != null)
+ return targetGameObject.GetComponent<T>();
+ }
+ return null;
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: c5d95ccadebafc84b8226853d987217d
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 351cec6faf82a1848a52b8fd995c6c25
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_EXPERIMENTAL_VCAM
+using UnityEngine;
+using UnityEditor;
+using Cinemachine.Editor;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ [CustomEditor(typeof(CinemachineNewFreeLook))]
+ sealed class CinemachineNewFreeLookEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineNewFreeLook>
+ {
+ GUIContent[] mRigNames = new GUIContent[]
+ { new GUIContent("Top Rig"), new GUIContent("Bottom Rig") };
+
+ GUIContent[] mOrbitNames = new GUIContent[]
+ { new GUIContent("Top Rig"), new GUIContent("Main Rig"), new GUIContent("Bottom Rig") };
+
+ GUIContent mAllLensLabel = new GUIContent(
+ "Customize", "Custom settings for this rig. If unchecked, main rig settins will be used");
+
+ VcamPipelineStageSubeditorSet mPipelineSet = new VcamPipelineStageSubeditorSet();
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.m_Rigs)); // can't use HideInInspector for this
+ excluded.Add(FieldPath(x => x.m_Orbits));
+ excluded.Add(FieldPath(x => x.m_SplineCurvature));
+ return excluded;
+ }
+
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ mPipelineSet.CreateSubeditors(this);
+ }
+
+ protected override void OnDisable()
+ {
+ mPipelineSet.Shutdown();
+ base.OnDisable();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ // Ordinary properties
+ BeginInspector();
+ DrawHeaderInInspector();
+ DrawPropertyInInspector(FindProperty(x => x.m_Priority));
+ DrawTargetsInInspector(FindProperty(x => x.m_Follow), FindProperty(x => x.m_LookAt));
+ DrawRemainingPropertiesInInspector();
+
+ // Orbits
+ EditorGUILayout.Space();
+ EditorGUILayout.LabelField("Orbits", EditorStyles.boldLabel);
+ SerializedProperty orbits = FindProperty(x => x.m_Orbits);
+ EditorGUI.BeginChangeCheck();
+ for (int i = 0; i < 3; ++i)
+ {
+ var o = orbits.GetArrayElementAtIndex(i);
+ Rect rect = EditorGUILayout.GetControlRect(true);
+ InspectorUtility.MultiPropertyOnLine(
+ rect, mOrbitNames[i],
+ new [] { o.FindPropertyRelative(() => Target.m_Orbits[i].m_Height),
+ o.FindPropertyRelative(() => Target.m_Orbits[i].m_Radius) },
+ null);
+ }
+ EditorGUILayout.PropertyField(FindProperty(x => x.m_SplineCurvature));
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+
+ // Pipeline Stages
+ EditorGUILayout.Space();
+ EditorGUILayout.LabelField("Main Rig", EditorStyles.boldLabel);
+ var components = Target.ComponentCache;
+ for (int i = 0; i < mPipelineSet.m_subeditors.Length; ++i)
+ {
+ var ed = mPipelineSet.m_subeditors[i];
+ if (ed == null)
+ continue;
+ if (!ed.HasImplementation)
+ continue;
+ if ((CinemachineCore.Stage)i == CinemachineCore.Stage.Body)
+ ed.TypeIsLocked = true;
+ ed.OnInspectorGUI(components[i]); // may destroy component
+ }
+
+ // Rigs
+ EditorGUILayout.Space();
+ SerializedProperty rigs = FindProperty(x => x.m_Rigs);
+ for (int i = 0; i < 2; ++i)
+ {
+ EditorGUILayout.Separator();
+ DrawRigEditor(i, rigs.GetArrayElementAtIndex(i));
+ }
+
+ // Extensions
+ DrawExtensionsWidgetInInspector();
+ }
+
+ Vector3 mPreviousPosition; // for position dragging
+ private void OnSceneGUI()
+ {
+ if (!Target.UserIsDragging)
+ mPreviousPosition = Target.transform.position;
+ if (Selection.Contains(Target.gameObject) && Tools.current == Tool.Move
+ && Event.current.type == EventType.MouseDrag)
+ {
+ // User might be dragging our position handle
+ Target.UserIsDragging = true;
+ Vector3 delta = Target.transform.position - mPreviousPosition;
+ if (!delta.AlmostZero())
+ {
+ mPipelineSet.OnPositionDragged(delta);
+ mPreviousPosition = Target.transform.position;
+
+ // Adjust the rigs height and scale
+ Transform follow = Target.Follow;
+ if (follow != null)
+ {
+ Undo.RegisterCompleteObjectUndo(Target, "Camera drag");
+ Vector3 up = Target.State.ReferenceUp;
+ float heightDelta = Vector3.Dot(up, delta);
+
+ Vector3 fwd = (Target.State.FinalPosition - follow.position).normalized;
+ float oldRadius = Target.GetLocalPositionForCameraFromInput(
+ Target.m_VerticalAxis.Value).magnitude;
+ float newRadius = Mathf.Max(0.01f, oldRadius + Vector3.Dot(fwd, delta));
+ for (int i = 0; i < 3; ++i)
+ {
+ Target.m_Orbits[i].m_Height += heightDelta;
+ if (oldRadius > 0.001f)
+ Target.m_Orbits[i].m_Radius *= newRadius / oldRadius;
+ }
+ }
+ }
+ }
+ else if (GUIUtility.hotControl == 0 && Target.UserIsDragging)
+ {
+ // We're not dragging anything now, but we were
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ Target.UserIsDragging = false;
+ }
+ }
+
+ void DrawRigEditor(int rigIndex, SerializedProperty rig)
+ {
+ const float kBoxMargin = 3;
+
+ CinemachineNewFreeLook.Rig def = new CinemachineNewFreeLook.Rig(); // for properties
+ EditorGUILayout.BeginVertical(GUI.skin.box);
+ EditorGUIUtility.labelWidth -= kBoxMargin;
+ EditorGUILayout.LabelField(new GUIContent(mRigNames[rigIndex]), EditorStyles.boldLabel);
+
+ ++EditorGUI.indentLevel;
+ var components = Target.ComponentCache;
+ if (DrawFoldoutPropertyWithEnabledCheckbox(
+ rig.FindPropertyRelative(() => def.m_CustomLens),
+ rig.FindPropertyRelative(() => def.m_Lens)))
+ {
+ Target.m_Rigs[rigIndex].m_Lens = Target.m_Lens;
+ }
+
+ int index = (int)CinemachineCore.Stage.Body;
+ if (components[index] is CinemachineTransposer)
+ {
+ if (DrawFoldoutPropertyWithEnabledCheckbox(
+ rig.FindPropertyRelative(() => def.m_CustomBody),
+ rig.FindPropertyRelative(() => def.m_Body)))
+ {
+ Target.m_Rigs[rigIndex].m_Body.PullFrom(
+ components[index] as CinemachineTransposer);
+ }
+ }
+
+ index = (int)CinemachineCore.Stage.Aim;
+ if (components[index] is CinemachineComposer)
+ {
+ if (DrawFoldoutPropertyWithEnabledCheckbox(
+ rig.FindPropertyRelative(() => def.m_CustomAim),
+ rig.FindPropertyRelative(() => def.m_Aim)))
+ {
+ Target.m_Rigs[rigIndex].m_Aim.PullFrom(
+ components[index] as CinemachineComposer);
+ }
+ }
+
+ index = (int)CinemachineCore.Stage.Noise;
+ if (components[index] is CinemachineBasicMultiChannelPerlin)
+ {
+ if (DrawFoldoutPropertyWithEnabledCheckbox(
+ rig.FindPropertyRelative(() => def.m_CustomNoise),
+ rig.FindPropertyRelative(() => def.m_Noise)))
+ {
+ Target.m_Rigs[rigIndex].m_Noise.PullFrom(
+ components[index] as CinemachineBasicMultiChannelPerlin);
+ }
+ }
+ --EditorGUI.indentLevel;
+ EditorGUILayout.EndVertical();
+ EditorGUIUtility.labelWidth += kBoxMargin;
+ }
+
+ // Returns true if default value should be applied
+ bool DrawFoldoutPropertyWithEnabledCheckbox(
+ SerializedProperty enabledProperty, SerializedProperty property)
+ {
+ GUIContent label = new GUIContent(property.displayName, property.tooltip);
+ Rect rect = EditorGUILayout.GetControlRect(true,
+ (enabledProperty.boolValue && property.isExpanded)
+ ? EditorGUI.GetPropertyHeight(property)
+ : EditorGUIUtility.singleLineHeight);
+ Rect r = rect; r.height = EditorGUIUtility.singleLineHeight;
+ if (!enabledProperty.boolValue)
+ EditorGUI.LabelField(r, label);
+
+ float labelWidth = EditorGUIUtility.labelWidth;
+ bool newValue = EditorGUI.ToggleLeft(
+ new Rect(labelWidth, r.y, r.width - labelWidth, r.height),
+ mAllLensLabel, enabledProperty.boolValue);
+ if (newValue != enabledProperty.boolValue)
+ {
+ enabledProperty.boolValue = newValue;
+ enabledProperty.serializedObject.ApplyModifiedProperties();
+ property.isExpanded = newValue;
+ return true;
+ }
+ if (newValue == true)
+ {
+ EditorGUI.BeginChangeCheck();
+ EditorGUI.PropertyField(rect, property, property.isExpanded);
+ if (EditorGUI.EndChangeCheck())
+ enabledProperty.serializedObject.ApplyModifiedProperties();
+ }
+ return false;
+ }
+
+ [DrawGizmo(GizmoType.Active | GizmoType.Selected, typeof(CinemachineNewFreeLook))]
+ private static void DrawFreeLookGizmos(CinemachineNewFreeLook vcam, GizmoType selectionType)
+ {
+ // Standard frustum and logo
+ CinemachineBrainEditor.DrawVirtualCameraBaseGizmos(vcam, selectionType);
+
+ Color originalGizmoColour = Gizmos.color;
+ bool isActiveVirtualCam = CinemachineCore.Instance.IsLive(vcam);
+ Gizmos.color = isActiveVirtualCam
+ ? CinemachineSettings.CinemachineCoreSettings.ActiveGizmoColour
+ : CinemachineSettings.CinemachineCoreSettings.InactiveGizmoColour;
+
+ if (vcam.Follow != null)
+ {
+ Vector3 pos = vcam.Follow.position;
+ Vector3 up = Vector3.up;
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(vcam);
+ if (brain != null)
+ up = brain.DefaultWorldUp;
+
+ var middleRig = vcam.GetComponent<CinemachineTransposer>();
+ if (middleRig != null)
+ {
+ float scale = vcam.m_RadialAxis.Value;
+ Quaternion orient = middleRig.GetReferenceOrientation(up);
+ up = orient * Vector3.up;
+ var orbital = middleRig as CinemachineOrbitalTransposer;
+ if (orbital != null)
+ {
+ float rotation = orbital.m_XAxis.Value + orbital.m_Heading.m_Bias;
+ orient = Quaternion.AngleAxis(rotation, up) * orient;
+ }
+ CinemachineOrbitalTransposerEditor.DrawCircleAtPointWithRadius(
+ pos + up * vcam.m_Orbits[0].m_Height * scale,
+ orient, vcam.m_Orbits[0].m_Radius * scale);
+ CinemachineOrbitalTransposerEditor.DrawCircleAtPointWithRadius(
+ pos + up * vcam.m_Orbits[1].m_Height * scale,
+ orient, vcam.m_Orbits[1].m_Radius * scale);
+ CinemachineOrbitalTransposerEditor.DrawCircleAtPointWithRadius(
+ pos + up * vcam.m_Orbits[2].m_Height * scale,
+ orient, vcam.m_Orbits[2].m_Radius * scale);
+
+ DrawCameraPath(pos, orient, vcam);
+ }
+ }
+ Gizmos.color = originalGizmoColour;
+ }
+
+ private static void DrawCameraPath(
+ Vector3 atPos, Quaternion orient, CinemachineNewFreeLook vcam)
+ {
+ Matrix4x4 prevMatrix = Gizmos.matrix;
+ Gizmos.matrix = Matrix4x4.TRS(atPos, orient, Vector3.one);
+
+ const int kNumSteps = 20;
+ Vector3 currPos = vcam.GetLocalPositionForCameraFromInput(0f);
+ for (int i = 1; i < kNumSteps + 1; ++i)
+ {
+ float t = (float)i / (float)kNumSteps;
+ Vector3 nextPos = vcam.GetLocalPositionForCameraFromInput(t);
+ Gizmos.DrawLine(currPos, nextPos);
+ currPos = nextPos;
+ }
+ Gizmos.matrix = prevMatrix;
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 933e2b6843fbbbc4c8cabeead6fc1fae
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_EXPERIMENTAL_VCAM
+using UnityEngine;
+using UnityEditor;
+using Cinemachine.Editor;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ [CustomEditor(typeof(CinemachineNewVirtualCamera))]
+ sealed class CinemachineNewVirtualCameraEditor
+ : CinemachineVirtualCameraBaseEditor<CinemachineNewVirtualCamera>
+ {
+ VcamPipelineStageSubeditorSet mPipelineSet = new VcamPipelineStageSubeditorSet();
+
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ mPipelineSet.CreateSubeditors(this);
+ }
+
+ protected override void OnDisable()
+ {
+ mPipelineSet.Shutdown();
+ base.OnDisable();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ // Ordinary properties
+ BeginInspector();
+ DrawHeaderInInspector();
+ DrawPropertyInInspector(FindProperty(x => x.m_Priority));
+ DrawTargetsInInspector(FindProperty(x => x.m_Follow), FindProperty(x => x.m_LookAt));
+ DrawRemainingPropertiesInInspector();
+
+ // Pipeline Stages
+ var components = Target.ComponentCache;
+ for (int i = 0; i < mPipelineSet.m_subeditors.Length; ++i)
+ {
+ var ed = mPipelineSet.m_subeditors[i];
+ if (ed == null)
+ continue;
+ if (!ed.HasImplementation)
+ continue;
+ ed.OnInspectorGUI(components[i]); // may destroy component
+ }
+
+ // Extensions
+ DrawExtensionsWidgetInInspector();
+ }
+
+ Vector3 mPreviousPosition; // for position dragging
+ private void OnSceneGUI()
+ {
+ if (!Target.UserIsDragging)
+ mPreviousPosition = Target.transform.position;
+ if (Selection.Contains(Target.gameObject) && Tools.current == Tool.Move
+ && Event.current.type == EventType.MouseDrag)
+ {
+ // User might be dragging our position handle
+ Target.UserIsDragging = true;
+ Vector3 delta = Target.transform.position - mPreviousPosition;
+ if (!delta.AlmostZero())
+ {
+ mPipelineSet.OnPositionDragged(delta);
+ mPreviousPosition = Target.transform.position;
+ }
+ }
+ else if (GUIUtility.hotControl == 0 && Target.UserIsDragging)
+ {
+ // We're not dragging anything now, but we were
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ Target.UserIsDragging = false;
+ }
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 4692eb7a7fa5c53458eb32a04df6c6a0
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_EXPERIMENTAL_VCAM
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+using System.Reflection;
+
+namespace Cinemachine.Editor
+{
+ internal class VcamStageEditor
+ {
+ // Static state and caches - Call UpdateStaticData() to refresh this
+ struct StageData
+ {
+ string ExpandedKey { get { return "Cinemachine_Vcam_Stage_Expanded_" + Name; } }
+ public bool IsExpanded
+ {
+ get { return EditorPrefs.GetBool(ExpandedKey, false); }
+ set { EditorPrefs.SetBool(ExpandedKey, value); }
+ }
+ public string Name;
+ public Type[] types; // first entry is null
+ public GUIContent[] PopupOptions;
+ }
+ static StageData[] sStageData = null;
+
+ [InitializeOnLoad]
+ class EditorInitialize
+ {
+ // This code dynamically discovers eligible classes and builds the menu
+ // data for the various component pipeline stages.
+ static EditorInitialize()
+ {
+ sStageData = new StageData[Enum.GetValues(typeof(CinemachineCore.Stage)).Length];
+
+ var stageTypes = new List<Type>[Enum.GetValues(typeof(CinemachineCore.Stage)).Length];
+ for (int i = 0; i < stageTypes.Length; ++i)
+ {
+ sStageData[i].Name = ((CinemachineCore.Stage)i).ToString();
+ stageTypes[i] = new List<Type>();
+ }
+
+ // Get all ICinemachineComponents
+ var allTypes
+ = ReflectionHelpers.GetTypesInAllDependentAssemblies(
+ (Type t) => typeof(CinemachineComponentBase).IsAssignableFrom(t) && !t.IsAbstract);
+
+ // GML todo: use class attribute instead
+ // Create a temp game object so we can instance behaviours
+ GameObject go = new GameObject("Cinemachine Temp Object");
+ go.hideFlags = HideFlags.DontSaveInBuild | HideFlags.DontSaveInEditor;
+ foreach (Type t in allTypes)
+ {
+ MonoBehaviour b = go.AddComponent(t) as MonoBehaviour;
+ CinemachineComponentBase c = b != null ? (CinemachineComponentBase)b : null;
+ if (c != null)
+ {
+ CinemachineCore.Stage stage = c.Stage;
+ stageTypes[(int)stage].Add(t);
+ }
+ }
+ GameObject.DestroyImmediate(go);
+
+ // Create the static lists
+ for (int i = 0; i < stageTypes.Length; ++i)
+ {
+ stageTypes[i].Insert(0, null); // first item is "none"
+ sStageData[i].types = stageTypes[i].ToArray();
+ GUIContent[] names = new GUIContent[sStageData[i].types.Length];
+ for (int n = 0; n < names.Length; ++n)
+ {
+ if (n == 0)
+ {
+ bool useSimple
+ = (i == (int)CinemachineCore.Stage.Aim)
+ || (i == (int)CinemachineCore.Stage.Body);
+ names[n] = new GUIContent((useSimple) ? "Do nothing" : "none");
+ }
+ else
+ names[n] = new GUIContent(InspectorUtility.NicifyClassName(sStageData[i].types[n].Name));
+ }
+ sStageData[i].PopupOptions = names;
+ }
+ }
+ }
+
+ int mStageSelection = 0;
+ bool mStageError = false;
+ CinemachineCore.Stage mStage;
+ CinemachineComponentBase mComponent;
+ UnityEditor.Editor mComponentEditor;
+
+ // Target game object
+ public GameObject Target { get; private set; }
+
+ // Call this from OnEnable()
+ public VcamStageEditor(CinemachineCore.Stage stage, GameObject target)
+ {
+ mStage = stage;
+ Target = target;
+ }
+
+ ~VcamStageEditor()
+ {
+ Shutdown();
+ }
+
+ // Call this from OnDisable()
+ public void Shutdown()
+ {
+ if (mComponentEditor != null)
+ UnityEngine.Object.DestroyImmediate(mComponentEditor);
+ mComponentEditor = null;
+ Target = null;
+ mComponent = null;
+ }
+
+ // The current editor for the component (may be null)
+ public UnityEditor.Editor ComponentEditor { get { return mComponentEditor; } }
+
+ // Returns true if there are more than zero options for this pipeline stage
+ public bool HasImplementation { get { return sStageData[(int)mStage].PopupOptions.Length > 1; } }
+
+ // Can the component type be changed by the user?
+ public bool TypeIsLocked { get; set; }
+
+ // Call this from Editor's OnInspectorGUI - returns new component if user changes type
+ public void OnInspectorGUI(CinemachineComponentBase component)
+ {
+ if (component != mComponent)
+ {
+ if (mComponentEditor != null)
+ {
+ mComponentEditor.ResetTarget();
+ UnityEngine.Object.DestroyImmediate(mComponentEditor);
+ }
+ mComponentEditor = null;
+ mComponent = component;
+ }
+ if (mComponent != null && mComponentEditor == null)
+ UnityEditor.Editor.CreateCachedEditor(mComponent, null, ref mComponentEditor);
+ mStageSelection = GetPopupIndexForComponent(mComponent);
+ mStageError = mComponent == null ? false : !mComponent.IsValid;
+ DrawComponentInspector();
+ }
+
+ private int GetPopupIndexForComponent(CinemachineComponentBase c)
+ {
+ if (c != null)
+ {
+ var types = sStageData[(int)mStage].types;
+ for (int i = types.Length-1; i > 0; --i)
+ if (c.GetType() == types[i])
+ return i;
+ }
+ return 0; // none
+ }
+
+ private void DrawComponentInspector()
+ {
+ const float kBoxMargin = 4; // GML wtf get rid of this
+ const float indentSize = 15; // GML wtf get rid of this
+
+ int index = (int)mStage;
+
+ EditorGUILayout.BeginVertical(GUI.skin.box);
+ EditorGUIUtility.labelWidth -= kBoxMargin;
+
+ Rect rect = EditorGUILayout.GetControlRect(true);
+
+ // Don't use PrefixLabel() because it will link the enabled status of field and label
+ GUIContent label = new GUIContent(InspectorUtility.NicifyClassName(mStage.ToString()));
+ if (mStageError)
+ label.image = EditorGUIUtility.IconContent("console.warnicon.sml").image;
+ float labelWidth = EditorGUIUtility.labelWidth - EditorGUI.indentLevel * indentSize;
+ Rect r = rect; r.width = labelWidth; r.x -= kBoxMargin;
+ EditorGUI.LabelField(r, label);
+
+ r = rect; r.width -= labelWidth; r.x += labelWidth;
+ bool wasEnabled = GUI.enabled;
+ if (TypeIsLocked)
+ GUI.enabled = false;
+ int newSelection = EditorGUI.Popup(r, mStageSelection, sStageData[index].PopupOptions);
+ GUI.enabled = wasEnabled;
+
+ Type type = sStageData[index].types[newSelection];
+ if (newSelection != mStageSelection)
+ {
+ if (mComponent != null)
+ {
+ if (DestroyComponent != null)
+ DestroyComponent(mComponent);
+ }
+ if (newSelection != 0)
+ {
+ sStageData[index].IsExpanded = true;
+ if (SetComponent != null)
+ SetComponent(type);
+ }
+ mComponent = null;
+ GUIUtility.ExitGUI();
+ return; // let the component editor be recreated
+ }
+
+ // Draw the embedded editor
+ if (type != null)
+ {
+ r = new Rect(rect.x - kBoxMargin, rect.y, labelWidth, rect.height);
+ sStageData[index].IsExpanded = EditorGUI.Foldout(
+ r, sStageData[index].IsExpanded, GUIContent.none, true);
+ if (sStageData[index].IsExpanded)
+ {
+ // Make the editor for that stage
+ if (mComponentEditor != null)
+ {
+ ++EditorGUI.indentLevel;
+ EditorGUILayout.Separator();
+ mComponentEditor.OnInspectorGUI();
+ EditorGUILayout.Separator();
+ --EditorGUI.indentLevel;
+ }
+ }
+ }
+ EditorGUILayout.EndVertical();
+ EditorGUIUtility.labelWidth += kBoxMargin;
+ }
+
+ public void OnPositionDragged(Vector3 delta)
+ {
+ if (mComponentEditor != null)
+ {
+ MethodInfo mi = mComponentEditor.GetType().GetMethod("OnVcamPositionDragged"
+ , BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
+ if (mi != null && mComponentEditor.target != null)
+ {
+ mi.Invoke(mComponentEditor, new object[] { delta } );
+ }
+ }
+ }
+
+ public delegate void DestroyComponentDelegate(CinemachineComponentBase component);
+ public DestroyComponentDelegate DestroyComponent;
+
+ public delegate void SetComponentDelegate(Type type);
+ public SetComponentDelegate SetComponent;
+ }
+
+ internal class VcamPipelineStageSubeditorSet
+ {
+ public VcamStageEditor[] m_subeditors;
+
+ UnityEditor.Editor mParentEditor;
+
+ public void CreateSubeditors(UnityEditor.Editor parentEditor)
+ {
+ mParentEditor = parentEditor;
+ m_subeditors = new VcamStageEditor[(int)CinemachineCore.Stage.Finalize];
+ CinemachineNewVirtualCamera owner = mParentEditor == null
+ ? null : mParentEditor.target as CinemachineNewVirtualCamera;
+ if (owner == null)
+ return;
+ for (CinemachineCore.Stage stage = CinemachineCore.Stage.Body;
+ stage < CinemachineCore.Stage.Finalize; ++stage)
+ {
+ var ed = new VcamStageEditor(stage, owner.gameObject);
+ m_subeditors[(int)stage] = ed;
+ ed.SetComponent = (type)
+ => {
+ var vcam = mParentEditor.target as CinemachineNewVirtualCamera;
+ if (vcam != null)
+ {
+ var c = Undo.AddComponent(vcam.gameObject, type);
+ c.hideFlags |= HideFlags.HideInInspector;
+ vcam.InvalidateComponentCache();
+ }
+ };
+ ed.DestroyComponent = (component)
+ => {
+ var vcam = mParentEditor.target as CinemachineNewVirtualCamera;
+ if (vcam != null)
+ {
+ Undo.DestroyObjectImmediate(component);
+ vcam.InvalidateComponentCache();
+ }
+ };
+ }
+ }
+
+ public void Shutdown()
+ {
+ if (m_subeditors != null)
+ {
+ for (int i = 0; i < m_subeditors.Length; ++i)
+ {
+ if (m_subeditors[i] != null)
+ m_subeditors[i].Shutdown();
+ m_subeditors[i] = null;
+ }
+ m_subeditors = null;
+ }
+ mParentEditor = null;
+ }
+
+ // Pass the dragged event down to the CM component editors
+ public void OnPositionDragged(Vector3 delta)
+ {
+ foreach (var e in m_subeditors)
+ if (e != null)
+ e.OnPositionDragged(delta);
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 68194b7bb9ff1c6489c9c3c87c68c2a4
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: ac4cc060534a50747a448a00776ed888
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS || CINEMACHINE_PHYSICS_2D
+
+using UnityEditor;
+using UnityEngine;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineCollisionImpulseSource))]
+ internal sealed class CinemachineCollisionImpulseSourceEditor
+ : BaseEditor<CinemachineCollisionImpulseSource>
+ {
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+
+ EditorGUILayout.Separator();
+ var collider = Target.GetComponent<Collider>();
+ var collider2D = Target.GetComponent<Collider2D>();
+ if ((collider == null || !collider.enabled) && (collider2D == null || !collider2D.enabled))
+ EditorGUILayout.HelpBox(
+ "An active Collider or Collider2D component is required in order to detect collisions and generate Impulse events",
+ MessageType.Warning);
+
+ DrawRemainingPropertiesInInspector();
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 9cd1a769fbb1d1c47b4c22a04a64fa5f
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(CinemachineImpulseChannelPropertyAttribute))]
+ internal sealed class CinemachineImpulseChannelPropertyDrawer : PropertyDrawer
+ {
+ const float hSpace = 2;
+ GUIContent mAddLabel = new GUIContent("Edit...", "Add, remove, or rename channels");
+ string[] mLayerList = null;
+
+ void UpdateLayerList()
+ {
+ CinemachineImpulseChannels settings = CinemachineImpulseChannels.InstanceIfExists;
+ int numLayers = 0;
+ if (settings != null && settings.ImpulseChannels != null)
+ numLayers = settings.ImpulseChannels.Length;
+ numLayers = Mathf.Clamp(numLayers, 1, 31);
+ if (mLayerList == null || mLayerList.Length != numLayers)
+ mLayerList = new string[numLayers];
+ for (int i = 0; i < numLayers; ++i)
+ {
+ mLayerList[i] = string.Format(
+ "{0}: {1}", i,
+ (settings == null || settings.ImpulseChannels.Length <= i)
+ ? "default" : settings.ImpulseChannels[i]);
+ }
+ }
+
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ UpdateLayerList();
+ float addWidth = GUI.skin.button.CalcSize(mAddLabel).x;
+ rect.width -= addWidth + hSpace;
+ int value = EditorGUI.MaskField(rect, label, property.intValue, mLayerList);
+ if (value != property.intValue)
+ {
+ property.intValue = value;
+ property.serializedObject.ApplyModifiedProperties();
+ }
+
+ rect.x += rect.width + hSpace; rect.width = addWidth; rect.height -= 1;
+ if (GUI.Button(rect, mAddLabel))
+ if (CinemachineImpulseChannels.Instance != null)
+ Selection.activeObject = CinemachineImpulseChannels.Instance;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 0803634542916d8498caef53ed5604db
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ /// <summary>
+ /// This class contains setting for the Impulse system. Specifically, it holds
+ /// the Impulse Channel definitions. These work like Unity Layers, you can
+ /// define and name them, and create masks to filter only the layers you want.
+ /// </summary>
+ [Serializable]
+ public class CinemachineImpulseChannels : ScriptableObject
+ {
+ static CinemachineImpulseChannels sInstance = null;
+ private static bool alreadySearched = false;
+
+ /// <summary>Get the singleton instance of this object, or null if it doesn't exist</summary>
+ public static CinemachineImpulseChannels InstanceIfExists
+ {
+ get
+ {
+ if (!alreadySearched)
+ {
+ alreadySearched = true;
+ var guids = AssetDatabase.FindAssets("t:CinemachineImpulseChannels");
+ for (int i = 0; i < guids.Length && sInstance == null; ++i)
+ sInstance = AssetDatabase.LoadAssetAtPath<CinemachineImpulseChannels>(
+ AssetDatabase.GUIDToAssetPath(guids[i]));
+ }
+ if (sInstance != null)
+ sInstance.EnsureDefaultLayer();
+ return sInstance;
+ }
+ }
+
+ /// <summary>Get the singleton instance of this object. Creates asset if nonexistant</summary>
+ public static CinemachineImpulseChannels Instance
+ {
+ get
+ {
+ if (InstanceIfExists == null)
+ {
+ string newAssetPath = EditorUtility.SaveFilePanelInProject(
+ "Create Impulse Channel Definition asset", "CinemachineImpulseChannels", "asset",
+ "This editor-only file will contain the Impulse channels for this project");
+ if (!string.IsNullOrEmpty(newAssetPath))
+ {
+ sInstance = CreateInstance<CinemachineImpulseChannels>();
+ AssetDatabase.CreateAsset(sInstance, newAssetPath);
+ AssetDatabase.SaveAssets();
+ AssetDatabase.Refresh();
+ }
+ }
+ sInstance.EnsureDefaultLayer();
+ return sInstance;
+ }
+ }
+
+ // Make sure it has at least one layer in it
+ void EnsureDefaultLayer()
+ {
+ if (ImpulseChannels == null || ImpulseChannels.Length == 0)
+ ImpulseChannels = new string[] { "default" };
+ }
+
+ public string[] ImpulseChannels;
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: a1728508674789b4e8539a2ad08ebc3f
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(CinemachineImpulseDefinitionPropertyAttribute))]
+ internal sealed class CinemachineImpulseDefinitionPropertyDrawer : PropertyDrawer
+ {
+ const int vSpace = 2;
+
+ float HeaderHeight { get { return EditorGUIUtility.singleLineHeight * 1.5f; } }
+ float DrawHeader(Rect rect, string text)
+ {
+ float delta = HeaderHeight - EditorGUIUtility.singleLineHeight;
+ rect.y += delta; rect.height -= delta;
+ EditorGUI.LabelField(rect, new GUIContent(text), EditorStyles.boldLabel);
+ return HeaderHeight;
+ }
+
+ string HeaderText(SerializedProperty property)
+ {
+ var attrs = property.serializedObject.targetObject.GetType()
+ .GetCustomAttributes(typeof(HeaderAttribute), false);
+ if (attrs != null && attrs.Length > 0)
+ return ((HeaderAttribute)attrs[0]).header;
+ return null;
+ }
+
+ List<string> mHideProperties = new List<string>();
+
+ public override float GetPropertyHeight(SerializedProperty prop, GUIContent label)
+ {
+ CinemachineImpulseDefinition myClass = null; // to access name strings
+ SignalSourceAsset asset = null;
+ float height = 0;
+ mHideProperties.Clear();
+ string prefix = prop.name;
+ prop.NextVisible(true); // Skip outer foldout
+ do
+ {
+ if (!prop.propertyPath.StartsWith(prefix))
+ break;
+ string header = HeaderText(prop);
+ if (header != null)
+ height += HeaderHeight + vSpace;
+
+ // Do we hide this property?
+ bool hide = false;
+ if (prop.name == SerializedPropertyHelper.PropertyName(() => myClass.m_RawSignal))
+ asset = prop.objectReferenceValue as SignalSourceAsset;
+ if (prop.name == SerializedPropertyHelper.PropertyName(() => myClass.m_RepeatMode))
+ hide = asset == null || asset.SignalDuration <= 0;
+ else if (prop.name == SerializedPropertyHelper.PropertyName(() => myClass.m_Randomize))
+ hide = asset == null || asset.SignalDuration > 0;
+
+ if (hide)
+ mHideProperties.Add(prop.name);
+ else
+ height += EditorGUI.GetPropertyHeight(prop, false) + vSpace;
+ } while (prop.NextVisible(prop.isExpanded));
+ return height;
+ }
+
+ public override void OnGUI(Rect rect, SerializedProperty prop, GUIContent label)
+ {
+ string prefix = prop.name;
+ prop.NextVisible(true); // Skip outer foldout
+ do
+ {
+ if (!prop.propertyPath.StartsWith(prefix))
+ break;
+ string header = HeaderText(prop);
+ if (header != null)
+ {
+ rect.height = HeaderHeight;
+ DrawHeader(rect, header);
+ rect.y += HeaderHeight + vSpace;
+ }
+ if (mHideProperties.Contains(prop.name))
+ continue;
+ rect.height = EditorGUI.GetPropertyHeight(prop, false);
+ EditorGUI.PropertyField(rect, prop);
+ rect.y += rect.height + vSpace;
+ } while (prop.NextVisible(prop.isExpanded));
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: b1a97a2b5515f5d49977e7e8add5b7a9
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(CinemachineImpulseEnvelopePropertyAttribute))]
+ internal sealed class CinemachineImpulseEnvelopePropertyDrawer : PropertyDrawer
+ {
+ const int vSpace = 2;
+ static bool mExpanded = true;
+
+ CinemachineImpulseManager.EnvelopeDefinition myClass
+ = new CinemachineImpulseManager.EnvelopeDefinition(); // to access name strings
+
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ float height = EditorGUIUtility.singleLineHeight;
+ rect.height = height;
+ mExpanded = EditorGUI.Foldout(rect, mExpanded, label, true);
+ if (mExpanded)
+ {
+ const float indentAmount = 15;
+ rect.width -= indentAmount; rect.x += indentAmount;
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth -= indentAmount;
+
+ rect.y += EditorGUIUtility.singleLineHeight + vSpace;
+ DrawCurveTimeProperty(
+ rect, new GUIContent("Attack", "The custom shape of the attack curve. Leave it blank for a default shape"),
+ property.FindPropertyRelative(() => myClass.m_AttackShape),
+ property.FindPropertyRelative(() => myClass.m_AttackTime));
+
+ rect.y += EditorGUIUtility.singleLineHeight + vSpace;
+#if false // with "forever" button... dangerous because signal never goes away!
+ var holdProp = property.FindPropertyRelative(() => myClass.m_SustainTime);
+ InspectorUtility.MultiPropertyOnLine(
+ rect, new GUIContent(holdProp.displayName, holdProp.tooltip),
+ new SerializedProperty[] { holdProp, property.FindPropertyRelative(() => myClass.m_HoldForever) },
+ new GUIContent[] { GUIContent.none, new GUIContent("forever") });
+#else
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => myClass.m_SustainTime));
+#endif
+ rect.y += EditorGUIUtility.singleLineHeight + vSpace;
+ DrawCurveTimeProperty(
+ rect, new GUIContent("Decay", "The custom shape of the decay curve. Leave it blank for a default shape"),
+ property.FindPropertyRelative(() => myClass.m_DecayShape),
+ property.FindPropertyRelative(() => myClass.m_DecayTime));
+
+ rect.y += EditorGUIUtility.singleLineHeight + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => myClass.m_ScaleWithImpact));
+
+ EditorGUIUtility.labelWidth = oldWidth;
+ }
+ }
+
+ void DrawCurveTimeProperty(
+ Rect rect, GUIContent label,
+ SerializedProperty curveProp, SerializedProperty timeProp)
+ {
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 2.5f;
+
+ GUIContent timeText = new GUIContent(" s", timeProp.tooltip);
+ var textDimensions = GUI.skin.label.CalcSize(timeText);
+
+ rect = EditorGUI.PrefixLabel(rect, label);
+
+ rect.height = EditorGUIUtility.singleLineHeight;
+ rect.width -= floatFieldWidth + textDimensions.x;
+
+ Rect r = rect; r.height += 1; r.y -= 1;
+ EditorGUI.BeginChangeCheck();
+ EditorGUI.PropertyField(r, curveProp, GUIContent.none);
+ if (EditorGUI.EndChangeCheck())
+ {
+ curveProp.animationCurveValue = InspectorUtility.NormalizeCurve(curveProp.animationCurveValue);
+ if (curveProp.animationCurveValue.length < 1)
+ curveProp.animationCurveValue = new AnimationCurve();
+ curveProp.serializedObject.ApplyModifiedProperties();
+ }
+
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = textDimensions.x;
+ rect.x += rect.width; rect.width = floatFieldWidth + EditorGUIUtility.labelWidth;
+ EditorGUI.BeginChangeCheck();
+ EditorGUI.PropertyField(rect, timeProp, timeText);
+ if (EditorGUI.EndChangeCheck())
+ timeProp.floatValue = Mathf.Max(timeProp.floatValue, 0);
+ EditorGUIUtility.labelWidth = oldWidth;
+ }
+
+ public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+ {
+ float height = EditorGUIUtility.singleLineHeight + vSpace;
+ if (mExpanded)
+ height *= 5;
+ return height;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: fdb859783dabdca44be0ea05d1203b30
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineImpulseListener))]
+ internal sealed class CinemachineImpulseListenerEditor
+ : BaseEditor<CinemachineImpulseListener>
+ {
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ EditorGUILayout.HelpBox(
+ "The Impulse Listener will respond to signals broadcast by any CinemachineImpulseSource.",
+ MessageType.Info);
+ DrawRemainingPropertiesInInspector();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: c63cb4cb8e3e82c4f8bfa7516da4f2b5
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomEditor(typeof(CinemachineImpulseSource))]
+ internal sealed class CinemachineImpulseSourceEditor
+ : BaseEditor<CinemachineImpulseSource>
+ {
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ EditorGUILayout.Separator();
+ EditorGUILayout.HelpBox(
+ "First set up the Signal and Range, then connect your impulse-generating event to one of the GenerateImpulse API methods defined in this script.",
+ MessageType.Info);
+ DrawRemainingPropertiesInInspector();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: b56f2475416eeea4c916add2d7268ad1
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: d093acf2bada69e4bbbcf0a8b4534919
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.IO;
+
+namespace Cinemachine.Editor
+{
+ internal static class CinemachineMenu
+ {
+ public const string kCinemachineRootMenu = "Assets/Create/Cinemachine/";
+
+ [MenuItem(kCinemachineRootMenu + "BlenderSettings")]
+ private static void CreateBlenderSettingAsset()
+ {
+ ScriptableObjectUtility.Create<CinemachineBlenderSettings>();
+ }
+
+ [MenuItem(kCinemachineRootMenu + "NoiseSettings")]
+ private static void CreateNoiseSettingAsset()
+ {
+ ScriptableObjectUtility.Create<NoiseSettings>();
+ }
+
+ [MenuItem(kCinemachineRootMenu + "Fixed Signal Definition")]
+ private static void CreateFixedSignalDefinition()
+ {
+ ScriptableObjectUtility.Create<CinemachineFixedSignal>();
+ }
+
+ [MenuItem("Cinemachine/Create Virtual Camera", false, 1)]
+ public static CinemachineVirtualCamera CreateVirtualCamera()
+ {
+ return InternalCreateVirtualCamera(
+ "CM vcam", true, typeof(CinemachineComposer), typeof(CinemachineTransposer));
+ }
+
+ [MenuItem("Cinemachine/Create FreeLook Camera", false, 1)]
+ private static void CreateFreeLookCamera()
+ {
+ CreateCameraBrainIfAbsent();
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineFreeLook), "CM FreeLook"),
+ typeof(CinemachineFreeLook));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Selection.activeGameObject = go;
+ }
+
+ [MenuItem("Cinemachine/Create Blend List Camera", false, 1)]
+ private static void CreateBlendListCamera()
+ {
+ CreateCameraBrainIfAbsent();
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineBlendListCamera), "CM BlendListCamera"),
+ typeof(CinemachineBlendListCamera));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create Blend List camera");
+ var vcam = go.GetComponent<CinemachineBlendListCamera>();
+ Selection.activeGameObject = go;
+
+ // Give it a couple of children
+ var child1 = CreateDefaultVirtualCamera();
+ Undo.SetTransformParent(child1.transform, go.transform, "create BlendListCam child");
+ var child2 = CreateDefaultVirtualCamera();
+ child2.m_Lens.FieldOfView = 10;
+ Undo.SetTransformParent(child2.transform, go.transform, "create BlendListCam child");
+
+ // Set up initial instruction set
+ vcam.m_Instructions = new CinemachineBlendListCamera.Instruction[2];
+ vcam.m_Instructions[0].m_VirtualCamera = child1;
+ vcam.m_Instructions[0].m_Hold = 1f;
+ vcam.m_Instructions[1].m_VirtualCamera = child2;
+ vcam.m_Instructions[1].m_Blend.m_Style = CinemachineBlendDefinition.Style.EaseInOut;
+ vcam.m_Instructions[1].m_Blend.m_Time = 2f;
+ }
+
+ [MenuItem("Cinemachine/Create State-Driven Camera", false, 1)]
+ private static void CreateStateDivenCamera()
+ {
+ CreateCameraBrainIfAbsent();
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineStateDrivenCamera), "CM StateDrivenCamera"),
+ typeof(CinemachineStateDrivenCamera));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create state driven camera");
+ Selection.activeGameObject = go;
+
+ // Give it a child
+ Undo.SetTransformParent(CreateDefaultVirtualCamera().transform, go.transform, "create state driven camera");
+ }
+
+#if CINEMACHINE_PHYSICS
+ [MenuItem("Cinemachine/Create ClearShot Camera", false, 1)]
+ private static void CreateClearShotVirtualCamera()
+ {
+ CreateCameraBrainIfAbsent();
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineClearShot), "CM ClearShot"),
+ typeof(CinemachineClearShot));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create ClearShot camera");
+ Selection.activeGameObject = go;
+
+ // Give it a child
+ var child = CreateDefaultVirtualCamera();
+ Undo.SetTransformParent(child.transform, go.transform, "create ClearShot camera");
+ var collider = Undo.AddComponent<CinemachineCollider>(child.gameObject);
+ collider.m_AvoidObstacles = false;
+ Undo.RecordObject(collider, "create ClearShot camera");
+ }
+#endif
+
+ [MenuItem("Cinemachine/Create Dolly Camera with Track", false, 1)]
+ private static void CreateDollyCameraWithPath()
+ {
+ CinemachineVirtualCamera vcam = InternalCreateVirtualCamera(
+ "CM vcam", true, typeof(CinemachineComposer), typeof(CinemachineTrackedDolly));
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineSmoothPath), "DollyTrack"),
+ typeof(CinemachineSmoothPath));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create track");
+ CinemachineSmoothPath path = go.GetComponent<CinemachineSmoothPath>();
+ var dolly = vcam.GetCinemachineComponent<CinemachineTrackedDolly>();
+ Undo.RecordObject(dolly, "create track");
+ dolly.m_Path = path;
+ }
+
+ [MenuItem("Cinemachine/Create Dolly Track with Cart", false, 1)]
+ private static void CreateDollyTrackWithCart()
+ {
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineSmoothPath), "DollyTrack"),
+ typeof(CinemachineSmoothPath));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create track");
+ CinemachineSmoothPath path = go.GetComponent<CinemachineSmoothPath>();
+ Selection.activeGameObject = go;
+
+ go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineDollyCart), "DollyCart"),
+ typeof(CinemachineDollyCart));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create cart");
+ CinemachineDollyCart cart = go.GetComponent<CinemachineDollyCart>();
+ Undo.RecordObject(cart, "create track");
+ cart.m_Path = path;
+ }
+
+ [MenuItem("Cinemachine/Create Target Group Camera", false, 1)]
+ private static void CreateTargetGroupCamera()
+ {
+ CinemachineVirtualCamera vcam = InternalCreateVirtualCamera(
+ "CM vcam", true, typeof(CinemachineGroupComposer), typeof(CinemachineTransposer));
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineTargetGroup), "TargetGroup"),
+ typeof(CinemachineTargetGroup));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create target group");
+ vcam.LookAt = go.transform;
+ vcam.Follow = go.transform;
+ }
+
+ [MenuItem("Cinemachine/Create Mixing Camera", false, 1)]
+ private static void CreateMixingCamera()
+ {
+ CreateCameraBrainIfAbsent();
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineMixingCamera), "CM MixingCamera"),
+ typeof(CinemachineMixingCamera));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create MixingCamera camera");
+ Selection.activeGameObject = go;
+
+ // Give it a couple of children
+ Undo.SetTransformParent(CreateDefaultVirtualCamera().transform, go.transform, "create MixedCamera child");
+ Undo.SetTransformParent(CreateDefaultVirtualCamera().transform, go.transform, "create MixingCamera child");
+ }
+
+ [MenuItem("Cinemachine/Create 2D Camera", false, 1)]
+ private static void Create2DCamera()
+ {
+ InternalCreateVirtualCamera("CM vcam", true, typeof(CinemachineFramingTransposer));
+ }
+
+ [MenuItem("Cinemachine/Import Example Asset Package")]
+ private static void ImportExamplePackage()
+ {
+ string pkgFile = ScriptableObjectUtility.CinemachineInstallPath
+ + "/Extras~/CinemachineExamples.unitypackage";
+ if (!File.Exists(pkgFile))
+ Debug.LogError("Missing file " + pkgFile);
+ else
+ AssetDatabase.ImportPackage(pkgFile, true);
+ }
+
+ /// <summary>
+ /// Create a default Virtual Camera, with standard components
+ /// </summary>
+ public static CinemachineVirtualCamera CreateDefaultVirtualCamera()
+ {
+ return InternalCreateVirtualCamera(
+ "CM vcam", false, typeof(CinemachineComposer), typeof(CinemachineTransposer));
+ }
+
+ /// <summary>
+ /// Create a Virtual Camera, with components
+ /// </summary>
+ static CinemachineVirtualCamera InternalCreateVirtualCamera(
+ string name, bool selectIt, params Type[] components)
+ {
+ // Create a new virtual camera
+ CreateCameraBrainIfAbsent();
+ GameObject go = InspectorUtility.CreateGameObject(
+ GenerateUniqueObjectName(typeof(CinemachineVirtualCamera), name),
+ typeof(CinemachineVirtualCamera));
+ if (SceneView.lastActiveSceneView != null)
+ go.transform.position = SceneView.lastActiveSceneView.pivot;
+ Undo.RegisterCreatedObjectUndo(go, "create " + name);
+ CinemachineVirtualCamera vcam = go.GetComponent<CinemachineVirtualCamera>();
+ GameObject componentOwner = vcam.GetComponentOwner().gameObject;
+ foreach (Type t in components)
+ Undo.AddComponent(componentOwner, t);
+ vcam.InvalidateComponentPipeline();
+ if (selectIt)
+ Selection.activeObject = go;
+ return vcam;
+ }
+
+ /// <summary>
+ /// If there is no CinemachineBrain in the scene, try to create one on the main camera
+ /// </summary>
+ public static void CreateCameraBrainIfAbsent()
+ {
+ CinemachineBrain[] brains = UnityEngine.Object.FindObjectsOfType(
+ typeof(CinemachineBrain)) as CinemachineBrain[];
+ if (brains == null || brains.Length == 0)
+ {
+ Camera cam = Camera.main;
+ if (cam == null)
+ {
+ Camera[] cams = UnityEngine.Object.FindObjectsOfType(
+ typeof(Camera)) as Camera[];
+ if (cams != null && cams.Length > 0)
+ cam = cams[0];
+ }
+ if (cam != null)
+ {
+ Undo.AddComponent<CinemachineBrain>(cam.gameObject);
+ }
+ }
+ }
+
+ /// <summary>
+ /// Generate a unique name with the given prefix by adding a suffix to it
+ /// </summary>
+ public static string GenerateUniqueObjectName(Type type, string prefix)
+ {
+ int count = 0;
+ UnityEngine.Object[] all = Resources.FindObjectsOfTypeAll(type);
+ foreach (UnityEngine.Object o in all)
+ {
+ if (o != null && o.name.StartsWith(prefix))
+ {
+ string suffix = o.name.Substring(prefix.Length);
+ int i;
+ if (Int32.TryParse(suffix, out i) && i > count)
+ count = i;
+ }
+ }
+ return prefix + (count + 1);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 54b24e51e2a9fa242b38d80ee11f3b2d
+timeCreated: 1481654955
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 0e25865eefe5b6f40a615add150c0042
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_POST_PROCESSING_V2
+
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Rendering.PostProcessing;
+using UnityEditor.Rendering.PostProcessing;
+
+namespace Cinemachine.PostFX.Editor
+{
+ [CustomEditor(typeof(CinemachinePostProcessing))]
+ public sealed class CinemachinePostProcessingEditor
+ : Cinemachine.Editor.BaseEditor<CinemachinePostProcessing>
+ {
+ SerializedProperty m_Profile;
+ SerializedProperty m_FocusTracksTarget;
+ SerializedProperty m_FocusOffset;
+
+ EffectListEditor m_EffectList;
+ GUIContent m_ProfileLabel;
+
+ void OnEnable()
+ {
+ Texture textue = Resources.Load("PostProcessLayer") as Texture;
+ m_ProfileLabel = new GUIContent("Profile", textue, "A reference to a profile asset");
+
+ m_FocusTracksTarget = FindProperty(x => x.m_FocusTracksTarget);
+ m_FocusOffset = FindProperty(x => x.m_FocusOffset);
+ m_Profile = FindProperty(x => x.m_Profile);
+
+ m_EffectList = new EffectListEditor(this);
+ RefreshEffectListEditor(Target.m_Profile);
+ }
+
+ void OnDisable()
+ {
+ if (m_EffectList != null)
+ m_EffectList.Clear();
+ }
+
+ void RefreshEffectListEditor(PostProcessProfile asset)
+ {
+ if (m_EffectList == null)
+ m_EffectList = new EffectListEditor(this);
+ m_EffectList.Clear();
+ if (asset != null)
+ m_EffectList.Init(asset, new SerializedObject(asset));
+ }
+
+ public override void OnInspectorGUI()
+ {
+ serializedObject.Update();
+
+ if (m_FocusTracksTarget.boolValue)
+ {
+ bool valid = false;
+ DepthOfField dof;
+ if (Target.m_Profile != null && Target.m_Profile.TryGetSettings(out dof))
+ valid = dof.enabled && dof.active && dof.focusDistance.overrideState;
+ if (!valid)
+ EditorGUILayout.HelpBox(
+ "Focus Tracking requires an active DepthOfField/FocusDistance effect in the profile",
+ MessageType.Warning);
+ else
+ {
+ if (!Target.VirtualCamera.State.HasLookAt)
+ EditorGUILayout.HelpBox(
+ "Focus Offset is relative to the Camera position",
+ MessageType.Info);
+ else
+ EditorGUILayout.HelpBox(
+ "Focus Offset is relative to the Target position",
+ MessageType.Info);
+ }
+ }
+
+ var rect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight); rect.y += 2;
+ float checkboxWidth = rect.height + 5;
+ rect = EditorGUI.PrefixLabel(rect, new GUIContent(m_FocusTracksTarget.displayName));
+ EditorGUI.PropertyField(new Rect(rect.x, rect.y, checkboxWidth, rect.height), m_FocusTracksTarget, GUIContent.none);
+ rect.x += checkboxWidth; rect.width -= checkboxWidth;
+ if (m_FocusTracksTarget.boolValue)
+ {
+ GUIContent offsetText = new GUIContent("Offset ");
+ var textDimensions = GUI.skin.label.CalcSize(offsetText);
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = textDimensions.x;
+ EditorGUI.PropertyField(rect, m_FocusOffset, offsetText);
+ EditorGUIUtility.labelWidth = oldWidth;
+ }
+
+ DrawProfileInspectorGUI();
+ Target.InvalidateCachedProfile();
+
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ void DrawProfileInspectorGUI()
+ {
+ EditorGUILayout.Space();
+
+ bool assetHasChanged = false;
+ bool showCopy = m_Profile.objectReferenceValue != null;
+
+ // The layout system sort of break alignement when mixing inspector fields with custom
+ // layouted fields, do the layout manually instead
+ int buttonWidth = showCopy ? 45 : 60;
+ float indentOffset = EditorGUI.indentLevel * 15f;
+ var lineRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
+ var labelRect = new Rect(lineRect.x, lineRect.y, EditorGUIUtility.labelWidth - indentOffset, lineRect.height);
+ var fieldRect = new Rect(labelRect.xMax, lineRect.y, lineRect.width - labelRect.width - buttonWidth * (showCopy ? 2 : 1), lineRect.height);
+ var buttonNewRect = new Rect(fieldRect.xMax, lineRect.y, buttonWidth, lineRect.height);
+ var buttonCopyRect = new Rect(buttonNewRect.xMax, lineRect.y, buttonWidth, lineRect.height);
+
+ EditorGUI.PrefixLabel(labelRect, m_ProfileLabel);
+
+ using (var scope = new EditorGUI.ChangeCheckScope())
+ {
+ m_Profile.objectReferenceValue
+ = (PostProcessProfile)EditorGUI.ObjectField(
+ fieldRect, m_Profile.objectReferenceValue, typeof(PostProcessProfile), false);
+ assetHasChanged = scope.changed;
+ }
+
+ if (GUI.Button(
+ buttonNewRect,
+ EditorUtilities.GetContent("New|Create a new profile."),
+ showCopy ? EditorStyles.miniButtonLeft : EditorStyles.miniButton))
+ {
+ // By default, try to put assets in a folder next to the currently active
+ // scene file. If the user isn't a scene, put them in root instead.
+ var targetName = Target.name;
+ var scene = Target.gameObject.scene;
+ var asset = CreatePostProcessProfile(scene, targetName);
+ m_Profile.objectReferenceValue = asset;
+ assetHasChanged = true;
+ }
+
+ if (showCopy && GUI.Button(
+ buttonCopyRect,
+ EditorUtilities.GetContent("Clone|Create a new profile and copy the content of the currently assigned profile."),
+ EditorStyles.miniButtonRight))
+ {
+ // Duplicate the currently assigned profile and save it as a new profile
+ var origin = (PostProcessProfile)m_Profile.objectReferenceValue;
+ var path = AssetDatabase.GetAssetPath(origin);
+ path = AssetDatabase.GenerateUniqueAssetPath(path);
+
+ var asset = Instantiate(origin);
+ asset.settings.Clear();
+ AssetDatabase.CreateAsset(asset, path);
+
+ foreach (var item in origin.settings)
+ {
+ var itemCopy = Instantiate(item);
+ itemCopy.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy;
+ itemCopy.name = item.name;
+ asset.settings.Add(itemCopy);
+ AssetDatabase.AddObjectToAsset(itemCopy, asset);
+ }
+
+ AssetDatabase.SaveAssets();
+ AssetDatabase.Refresh();
+
+ m_Profile.objectReferenceValue = asset;
+ assetHasChanged = true;
+ }
+
+ if (m_Profile.objectReferenceValue == null)
+ {
+ if (assetHasChanged && m_EffectList != null)
+ m_EffectList.Clear(); // Asset wasn't null before, do some cleanup
+
+ EditorGUILayout.HelpBox(
+ "Assign an existing Post-process Profile by choosing an asset, or create a new one by clicking the \"New\" button.\nNew assets are automatically put in a folder next to your scene file. If your scene hasn't been saved yet they will be created at the root of the Assets folder.",
+ MessageType.Info);
+ }
+ else
+ {
+ if (assetHasChanged)
+ RefreshEffectListEditor((PostProcessProfile)m_Profile.objectReferenceValue);
+ if (m_EffectList != null)
+ m_EffectList.OnGUI();
+ }
+ }
+
+ // Copied from UnityEditor.Rendering.PostProcessing.ProfileFactory.CreatePostProcessProfile() because it's internal
+ static PostProcessProfile CreatePostProcessProfile(UnityEngine.SceneManagement.Scene scene, string targetName)
+ {
+ var path = string.Empty;
+
+ if (string.IsNullOrEmpty(scene.path))
+ {
+ path = "Assets/";
+ }
+ else
+ {
+ var scenePath = System.IO.Path.GetDirectoryName(scene.path);
+ var extPath = scene.name + "_Profiles";
+ var profilePath = scenePath + "/" + extPath;
+
+ if (!AssetDatabase.IsValidFolder(profilePath))
+ AssetDatabase.CreateFolder(scenePath, extPath);
+
+ path = profilePath + "/";
+ }
+
+ path += targetName + " Profile.asset";
+ path = AssetDatabase.GenerateUniqueAssetPath(path);
+
+ var profile = ScriptableObject.CreateInstance<PostProcessProfile>();
+ AssetDatabase.CreateAsset(profile, path);
+ AssetDatabase.SaveAssets();
+ AssetDatabase.Refresh();
+ return profile;
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: dec69862942cc9744ade63216979cafd
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_POST_PROCESSING_V3
+
+using UnityEngine;
+using UnityEditor;
+using UnityEngine.Rendering;
+using UnityEditor.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace Cinemachine.PostFX.Editor
+{
+ [CustomEditor(typeof(CinemachineVolumeSettings))]
+ public sealed class CinemachineVolumeSettingsEditor
+ : Cinemachine.Editor.BaseEditor<CinemachineVolumeSettings>
+ {
+ SerializedProperty m_Profile;
+ SerializedProperty m_FocusTracksTarget;
+ SerializedProperty m_FocusOffset;
+
+ VolumeComponentListEditor m_ComponentList;
+
+ GUIContent m_ProfileLabel;
+ GUIContent m_NewLabel;
+ GUIContent m_CloneLabel;
+
+ void OnEnable()
+ {
+ m_ProfileLabel = new GUIContent("Profile", "A reference to a profile asset");
+ m_NewLabel = new GUIContent("New", "Create a new profile.");
+ m_CloneLabel = new GUIContent("Clone", "Create a new profile and copy the content of the currently assigned profile.");
+
+ m_FocusTracksTarget = FindProperty(x => x.m_FocusTracksTarget);
+ m_FocusOffset = FindProperty(x => x.m_FocusOffset);
+ m_Profile = FindProperty(x => x.m_Profile);
+
+ RefreshVolumeComponentEditor(Target.m_Profile);
+ }
+
+ void OnDisable()
+ {
+ if (m_ComponentList != null)
+ m_ComponentList.Clear();
+ }
+
+ void RefreshVolumeComponentEditor(VolumeProfile asset)
+ {
+ if (m_ComponentList == null)
+ m_ComponentList = new VolumeComponentListEditor(this);
+ m_ComponentList.Clear();
+ if (asset != null)
+ m_ComponentList.Init(asset, new SerializedObject(asset));
+ }
+
+ public override void OnInspectorGUI()
+ {
+ serializedObject.Update();
+
+ if (m_FocusTracksTarget.boolValue)
+ {
+ bool valid = false;
+ DepthOfField dof;
+ if (Target.m_Profile != null && Target.m_Profile.TryGet(out dof))
+ valid = dof.active && dof.focusDistance.overrideState
+ && dof.focusMode == DepthOfFieldMode.UsePhysicalCamera;
+ if (!valid)
+ EditorGUILayout.HelpBox(
+ "Focus Tracking requires an active DepthOfField/FocusDistance effect and FoculdMode set to Physical Camera in the profile",
+ MessageType.Warning);
+ else
+ {
+ if (!Target.VirtualCamera.State.HasLookAt)
+ EditorGUILayout.HelpBox(
+ "Focus Offset is relative to the Camera position",
+ MessageType.Info);
+ else
+ EditorGUILayout.HelpBox(
+ "Focus Offset is relative to the Target position",
+ MessageType.Info);
+ }
+ }
+
+ var rect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight); rect.y += 2;
+ float checkboxWidth = rect.height + 5;
+ rect = EditorGUI.PrefixLabel(rect, new GUIContent(m_FocusTracksTarget.displayName));
+ EditorGUI.PropertyField(new Rect(rect.x, rect.y, checkboxWidth, rect.height), m_FocusTracksTarget, GUIContent.none);
+ rect.x += checkboxWidth; rect.width -= checkboxWidth;
+ if (m_FocusTracksTarget.boolValue)
+ {
+ GUIContent offsetText = new GUIContent("Offset ");
+ var textDimensions = GUI.skin.label.CalcSize(offsetText);
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = textDimensions.x;
+ EditorGUI.PropertyField(rect, m_FocusOffset, offsetText);
+ EditorGUIUtility.labelWidth = oldWidth;
+ }
+
+ DrawProfileInspectorGUI();
+ Target.InvalidateCachedProfile();
+
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ void DrawProfileInspectorGUI()
+ {
+ EditorGUILayout.Space();
+
+ bool assetHasChanged = false;
+ bool showCopy = m_Profile.objectReferenceValue != null;
+
+ // The layout system sort of break alignement when mixing inspector fields with custom
+ // layouted fields, do the layout manually instead
+ int buttonWidth = showCopy ? 45 : 60;
+ float indentOffset = EditorGUI.indentLevel * 15f;
+ var lineRect = GUILayoutUtility.GetRect(1, EditorGUIUtility.singleLineHeight);
+ var labelRect = new Rect(lineRect.x, lineRect.y, EditorGUIUtility.labelWidth - indentOffset, lineRect.height);
+ var fieldRect = new Rect(labelRect.xMax, lineRect.y, lineRect.width - labelRect.width - buttonWidth * (showCopy ? 2 : 1), lineRect.height);
+ var buttonNewRect = new Rect(fieldRect.xMax, lineRect.y, buttonWidth, lineRect.height);
+ var buttonCopyRect = new Rect(buttonNewRect.xMax, lineRect.y, buttonWidth, lineRect.height);
+
+ EditorGUI.PrefixLabel(labelRect, m_ProfileLabel);
+
+ using (var scope = new EditorGUI.ChangeCheckScope())
+ {
+ m_Profile.objectReferenceValue
+ = (VolumeProfile)EditorGUI.ObjectField(
+ fieldRect, m_Profile.objectReferenceValue, typeof(VolumeProfile), false);
+ assetHasChanged = scope.changed;
+ }
+
+ if (GUI.Button(buttonNewRect, m_NewLabel,
+ showCopy ? EditorStyles.miniButtonLeft : EditorStyles.miniButton))
+ {
+ // By default, try to put assets in a folder next to the currently active
+ // scene file. If the user isn't a scene, put them in root instead.
+ var targetName = Target.name;
+ var scene = Target.gameObject.scene;
+ var asset = CreateVolumeProfile(scene, targetName);
+ m_Profile.objectReferenceValue = asset;
+ assetHasChanged = true;
+ }
+
+ if (showCopy && GUI.Button(buttonCopyRect, m_CloneLabel, EditorStyles.miniButtonRight))
+ {
+ // Duplicate the currently assigned profile and save it as a new profile
+ var origin = (VolumeProfile)m_Profile.objectReferenceValue;
+ var path = AssetDatabase.GetAssetPath(origin);
+ path = AssetDatabase.GenerateUniqueAssetPath(path);
+
+ var asset = Instantiate(origin);
+ asset.components.Clear();
+ AssetDatabase.CreateAsset(asset, path);
+
+ foreach (var item in origin.components)
+ {
+ var itemCopy = Instantiate(item);
+ itemCopy.hideFlags = HideFlags.HideInInspector | HideFlags.HideInHierarchy;
+ itemCopy.name = item.name;
+ asset.components.Add(itemCopy);
+ AssetDatabase.AddObjectToAsset(itemCopy, asset);
+ }
+
+ AssetDatabase.SaveAssets();
+ AssetDatabase.Refresh();
+
+ m_Profile.objectReferenceValue = asset;
+ assetHasChanged = true;
+ }
+
+ if (m_Profile.objectReferenceValue == null)
+ {
+ if (assetHasChanged && m_ComponentList != null)
+ m_ComponentList.Clear(); // Asset wasn't null before, do some cleanup
+
+ EditorGUILayout.HelpBox(
+ "Assign an existing Volume Profile by choosing an asset, or create a new one by clicking the \"New\" button.\nNew assets are automatically put in a folder next to your scene file. If your scene hasn't been saved yet they will be created at the root of the Assets folder.",
+ MessageType.Info);
+ }
+ else
+ {
+ EditorGUILayout.Space();
+ if (assetHasChanged)
+ RefreshVolumeComponentEditor((VolumeProfile)m_Profile.objectReferenceValue);
+ if (m_ComponentList != null)
+ m_ComponentList.OnGUI();
+ }
+ }
+
+ // Copied from UnityEditor.Rendering.PostProcessing.ProfileFactory.CreateVolumeProfile() because it's internal
+ static VolumeProfile CreateVolumeProfile(UnityEngine.SceneManagement.Scene scene, string targetName)
+ {
+ var path = string.Empty;
+
+ if (string.IsNullOrEmpty(scene.path))
+ {
+ path = "Assets/";
+ }
+ else
+ {
+ var scenePath = System.IO.Path.GetDirectoryName(scene.path);
+ var extPath = scene.name + "_Profiles";
+ var profilePath = scenePath + "/" + extPath;
+
+ if (!AssetDatabase.IsValidFolder(profilePath))
+ AssetDatabase.CreateFolder(scenePath, extPath);
+
+ path = profilePath + "/";
+ }
+
+ path += targetName + " Profile.asset";
+ path = AssetDatabase.GenerateUniqueAssetPath(path);
+
+ var profile = ScriptableObject.CreateInstance<VolumeProfile>();
+ AssetDatabase.CreateAsset(profile, path);
+ AssetDatabase.SaveAssets();
+ AssetDatabase.Refresh();
+ return profile;
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 12a60b3365a7d424cbc3f935bd1ed799
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 9624eb95bd1e31744a52461501b39e66
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: d6e27dc5ad82e7c4e8cddded5872eb77
+TextureImporter:
+ internalIDToNameTable: []
+ externalObjects: {}
+ serializedVersion: 8
+ mipmaps:
+ mipMapMode: 0
+ enableMipMap: 1
+ sRGBTexture: 1
+ linearTexture: 0
+ fadeOut: 0
+ borderMipMap: 0
+ mipMapsPreserveCoverage: 0
+ alphaTestReferenceValue: 0.5
+ mipMapFadeDistanceStart: 1
+ mipMapFadeDistanceEnd: 3
+ bumpmap:
+ convertToNormalMap: 0
+ externalNormalMap: 0
+ heightScale: 0.25
+ normalMapFilter: 0
+ isReadable: 0
+ streamingMipmaps: 0
+ streamingMipmapsPriority: 0
+ grayScaleToAlpha: 0
+ generateCubemap: 6
+ cubemapConvolution: 0
+ seamlessCubemap: 0
+ textureFormat: 1
+ maxTextureSize: 2048
+ textureSettings:
+ serializedVersion: 2
+ filterMode: -1
+ aniso: -1
+ mipBias: -100
+ wrapU: -1
+ wrapV: -1
+ wrapW: -1
+ nPOTScale: 1
+ lightmap: 0
+ compressionQuality: 50
+ spriteMode: 0
+ spriteExtrude: 1
+ spriteMeshType: 1
+ alignment: 0
+ spritePivot: {x: 0.5, y: 0.5}
+ spritePixelsToUnits: 100
+ spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+ spriteGenerateFallbackPhysicsShape: 1
+ alphaUsage: 1
+ alphaIsTransparency: 0
+ spriteTessellationDetail: -1
+ textureType: 0
+ textureShape: 1
+ singleChannelComponent: 0
+ maxTextureSizeSet: 0
+ compressionQualitySet: 0
+ textureFormatSet: 0
+ platformSettings:
+ - serializedVersion: 2
+ buildTarget: DefaultTexturePlatform
+ maxTextureSize: 2048
+ resizeAlgorithm: 0
+ textureFormat: -1
+ textureCompression: 1
+ compressionQuality: 50
+ crunchedCompression: 0
+ allowsAlphaSplitting: 0
+ overridden: 0
+ androidETC2FallbackOverride: 0
+ spriteSheet:
+ serializedVersion: 2
+ sprites: []
+ outline: []
+ physicsShape: []
+ bones: []
+ spriteID:
+ internalID: 0
+ vertices: []
+ indices:
+ edges: []
+ weights: []
+ secondaryTextures: []
+ spritePackingTag:
+ pSDRemoveMatte: 0
+ pSDShowRemoveMatteOption: 0
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 31c3ab7d86d07034eb528155d40c016b
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.Reflection;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(AxisStatePropertyAttribute))]
+ internal sealed class AxisStatePropertyDrawer : PropertyDrawer
+ {
+ const int vSpace = 2;
+ bool mExpanded = true;
+ AxisState def = new AxisState(); // to access name strings
+
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ float height = EditorGUIUtility.singleLineHeight;
+ rect.height = height;
+ mExpanded = EditorGUI.Foldout(rect, mExpanded, label, true);
+ if (mExpanded)
+ {
+ ++EditorGUI.indentLevel;
+
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.Value));
+
+ if (!ValueRangeIsLocked(property))
+ {
+ rect.y += height + vSpace;
+ InspectorUtility.MultiPropertyOnLine(rect, new GUIContent("Value Range"),
+ new [] { property.FindPropertyRelative(() => def.m_MinValue),
+ property.FindPropertyRelative(() => def.m_MaxValue),
+ property.FindPropertyRelative(() => def.m_Wrap) },
+ new [] { GUIContent.none, new GUIContent("to "), null });
+ }
+
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.m_MaxSpeed));
+
+ rect.y += height + vSpace;
+ InspectorUtility.MultiPropertyOnLine(
+ rect, null,
+ new [] { property.FindPropertyRelative(() => def.m_AccelTime),
+ property.FindPropertyRelative(() => def.m_DecelTime)},
+ new [] { GUIContent.none, null });
+
+ if (HasRecentering(property))
+ {
+ var rDef = new AxisState.Recentering();
+ var recentering = property.FindPropertyRelative(() => def.m_Recentering);
+ rect.y += height + vSpace;
+ InspectorUtility.MultiPropertyOnLine(
+ rect, new GUIContent(recentering.displayName, recentering.tooltip),
+ new [] {
+ recentering.FindPropertyRelative(() => rDef.m_enabled),
+ recentering.FindPropertyRelative(() => rDef.m_WaitTime),
+ recentering.FindPropertyRelative(() => rDef.m_RecenteringTime)},
+ new [] { new GUIContent(""),
+ new GUIContent("Wait"),
+ new GUIContent("Time")} );
+ }
+
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.m_InputAxisName));
+
+ rect.y += height + vSpace;
+ InspectorUtility.MultiPropertyOnLine(rect, null,
+ new [] { property.FindPropertyRelative(() => def.m_InputAxisValue),
+ property.FindPropertyRelative(() => def.m_InvertInput) },
+ new [] { GUIContent.none, new GUIContent("Invert") });
+
+ --EditorGUI.indentLevel;
+ }
+ }
+
+ public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+ {
+ float height = EditorGUIUtility.singleLineHeight + vSpace;
+ if (mExpanded)
+ {
+ int lines = 6;
+ if (!ValueRangeIsLocked(property))
+ ++lines;
+ if (HasRecentering(property))
+ ++lines;
+ height *= lines;
+ }
+ return height - vSpace;
+ }
+
+ bool ValueRangeIsLocked(SerializedProperty property)
+ {
+ bool value = false;
+ PropertyInfo pi = typeof(AxisState).GetProperty(
+ "ValueRangeLocked", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+ if (pi != null)
+ value = bool.Equals(true, pi.GetValue(SerializedPropertyHelper.GetPropertyValue(property), null));
+ return value;
+ }
+
+ bool HasRecentering(SerializedProperty property)
+ {
+ bool value = false;
+ PropertyInfo pi = typeof(AxisState).GetProperty(
+ "HasRecentering", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+ if (pi != null)
+ value = bool.Equals(true, pi.GetValue(SerializedPropertyHelper.GetPropertyValue(property), null));
+ return value;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 70f1be76e10cd9f44ad1a86b9e05745e
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(CinemachineBlendDefinitionPropertyAttribute))]
+ internal sealed class CinemachineBlendDefinitionPropertyDrawer : PropertyDrawer
+ {
+ CinemachineBlendDefinition myClass = new CinemachineBlendDefinition(); // to access name strings
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ float vSpace = 0;
+ float floatFieldWidth = EditorGUIUtility.singleLineHeight * 2.5f;
+
+ SerializedProperty timeProp = property.FindPropertyRelative(() => myClass.m_Time);
+ GUIContent timeText = new GUIContent(" s", timeProp.tooltip);
+ var textDimensions = GUI.skin.label.CalcSize(timeText);
+
+ rect = EditorGUI.PrefixLabel(rect, label);
+
+ rect.y += vSpace; rect.height = EditorGUIUtility.singleLineHeight;
+ rect.width -= floatFieldWidth + textDimensions.x;
+
+ SerializedProperty styleProp = property.FindPropertyRelative(() => myClass.m_Style);
+ if (styleProp.enumValueIndex != (int)CinemachineBlendDefinition.Style.Custom)
+ EditorGUI.PropertyField(rect, styleProp, GUIContent.none);
+ else
+ {
+ SerializedProperty curveProp = property.FindPropertyRelative(() => myClass.m_CustomCurve);
+ Rect r = rect;
+ r.width -= rect.height;
+ r.height -= 1;
+ EditorGUI.BeginChangeCheck();
+ EditorGUI.PropertyField(r, curveProp, GUIContent.none);
+ if (EditorGUI.EndChangeCheck())
+ {
+ curveProp.animationCurveValue = InspectorUtility.NormalizeCurve(curveProp.animationCurveValue);
+ curveProp.serializedObject.ApplyModifiedProperties();
+ }
+ r.x += r.width; r.width = r.height; ++r.height;
+ EditorGUI.PropertyField(r, styleProp, GUIContent.none);
+ }
+ if (styleProp.intValue != (int)CinemachineBlendDefinition.Style.Cut)
+ {
+ float oldWidth = EditorGUIUtility.labelWidth;
+ EditorGUIUtility.labelWidth = textDimensions.x;
+ rect.x += rect.width; rect.width = floatFieldWidth + EditorGUIUtility.labelWidth;
+ EditorGUI.BeginChangeCheck();
+ EditorGUI.PropertyField(rect, timeProp, timeText);
+ if (EditorGUI.EndChangeCheck())
+ timeProp.floatValue = Mathf.Max(timeProp.floatValue, 0);
+ EditorGUIUtility.labelWidth = oldWidth;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 4a9c464b0191f7d4da1d129d97d8240b
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(TagFieldAttribute))]
+ internal sealed class CinemachineTagFieldPropertyDrawer : PropertyDrawer
+ {
+ const float hSpace = 2;
+ GUIContent clearText = new GUIContent("Clear", "Set the tag to empty");
+
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ var textDimensions = GUI.skin.button.CalcSize(clearText);
+
+ rect.width -= textDimensions.x + hSpace;
+ string oldValue = property.stringValue;
+ string newValue = EditorGUI.TagField(rect, label, oldValue);
+
+ rect.x += rect.width + hSpace; rect.width = textDimensions.x; rect.height -=1;
+ GUI.enabled = oldValue.Length > 0;
+ if (GUI.Button(rect, clearText))
+ newValue = string.Empty;
+ GUI.enabled = true;
+ if (oldValue != newValue)
+ property.stringValue = newValue;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: ed3efd28525441947b55ec9b5d68ba31
+timeCreated: 1510677929
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System;
+using Cinemachine.Utility;
+using System.Linq;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(CinemachineEmbeddedAssetPropertyAttribute))]
+ internal sealed class EmbeddedAssetPropertyDrawer : PropertyDrawer
+ {
+ const float vSpace = 2;
+ const float kIndentAmount = 15;
+ const float kBoxMargin = 3;
+ float HelpBoxHeight { get { return EditorGUIUtility.singleLineHeight * 2.5f; } }
+ bool mExpanded = false;
+
+ bool WarnIfNull
+ {
+ get
+ {
+ var attr = attribute as CinemachineEmbeddedAssetPropertyAttribute;
+ return attr == null ? false : attr.WarnIfNull;
+ }
+ }
+
+ float HeaderHeight { get { return EditorGUIUtility.singleLineHeight * 1.5f; } }
+ float DrawHeader(Rect rect, string text)
+ {
+ float delta = HeaderHeight - EditorGUIUtility.singleLineHeight;
+ rect.y += delta; rect.height -= delta;
+ EditorGUI.LabelField(rect, new GUIContent(text), EditorStyles.boldLabel);
+ return HeaderHeight;
+ }
+
+ string HeaderText(SerializedProperty property)
+ {
+ var attrs = property.serializedObject.targetObject.GetType()
+ .GetCustomAttributes(typeof(HeaderAttribute), false);
+ if (attrs != null && attrs.Length > 0)
+ return ((HeaderAttribute)attrs[0]).header;
+ return null;
+ }
+
+ bool AssetHasCustomEditor(SerializedProperty property)
+ {
+ ScriptableObject asset = property.objectReferenceValue as ScriptableObject;
+ if (asset != null)
+ return ActiveEditorTracker.HasCustomEditor(asset);
+ return false;
+ }
+
+ public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+ {
+ bool hasCustomEditor = AssetHasCustomEditor(property);
+ float height = base.GetPropertyHeight(property, label);
+ height += + 2 * (kBoxMargin + vSpace);
+ if (mExpanded && !hasCustomEditor)
+ {
+ height += HelpBoxHeight + kBoxMargin;
+ ScriptableObject asset = property.objectReferenceValue as ScriptableObject;
+ if (asset != null)
+ {
+ SerializedObject so = new SerializedObject(asset);
+ var prop = so.GetIterator();
+ prop.NextVisible(true);
+ do
+ {
+ if (prop.name == "m_Script")
+ continue;
+ string header = HeaderText(prop);
+ if (header != null)
+ height += HeaderHeight + vSpace;
+ height += EditorGUI.GetPropertyHeight(prop, false) + vSpace;
+ }
+ while (prop.NextVisible(prop.isExpanded));
+ height += kBoxMargin;
+ }
+ }
+ return height;
+ }
+
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ bool hasCustomEditor = AssetHasCustomEditor(property);
+ rect.y += vSpace; rect.height -= 2 * vSpace;
+ GUI.Box(rect, GUIContent.none, GUI.skin.box);
+ rect.y += kBoxMargin;
+
+ rect.height = EditorGUIUtility.singleLineHeight;
+ EditorGUIUtility.labelWidth -= kBoxMargin;
+ AssetFieldWithCreateButton(
+ new Rect(rect.x + kBoxMargin, rect.y, rect.width - 2 * kBoxMargin, rect.height),
+ property, WarnIfNull,
+ property.serializedObject.targetObject.name + " " + label.text);
+
+ ScriptableObject asset = property.objectReferenceValue as ScriptableObject;
+ if (asset != null && !hasCustomEditor)
+ {
+ mExpanded = EditorGUI.Foldout(rect, mExpanded, GUIContent.none, true);
+ if (mExpanded)
+ {
+ rect.y += rect.height + kBoxMargin + vSpace;
+ rect.x += kIndentAmount + kBoxMargin;
+ rect.width -= kIndentAmount + 2 * kBoxMargin;
+ EditorGUIUtility.labelWidth -= kIndentAmount;
+
+ EditorGUI.HelpBox(
+ new Rect(rect.x, rect.y, rect.width, HelpBoxHeight),
+ "This is a shared asset.\n"
+ + "Changes made here will apply to all users of this asset",
+ MessageType.Info);
+
+ rect.y += HelpBoxHeight + kBoxMargin;
+ SerializedObject so = new SerializedObject(property.objectReferenceValue);
+ var prop = so.GetIterator();
+ prop.NextVisible(true);
+
+ var indent = EditorGUI.indentLevel;
+ do
+ {
+ if (prop.name == "m_Script")
+ continue;
+ string header = HeaderText(prop);
+ if (header != null)
+ {
+ DrawHeader(rect, header);
+ rect.y += HeaderHeight + vSpace;
+ rect.height -= HeaderHeight + vSpace;
+ }
+ rect.height = EditorGUI.GetPropertyHeight(prop, false);
+ EditorGUI.indentLevel = indent + prop.depth;
+ EditorGUI.PropertyField(rect, prop);
+ rect.y += rect.height + vSpace;
+ } while (prop.NextVisible(prop.isExpanded));
+
+ if (GUI.changed)
+ so.ApplyModifiedProperties();
+ }
+ EditorGUIUtility.labelWidth += kIndentAmount;
+ }
+ EditorGUIUtility.labelWidth += kBoxMargin;
+ }
+
+ Type EmbeddedAssetType(SerializedProperty property)
+ {
+ Type type = property.serializedObject.targetObject.GetType();
+ var a = property.propertyPath.Split('.');
+ for (int i = 0; i < a.Length; ++i)
+ type = type.GetField(a[i],
+ System.Reflection.BindingFlags.Public
+ | System.Reflection.BindingFlags.NonPublic
+ | System.Reflection.BindingFlags.Instance).FieldType;
+ return type;
+ }
+
+ Type[] mAssetTypes = null;
+ List<ScriptableObject> mAssetPresets;
+ GUIContent[] mAssetPresetNames;
+
+ void RebuildPresetList()
+ {
+ if (mAssetPresets != null && mAssetPresetNames != null)
+ return;
+
+ mAssetPresets = new List<ScriptableObject>();
+#if UNITY_2018_1_OR_NEWER
+ if (mAssetTypes != null)
+ {
+ for (int i = 0; i < mAssetTypes.Length; ++i)
+ InspectorUtility.AddAssetsFromPackageSubDirectory(
+ mAssetTypes[i], mAssetPresets, "Presets/Noise");
+ }
+#endif
+ List<GUIContent> presetNameList = new List<GUIContent>();
+ foreach (var n in mAssetPresets)
+ presetNameList.Add(new GUIContent("Presets/" + n.name));
+ mAssetPresetNames = presetNameList.ToArray();
+ }
+
+ void AssetFieldWithCreateButton(
+ Rect r, SerializedProperty property, bool warnIfNull, string defaultName)
+ {
+ // Collect all the eligible asset types
+ Type type = EmbeddedAssetType(property);
+ if (mAssetTypes == null)
+ mAssetTypes = ReflectionHelpers.GetTypesInAllDependentAssemblies(
+ (Type t) => type.IsAssignableFrom(t) && !t.IsAbstract).ToArray();
+
+ float iconSize = r.height + 4;
+ r.width -= iconSize;
+
+ GUIContent label = new GUIContent(property.displayName, property.tooltip);
+ if (warnIfNull && property.objectReferenceValue == null)
+ label.image = EditorGUIUtility.IconContent("console.warnicon.sml").image;
+ EditorGUI.PropertyField(r, property, label);
+
+ r.x += r.width; r.width = iconSize; r.height = iconSize;
+ if (GUI.Button(r, EditorGUIUtility.IconContent("_Popup"), GUI.skin.label))
+ {
+ GenericMenu menu = new GenericMenu();
+ if (property.objectReferenceValue != null)
+ {
+ menu.AddItem(new GUIContent("Edit"), false, ()
+ => Selection.activeObject = property.objectReferenceValue);
+ menu.AddItem(new GUIContent("Clone"), false, () =>
+ {
+ ScriptableObject copyFrom = property.objectReferenceValue as ScriptableObject;
+ if (copyFrom != null)
+ {
+ string title = "Create New " + copyFrom.GetType().Name + " asset";
+ ScriptableObject asset = CreateAsset(
+ copyFrom.GetType(), copyFrom, defaultName, title);
+ if (asset != null)
+ {
+ property.objectReferenceValue = asset;
+ property.serializedObject.ApplyModifiedProperties();
+ }
+ }
+ });
+ menu.AddItem(new GUIContent("Locate"), false, ()
+ => EditorGUIUtility.PingObject(property.objectReferenceValue));
+ }
+
+ RebuildPresetList();
+ int i = 0;
+ foreach (var a in mAssetPresets)
+ {
+ menu.AddItem(mAssetPresetNames[i++], false, () =>
+ {
+ property.objectReferenceValue = a;
+ property.serializedObject.ApplyModifiedProperties();
+ });
+ }
+
+ foreach (var t in mAssetTypes)
+ {
+ menu.AddItem(new GUIContent("New " + InspectorUtility.NicifyClassName(t.Name)), false, () =>
+ {
+ string title = "Create New " + t.Name + " asset";
+ ScriptableObject asset = CreateAsset(t, null, defaultName, title);
+ if (asset != null)
+ {
+ property.objectReferenceValue = asset;
+ property.serializedObject.ApplyModifiedProperties();
+ }
+ });
+ }
+ menu.ShowAsContext();
+ }
+ }
+
+ ScriptableObject CreateAsset(
+ Type assetType, ScriptableObject copyFrom, string defaultName, string dialogTitle)
+ {
+ ScriptableObject asset = null;
+ string path = EditorUtility.SaveFilePanelInProject(
+ dialogTitle, defaultName, "asset", string.Empty);
+ if (!string.IsNullOrEmpty(path))
+ {
+ if (copyFrom != null)
+ {
+ string fromPath = AssetDatabase.GetAssetPath(copyFrom);
+ if (AssetDatabase.CopyAsset(fromPath, path))
+ asset = AssetDatabase.LoadAssetAtPath(path, assetType) as ScriptableObject;
+ }
+ else
+ {
+ asset = ScriptableObjectUtility.CreateAt(assetType, path);
+ }
+ AssetDatabase.SaveAssets();
+ AssetDatabase.Refresh();
+ }
+ return asset;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 57baee20e53f7b54782519af44a9468f
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.Reflection;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+using System;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(LensSettingsPropertyAttribute))]
+ internal sealed class LensSettingsPropertyDrawer : PropertyDrawer
+ {
+ const int vSpace = 2;
+ LensSettings def = new LensSettings(); // to access name strings
+ GUIContent FocalLengthLabel = new GUIContent("Focal Length", "The length of the lens (in mm)");
+
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ float height = EditorGUIUtility.singleLineHeight;
+ rect.height = height;
+ property.isExpanded = EditorGUI.Foldout(
+ new Rect(rect.x, rect.y, EditorGUIUtility.labelWidth, rect.height),
+ property.isExpanded, label, true);
+ if (property.isExpanded)
+ {
+ ++EditorGUI.indentLevel;
+ rect.y += height + vSpace;
+ if (IsOrtho)
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.OrthographicSize));
+ else
+ {
+ if (IsPhysical)
+ DrawFocalLengthControl(rect, property);
+ else
+ DrawFOVControl(rect, property);
+ }
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.NearClipPlane));
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.FarClipPlane));
+ if (IsPhysical)
+ {
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.LensShift));
+ }
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.Dutch));
+ --EditorGUI.indentLevel;
+ }
+ }
+
+ static float ExtraSpaceHackWTF() { return EditorGUIUtility.singleLineHeight - 2; }
+
+ void DrawFOVControl(Rect rect, SerializedProperty property)
+ {
+ var FOVProperty = property.FindPropertyRelative(() => def.FieldOfView);
+ float dropdownWidth = (rect.width - EditorGUIUtility.labelWidth) / 3;
+ rect.width -= dropdownWidth;
+ EditorGUI.PropertyField(rect, FOVProperty);
+ rect.x += rect.width; rect.width = dropdownWidth;
+
+ CinemachineLensPresets presets = CinemachineLensPresets.InstanceIfExists;
+ int preset = (presets == null) ? -1 : presets.GetMatchingPreset(FOVProperty.floatValue);
+ rect.x -= ExtraSpaceHackWTF(); rect.width += ExtraSpaceHackWTF();
+ int selection = EditorGUI.Popup(rect, GUIContent.none, preset, m_PresetOptions);
+ if (selection == m_PresetOptions.Length-1 && CinemachineLensPresets.Instance != null)
+ Selection.activeObject = presets = CinemachineLensPresets.Instance;
+ else if (selection >= 0 && selection < m_PresetOptions.Length-1)
+ {
+ FOVProperty.floatValue = presets.m_Presets[selection].m_FieldOfView;
+ property.serializedObject.ApplyModifiedProperties();
+ }
+ }
+
+ void DrawFocalLengthControl(Rect rect, SerializedProperty property)
+ {
+ var FOVProperty = property.FindPropertyRelative(() => def.FieldOfView);
+ float dropdownWidth = (rect.width - EditorGUIUtility.labelWidth) / 3;
+ rect.width -= dropdownWidth;
+ float f = VerticalFOVToFocalLength(FOVProperty.floatValue);
+ f = EditorGUI.FloatField(rect, FocalLengthLabel, f);
+ f = FocalLengthToVerticalFOV(f);
+ if (!Mathf.Approximately(FOVProperty.floatValue, f))
+ {
+ FOVProperty.floatValue = Mathf.Clamp(f, 1, 179);
+ property.serializedObject.ApplyModifiedProperties();
+ }
+ rect.x += rect.width; rect.width = dropdownWidth;
+
+ CinemachineLensPresets presets = CinemachineLensPresets.InstanceIfExists;
+ int preset = (presets == null) ? -1 : presets.GetMatchingPhysicalPreset(VerticalFOVToFocalLength(FOVProperty.floatValue));
+ rect.x -= ExtraSpaceHackWTF(); rect.width += ExtraSpaceHackWTF();
+ int selection = EditorGUI.Popup(rect, GUIContent.none, preset, m_PhysicalPresetOptions);
+ if (selection == m_PhysicalPresetOptions.Length-1 && CinemachineLensPresets.Instance != null)
+ Selection.activeObject = presets = CinemachineLensPresets.Instance;
+ else if (selection >= 0 && selection < m_PhysicalPresetOptions.Length-1)
+ {
+ FOVProperty.floatValue = FocalLengthToVerticalFOV(
+ presets.m_PhysicalPresets[selection].m_FocalLength);
+ property.serializedObject.ApplyModifiedProperties();
+ }
+ }
+
+ float VerticalFOVToFocalLength(float fov)
+ {
+ return SensorSize.y * 0.5f / Mathf.Tan(Mathf.Deg2Rad * fov * 0.5f);
+ }
+
+ float FocalLengthToVerticalFOV(float focalLength)
+ {
+ if (focalLength < UnityVectorExtensions.Epsilon)
+ return 180f;
+ return Mathf.Rad2Deg * 2.0f * Mathf.Atan(SensorSize.y * 0.5f / focalLength);
+ }
+
+ bool IsOrtho { get; set; }
+ bool IsPhysical { get; set; }
+ Vector2 SensorSize { get; set; }
+
+ GUIContent[] m_PresetOptions = new GUIContent[0];
+ GUIContent[] m_PhysicalPresetOptions = new GUIContent[0];
+
+ void CacheABunchOfStuff(SerializedProperty property)
+ {
+ object lens = SerializedPropertyHelper.GetPropertyValue(property);
+ IsOrtho = AccessProperty<bool>(typeof(LensSettings), lens, "Orthographic");
+ IsPhysical = AccessProperty<bool>(typeof(LensSettings), lens, "IsPhysicalCamera");
+ SensorSize = AccessProperty<Vector2>(typeof(LensSettings), lens, "SensorSize");
+
+ List<GUIContent> options = new List<GUIContent>();
+ CinemachineLensPresets presets = CinemachineLensPresets.InstanceIfExists;
+ if (presets != null)
+ for (int i = 0; i < presets.m_Presets.Length; ++i)
+ options.Add(new GUIContent(presets.m_Presets[i].m_Name));
+ options.Add(new GUIContent("Edit Presets..."));
+ m_PresetOptions = options.ToArray();
+
+ options.Clear();
+ if (presets != null)
+ for (int i = 0; i < presets.m_PhysicalPresets.Length; ++i)
+ options.Add(new GUIContent(presets.m_PhysicalPresets[i].m_FocalLength.ToString() + "mm"));
+ options.Add(new GUIContent("Edit Presets..."));
+ m_PhysicalPresetOptions = options.ToArray();
+ }
+
+ public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+ {
+ // Cache it here because it's called less often - less garbage
+ CacheABunchOfStuff(property);
+
+ float height = EditorGUIUtility.singleLineHeight + vSpace;
+ if (property.isExpanded)
+ height *= IsPhysical ? 6 : 5;
+ return height - vSpace;
+ }
+
+ static T AccessProperty<T>(Type type, object obj, string memberName)
+ {
+ if (string.IsNullOrEmpty(memberName) || (type == null))
+ return default(T);
+
+ System.Reflection.BindingFlags bindingFlags = System.Reflection.BindingFlags.Public;
+ if (obj != null)
+ bindingFlags |= System.Reflection.BindingFlags.Instance;
+ else
+ bindingFlags |= System.Reflection.BindingFlags.Static;
+
+ PropertyInfo pi = type.GetProperty(memberName, bindingFlags);
+ if ((pi != null) && (pi.PropertyType == typeof(T)))
+ return (T)pi.GetValue(obj, null);
+ else
+ return default(T);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 2449eb616c871d044adce04ac98030a6
+timeCreated: 1496951835
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(NoiseSettingsPropertyAttribute))]
+ internal sealed class NoiseSettingsPropertyDrawer : PropertyDrawer
+ {
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ RebuildProfileList();
+
+ float iconSize = rect.height + 4;
+ rect.width -= iconSize;
+ int preset = sNoisePresets.IndexOf((NoiseSettings)property.objectReferenceValue);
+ preset = EditorGUI.Popup(rect, label, preset, sNoisePresetNames);
+ string labelText = label.text;
+ NoiseSettings newProfile = preset < 0 ? null : sNoisePresets[preset] as NoiseSettings;
+ if ((NoiseSettings)property.objectReferenceValue != newProfile)
+ {
+ property.objectReferenceValue = newProfile;
+ property.serializedObject.ApplyModifiedProperties();
+ }
+ rect.x += rect.width; rect.width = iconSize; rect.height = iconSize;
+ if (GUI.Button(rect, EditorGUIUtility.IconContent("_Popup"), GUI.skin.label))
+ {
+ GenericMenu menu = new GenericMenu();
+ if (property.objectReferenceValue != null)
+ {
+ menu.AddItem(new GUIContent("Edit"), false, ()
+ => Selection.activeObject = property.objectReferenceValue);
+ menu.AddItem(new GUIContent("Clone"), false, () =>
+ {
+ NoiseSettings pp = CreateProfile(
+ property, labelText,
+ (NoiseSettings)property.objectReferenceValue);
+ if (pp != null)
+ {
+ property.objectReferenceValue = pp;
+ property.serializedObject.ApplyModifiedProperties();
+ InvalidateProfileList();
+ }
+ });
+ menu.AddItem(new GUIContent("Locate"), false, ()
+ => EditorGUIUtility.PingObject(property.objectReferenceValue));
+ }
+ menu.AddItem(new GUIContent("New"), false, () =>
+ {
+ //Undo.RecordObject(Target, "Change Noise Profile");
+ NoiseSettings pp = CreateProfile(property, labelText, null);
+ if (pp != null)
+ {
+ property.objectReferenceValue = pp;
+ property.serializedObject.ApplyModifiedProperties();
+ InvalidateProfileList();
+ }
+ });
+ menu.ShowAsContext();
+ }
+ }
+
+ static List<ScriptableObject> sNoisePresets;
+ static GUIContent[] sNoisePresetNames;
+ static float sLastPresetRebuildTime = 0;
+
+ public static void InvalidateProfileList()
+ {
+ sNoisePresets = null;
+ sNoisePresetNames = null;
+ }
+
+ static void RebuildProfileList()
+ {
+ if (sLastPresetRebuildTime < Time.realtimeSinceStartup - 5)
+ InvalidateProfileList();
+ if (sNoisePresets != null && sNoisePresetNames != null)
+ return;
+
+ sNoisePresets = FindAssetsByType<NoiseSettings>();
+#if UNITY_2018_1_OR_NEWER
+ InspectorUtility.AddAssetsFromPackageSubDirectory(
+ typeof(NoiseSettings), sNoisePresets, "Presets/Noise");
+#endif
+ sNoisePresets.Insert(0, null);
+ List<GUIContent> presetNameList = new List<GUIContent>();
+ foreach (var n in sNoisePresets)
+ presetNameList.Add(new GUIContent((n == null) ? "(none)" : n.name));
+ sNoisePresetNames = presetNameList.ToArray();
+ sLastPresetRebuildTime = Time.realtimeSinceStartup;
+ }
+
+ static List<ScriptableObject> FindAssetsByType<T>() where T : UnityEngine.Object
+ {
+ List<ScriptableObject> assets = new List<ScriptableObject>();
+ string[] guids = AssetDatabase.FindAssets(string.Format("t:{0}", typeof(T)));
+ for (int i = 0; i < guids.Length; i++)
+ {
+ string assetPath = AssetDatabase.GUIDToAssetPath(guids[i]);
+ ScriptableObject asset = AssetDatabase.LoadAssetAtPath<T>(assetPath) as ScriptableObject;
+ if (asset != null)
+ assets.Add(asset);
+ }
+ return assets;
+ }
+
+ NoiseSettings CreateProfile(SerializedProperty property, string label, NoiseSettings copyFrom)
+ {
+ string path = GetObjectName(property) + " " + label;
+ path = EditorUtility.SaveFilePanelInProject(
+ "Create Noise Profile asset", path, "asset",
+ "This asset will generate a procedural noise signal");
+ if (!string.IsNullOrEmpty(path))
+ {
+ NoiseSettings profile = null;
+ if (copyFrom != null)
+ {
+ string fromPath = AssetDatabase.GetAssetPath(copyFrom);
+ if (AssetDatabase.CopyAsset(fromPath, path))
+ {
+ profile = AssetDatabase.LoadAssetAtPath(
+ path, typeof(NoiseSettings)) as NoiseSettings;
+ }
+ }
+ else
+ {
+ profile = ScriptableObjectUtility.CreateAt(
+ typeof(NoiseSettings), path) as NoiseSettings;
+ }
+ AssetDatabase.SaveAssets();
+ AssetDatabase.Refresh();
+ return profile;
+ }
+ return null;
+ }
+
+ static string GetObjectName(SerializedProperty property)
+ {
+ // A little hacky here, as we favour virtual cameras...
+ var obj = property.serializedObject.targetObject;
+ GameObject go = obj as GameObject;
+ if (go == null)
+ {
+ var component = obj as Component;
+ if (component != null)
+ go = component.gameObject;
+ }
+ if (go != null)
+ {
+ var vcam = go.GetComponentInParent<CinemachineVirtualCameraBase>();
+ if (vcam != null)
+ return vcam.Name;
+ return go.name;
+ }
+ return obj.name;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 7d0d800d47186f0468d962ccf338ab97
+timeCreated: 1518034045
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ [CustomPropertyDrawer(typeof(OrbitalTransposerHeadingPropertyAttribute))]
+ internal sealed class OrbitalTransposerHeadingPropertyDrawer : PropertyDrawer
+ {
+ const int vSpace = 2;
+ bool mExpanded = true;
+ CinemachineOrbitalTransposer.Heading def = new CinemachineOrbitalTransposer.Heading(); // to access name strings
+
+ public override void OnGUI(Rect rect, SerializedProperty property, GUIContent label)
+ {
+ float height = EditorGUIUtility.singleLineHeight;
+ rect.height = height;
+ mExpanded = EditorGUI.Foldout(rect, mExpanded, label, true);
+ if (mExpanded)
+ {
+ ++EditorGUI.indentLevel;
+
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.m_Definition));
+
+ if (IsVelocityMode(property))
+ {
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.m_VelocityFilterStrength));
+ }
+
+ rect.y += height + vSpace;
+ EditorGUI.PropertyField(rect, property.FindPropertyRelative(() => def.m_Bias));
+
+ --EditorGUI.indentLevel;
+ }
+ }
+
+ public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+ {
+ float height = EditorGUIUtility.singleLineHeight + vSpace;
+ if (mExpanded)
+ height *= IsVelocityMode(property) ? 4 : 3;
+ return height;
+ }
+
+ bool IsVelocityMode(SerializedProperty property)
+ {
+ var mode = property.FindPropertyRelative(() => def.m_Definition);
+ var value = (CinemachineOrbitalTransposer.Heading.HeadingDefinition)
+ (System.Enum.GetValues(typeof(CinemachineOrbitalTransposer.Heading.HeadingDefinition))).GetValue(mode.enumValueIndex);
+ return value == CinemachineOrbitalTransposer.Heading.HeadingDefinition.Velocity
+ || value == CinemachineOrbitalTransposer.Heading.HeadingDefinition.PositionDelta;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: cd1b3b6848c215f4cba3ace2c38f9bce
+timeCreated: 1514911474
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 99ab3e8b62cb69145b760fc81e2d18d6
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#include "StdLib.hlsl"
+
+RWStructuredBuffer<uint4> _WaveformBuffer;
+Texture2D<float4> _Source;
+SamplerState sampler_Source;
+
+cbuffer name
+{
+ float4 _Params; // x: source width, y: source height, z: linear, w: histogramResolution
+};
+
+#if defined SHADER_API_GLES3
+ #define GROUP_SIZE 128
+ #define GROUP_SIZE_X 16
+ #define GROUP_SIZE_Y 8
+#else
+ #define GROUP_SIZE 256
+ #define GROUP_SIZE_X 16
+ #define GROUP_SIZE_Y 16
+#endif
+
+half3 LinearToSRGB(half3 c)
+{
+ half3 sRGBLo = c * 12.92;
+ half3 sRGBHi = (PositivePow(c, half3(1.0 / 2.4, 1.0 / 2.4, 1.0 / 2.4)) * 1.055) - 0.055;
+ half3 sRGB = (c <= 0.0031308) ? sRGBLo : sRGBHi;
+ return sRGB;
+}
+
+#pragma kernel KCMWaveformGather
+[numthreads(1, GROUP_SIZE, 1)]
+void KCMWaveformGather(uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+ // Gather local group histogram
+ if (dispatchThreadId.x < uint(_Params.x) && dispatchThreadId.y < uint(_Params.y))
+ {
+ float3 color = _Source[dispatchThreadId].rgb;
+ color = saturate(color);
+
+ // We want a gamma-corrected histogram (like Photoshop & all)
+ if (_Params.z > 0)
+ color = LinearToSRGB(color);
+
+ // Convert channel values to histogram bins
+ uint3 idx = (uint3)(round(color * (_Params.w - 1)));
+ idx += dispatchThreadId.x * _Params.w;
+
+ if (idx.x > 0u) InterlockedAdd(_WaveformBuffer[idx.x].x, 1u); // Red
+ if (idx.y > 0u) InterlockedAdd(_WaveformBuffer[idx.y].y, 1u); // Green
+ if (idx.z > 0u) InterlockedAdd(_WaveformBuffer[idx.z].z, 1u); // Blue
+ }
+}
+
+#pragma kernel KCMWaveformClear
+[numthreads(GROUP_SIZE_X, GROUP_SIZE_Y, 1)]
+void KCMWaveformClear(uint2 dispatchThreadId : SV_DispatchThreadID)
+{
+ if (dispatchThreadId.x < uint(_Params.x) && dispatchThreadId.y < uint(_Params.w))
+ _WaveformBuffer[dispatchThreadId.y * uint(_Params.x) + dispatchThreadId.x] = uint4(0u, 0u, 0u, 0u);
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 6dd3f00b9032de54c8784df7bdc6fdf8
+timeCreated: 1517591688
+licenseType: Pro
+ComputeShaderImporter:
+ externalObjects: {}
+ currentAPIMask: 4
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+Shader "CMWaveform"
+{
+ HLSLINCLUDE
+
+ #pragma target 4.5
+ #include "StdLib.hlsl"
+
+ StructuredBuffer<uint4> _WaveformBuffer;
+ float3 _Params; // x: buffer width, y: buffer height, z: exposure, w: unused
+
+ float3 Tonemap(float3 x, float exposure)
+ {
+ const float a = 6.2;
+ const float b = 0.5;
+ const float c = 1.7;
+ const float d = 0.06;
+ x *= exposure;
+ x = max((0.0).xxx, x - (0.004).xxx);
+ x = (x * (a * x + b)) / (x * (a * x + c) + d);
+ return x * x;
+ }
+
+ float4 Frag(VaryingsDefault i) : SV_Target
+ {
+ const float3 red = float3(1.4, 0.03, 0.02);
+ const float3 green = float3(0.02, 1.1, 0.05);
+ const float3 blue = float3(0.0, 0.25, 1.5);
+ float3 color = float3(0.0, 0.0, 0.0);
+
+ uint2 uvI = i.vertex.xy;
+ float3 w = _WaveformBuffer[uvI.x * _Params.y + uvI.y].xyz;
+
+ color += red * w.r;
+ color += green * w.g;
+ color += blue * w.b;
+ color = Tonemap(color, _Params.z);
+
+ return float4(saturate(color), 1.0);
+ }
+
+ ENDHLSL
+
+ SubShader
+ {
+ Cull Off ZWrite Off ZTest Always
+
+ Pass
+ {
+ HLSLPROGRAM
+
+ #pragma vertex VertDefault
+ #pragma fragment Frag
+
+ ENDHLSL
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: e4e5d566a8aa9914c906555a6857fcb9
+timeCreated: 1517591688
+licenseType: Pro
+ShaderImporter:
+ externalObjects: {}
+ defaultTextures: []
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 372fe04232d5ed94d8d71524616c1543
+timeCreated: 1503608963
+licenseType: Pro
+TextureImporter:
+ fileIDToRecycleName: {}
+ serializedVersion: 4
+ mipmaps:
+ mipMapMode: 0
+ enableMipMap: 1
+ sRGBTexture: 1
+ linearTexture: 0
+ fadeOut: 0
+ borderMipMap: 0
+ mipMapsPreserveCoverage: 0
+ alphaTestReferenceValue: 0.5
+ mipMapFadeDistanceStart: 1
+ mipMapFadeDistanceEnd: 3
+ bumpmap:
+ convertToNormalMap: 0
+ externalNormalMap: 0
+ heightScale: 0.25
+ normalMapFilter: 0
+ isReadable: 0
+ grayScaleToAlpha: 0
+ generateCubemap: 6
+ cubemapConvolution: 0
+ seamlessCubemap: 0
+ textureFormat: 1
+ maxTextureSize: 2048
+ textureSettings:
+ serializedVersion: 2
+ filterMode: -1
+ aniso: -1
+ mipBias: -1
+ wrapU: -1
+ wrapV: -1
+ wrapW: -1
+ nPOTScale: 1
+ lightmap: 0
+ compressionQuality: 50
+ spriteMode: 0
+ spriteExtrude: 1
+ spriteMeshType: 1
+ alignment: 0
+ spritePivot: {x: 0.5, y: 0.5}
+ spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+ spritePixelsToUnits: 100
+ alphaUsage: 1
+ alphaIsTransparency: 0
+ spriteTessellationDetail: -1
+ textureType: 0
+ textureShape: 1
+ maxTextureSizeSet: 0
+ compressionQualitySet: 0
+ textureFormatSet: 0
+ platformSettings:
+ - buildTarget: DefaultTexturePlatform
+ maxTextureSize: 2048
+ textureFormat: -1
+ textureCompression: 1
+ compressionQuality: 50
+ crunchedCompression: 0
+ allowsAlphaSplitting: 0
+ overridden: 0
+ spriteSheet:
+ serializedVersion: 2
+ sprites: []
+ outline: []
+ physicsShape: []
+ spritePackingTag:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+// Subset of PostProcessing's stdlib.hlsl
+
+#ifndef UNITY_CMWAVEFORM_STDLIB
+#define UNITY_CMWAVEFORM_STDLIB
+
+const float _RenderViewportScaleFactor = 1;
+
+#define FLT_EPSILON 1.192092896e-07 // Smallest positive number, such that 1.0 + FLT_EPSILON != 1.0
+
+float3 PositivePow(float3 base, float3 power)
+{
+ return pow(max(abs(base), float3(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
+}
+
+#if defined(UNITY_SINGLE_PASS_STEREO)
+float2 TransformStereoScreenSpaceTex(float2 uv, float w)
+{
+ float4 scaleOffset = unity_StereoScaleOffset[unity_StereoEyeIndex];
+ scaleOffset.xy *= _RenderViewportScaleFactor;
+ return uv.xy * scaleOffset.xy + scaleOffset.zw * w;
+}
+#else
+float2 TransformStereoScreenSpaceTex(float2 uv, float w)
+{
+ return uv * _RenderViewportScaleFactor;
+}
+#endif
+
+// Vertex manipulation
+float2 TransformTriangleVertexToUV(float2 vertex)
+{
+ float2 uv = (vertex + 1.0) * 0.5;
+ return uv;
+}
+
+struct AttributesDefault
+{
+ float3 vertex : POSITION;
+};
+
+struct VaryingsDefault
+{
+ float4 vertex : SV_POSITION;
+ float2 texcoord : TEXCOORD0;
+ float2 texcoordStereo : TEXCOORD1;
+};
+
+VaryingsDefault VertDefault(AttributesDefault v)
+{
+ VaryingsDefault o;
+ o.vertex = float4(v.vertex.xy, 0.0, 1.0);
+ o.texcoord = TransformTriangleVertexToUV(v.vertex.xy);
+
+#if UNITY_UV_STARTS_AT_TOP
+ o.texcoord = o.texcoord * float2(1.0, -1.0) + float2(0.0, 1.0);
+#endif
+
+ o.texcoordStereo = TransformStereoScreenSpaceTex(o.texcoord, 1.0);
+
+ return o;
+}
+
+#endif // UNITY_CMWAVEFORM_STDLIB
--- /dev/null
+fileFormatVersion: 2
+guid: f34d110791e602a418f182fbec6b699d
+timeCreated: 1517597295
+licenseType: Pro
+ShaderImporter:
+ externalObjects: {}
+ defaultTextures: []
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 5f2a108eb023faf43a809979fd3d38f2
+timeCreated: 1481660562
+licenseType: Pro
+TextureImporter:
+ fileIDToRecycleName: {}
+ serializedVersion: 4
+ mipmaps:
+ mipMapMode: 1
+ enableMipMap: 1
+ sRGBTexture: 1
+ linearTexture: 0
+ fadeOut: 0
+ borderMipMap: 0
+ mipMapsPreserveCoverage: 0
+ alphaTestReferenceValue: 0.5
+ mipMapFadeDistanceStart: 1
+ mipMapFadeDistanceEnd: 3
+ bumpmap:
+ convertToNormalMap: 0
+ externalNormalMap: 0
+ heightScale: 0.25
+ normalMapFilter: 0
+ isReadable: 0
+ grayScaleToAlpha: 0
+ generateCubemap: 6
+ cubemapConvolution: 0
+ seamlessCubemap: 0
+ textureFormat: 1
+ maxTextureSize: 2048
+ textureSettings:
+ serializedVersion: 2
+ filterMode: -1
+ aniso: -1
+ mipBias: -1
+ wrapU: -1
+ wrapV: -1
+ wrapW: -1
+ nPOTScale: 1
+ lightmap: 0
+ compressionQuality: 50
+ spriteMode: 0
+ spriteExtrude: 1
+ spriteMeshType: 1
+ alignment: 0
+ spritePivot: {x: 0.5, y: 0.5}
+ spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+ spritePixelsToUnits: 100
+ alphaUsage: 1
+ alphaIsTransparency: 0
+ spriteTessellationDetail: -1
+ textureType: 0
+ textureShape: 1
+ maxTextureSizeSet: 0
+ compressionQualitySet: 0
+ textureFormatSet: 0
+ platformSettings:
+ - buildTarget: DefaultTexturePlatform
+ maxTextureSize: 2048
+ textureFormat: -1
+ textureCompression: 1
+ compressionQuality: 50
+ crunchedCompression: 0
+ allowsAlphaSplitting: 0
+ overridden: 0
+ - buildTarget: Standalone
+ maxTextureSize: 2048
+ textureFormat: -1
+ textureCompression: 1
+ compressionQuality: 50
+ crunchedCompression: 0
+ allowsAlphaSplitting: 0
+ overridden: 0
+ spriteSheet:
+ serializedVersion: 2
+ sprites: []
+ outline: []
+ physicsShape: []
+ spritePackingTag:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 59bf6f737ca29494a8a074e4e7151fc3
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_TIMELINE
+
+using UnityEditor;
+using UnityEngine;
+using Cinemachine.Editor;
+using System.Collections.Generic;
+using UnityEditor.Timeline;
+using Cinemachine;
+
+//namespace Cinemachine.Timeline
+//{
+ [CustomEditor(typeof(CinemachineShot))]
+ internal sealed class CinemachineShotEditor : BaseEditor<CinemachineShot>
+ {
+ private static readonly GUIContent kVirtualCameraLabel
+ = new GUIContent("Virtual Camera", "The virtual camera to use for this shot");
+
+ protected override List<string> GetExcludedPropertiesInInspector()
+ {
+ List<string> excluded = base.GetExcludedPropertiesInInspector();
+ excluded.Add(FieldPath(x => x.VirtualCamera));
+ return excluded;
+ }
+
+ private void OnDisable()
+ {
+ DestroyComponentEditors();
+ }
+
+ private void OnDestroy()
+ {
+ DestroyComponentEditors();
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ SerializedProperty vcamProperty = FindProperty(x => x.VirtualCamera);
+ EditorGUI.indentLevel = 0; // otherwise subeditor layouts get screwed up
+
+ Rect rect;
+ CinemachineVirtualCameraBase vcam
+ = vcamProperty.exposedReferenceValue as CinemachineVirtualCameraBase;
+ if (vcam != null)
+ EditorGUILayout.PropertyField(vcamProperty, kVirtualCameraLabel);
+ else
+ {
+ GUIContent createLabel = new GUIContent("Create");
+ Vector2 createSize = GUI.skin.button.CalcSize(createLabel);
+
+ rect = EditorGUILayout.GetControlRect(true);
+ rect.width -= createSize.x;
+
+ EditorGUI.PropertyField(rect, vcamProperty, kVirtualCameraLabel);
+ rect.x += rect.width; rect.width = createSize.x;
+ if (GUI.Button(rect, createLabel))
+ {
+ vcam = CinemachineMenu.CreateDefaultVirtualCamera();
+ vcamProperty.exposedReferenceValue = vcam;
+ }
+ serializedObject.ApplyModifiedProperties();
+ }
+
+ EditorGUI.BeginChangeCheck();
+ DrawRemainingPropertiesInInspector();
+
+ if (vcam != null)
+ DrawSubeditors(vcam);
+
+ // by default timeline rebuilds the entire graph when something changes,
+ // but if a property of the virtual camera changes, we only need to re-evaluate the timeline.
+ // this prevents flicker on post processing updates
+ if (EditorGUI.EndChangeCheck())
+ {
+ TimelineEditor.Refresh(RefreshReason.SceneNeedsUpdate);
+ GUI.changed = false;
+ }
+ }
+
+ void DrawSubeditors(CinemachineVirtualCameraBase vcam)
+ {
+ // Create an editor for each of the cinemachine virtual cam and its components
+ GUIStyle foldoutStyle = new GUIStyle(EditorStyles.foldout) { fontStyle = FontStyle.Bold };
+ UpdateComponentEditors(vcam);
+ if (m_editors != null)
+ {
+ foreach (UnityEditor.Editor e in m_editors)
+ {
+ if (e == null || e.target == null || (e.target.hideFlags & HideFlags.HideInInspector) != 0)
+ continue;
+
+ // Separator line - how do you make a thinner one?
+ GUILayout.Box("", new GUILayoutOption[] { GUILayout.ExpandWidth(true), GUILayout.Height(1) } );
+
+ bool expanded = true;
+ if (!s_EditorExpanded.TryGetValue(e.target.GetType(), out expanded))
+ expanded = true;
+ expanded = EditorGUILayout.Foldout(
+ expanded, e.target.GetType().Name, true, foldoutStyle);
+ if (expanded)
+ e.OnInspectorGUI();
+ s_EditorExpanded[e.target.GetType()] = expanded;
+ }
+ }
+ }
+
+ CinemachineVirtualCameraBase m_cachedReferenceObject;
+ UnityEditor.Editor[] m_editors = null;
+ static Dictionary<System.Type, bool> s_EditorExpanded = new Dictionary<System.Type, bool>();
+
+ void UpdateComponentEditors(CinemachineVirtualCameraBase obj)
+ {
+ MonoBehaviour[] components = null;
+ if (obj != null)
+ components = obj.gameObject.GetComponents<MonoBehaviour>();
+ int numComponents = (components == null) ? 0 : components.Length;
+ int numEditors = (m_editors == null) ? 0 : m_editors.Length;
+ if (m_cachedReferenceObject != obj || (numComponents + 1) != numEditors)
+ {
+ DestroyComponentEditors();
+ m_cachedReferenceObject = obj;
+ if (obj != null)
+ {
+ m_editors = new UnityEditor.Editor[components.Length + 1];
+ CreateCachedEditor(obj.gameObject.GetComponent<Transform>(), null, ref m_editors[0]);
+ for (int i = 0; i < components.Length; ++i)
+ CreateCachedEditor(components[i], null, ref m_editors[i + 1]);
+ }
+ }
+ }
+
+ void DestroyComponentEditors()
+ {
+ m_cachedReferenceObject = null;
+ if (m_editors != null)
+ {
+ for (int i = 0; i < m_editors.Length; ++i)
+ {
+ if (m_editors[i] != null)
+ UnityEngine.Object.DestroyImmediate(m_editors[i]);
+ m_editors[i] = null;
+ }
+ m_editors = null;
+ }
+ }
+ }
+//}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: f24a4388d07ef494e8516cb859803e09
+timeCreated: 1484435492
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 29d58ccb958d24942bf23fafcec87c0b
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEditor;
+using System;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+using System.Linq.Expressions;
+
+namespace Cinemachine.Editor
+{
+ /// <summary>
+ /// A convenience base class for making inspector editors.
+ /// </summary>
+ /// <typeparam name="T">The class we're editing</typeparam>
+ public class BaseEditor<T> : UnityEditor.Editor where T : class
+ {
+ protected T Target { get { return target as T; } }
+
+ protected SerializedProperty FindAndExcludeProperty<TValue>(Expression<Func<T, TValue>> expr)
+ {
+ SerializedProperty p = FindProperty(expr);
+ ExcludeProperty(p.name);
+ return p;
+ }
+
+ protected SerializedProperty FindProperty<TValue>(Expression<Func<T, TValue>> expr)
+ {
+ return serializedObject.FindProperty(FieldPath(expr));
+ }
+
+ protected string FieldPath<TValue>(Expression<Func<T, TValue>> expr)
+ {
+ return ReflectionHelpers.GetFieldPath(expr);
+ }
+
+ protected virtual List<string> GetExcludedPropertiesInInspector()
+ {
+ var excluded = new List<string>() { "m_Script" };
+ if (mAdditionalExcluded != null)
+ excluded.AddRange(mAdditionalExcluded);
+ return excluded;
+ }
+
+ List<string> mAdditionalExcluded;
+ protected void ExcludeProperty(string propertyName)
+ {
+ if (mAdditionalExcluded == null)
+ mAdditionalExcluded = new List<string>();
+ mAdditionalExcluded.Add(propertyName);
+ }
+
+ public override void OnInspectorGUI()
+ {
+ BeginInspector();
+ DrawRemainingPropertiesInInspector();
+ }
+
+ protected virtual void BeginInspector()
+ {
+ mAdditionalExcluded = null;
+ serializedObject.Update();
+ }
+
+ protected virtual void DrawPropertyInInspector(SerializedProperty p)
+ {
+ List<string> excluded = GetExcludedPropertiesInInspector();
+ if (!excluded.Contains(p.name))
+ {
+ EditorGUI.BeginChangeCheck();
+ EditorGUILayout.PropertyField(p);
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+ ExcludeProperty(p.name);
+ }
+ }
+
+ protected void DrawRemainingPropertiesInInspector()
+ {
+ EditorGUI.BeginChangeCheck();
+ DrawPropertiesExcluding(serializedObject, GetExcludedPropertiesInInspector().ToArray());
+ if (EditorGUI.EndChangeCheck())
+ serializedObject.ApplyModifiedProperties();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 15ef94834d9e4aa44ac8fe619843346b
+timeCreated: 1506620939
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using UnityEditor;
+using System.Collections.Generic;
+
+namespace Cinemachine.Editor
+{
+ /// <summary>
+ /// User-definable named presets for lenses. This is a Singleton asset, available in editor only
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public sealed class CinemachineLensPresets : ScriptableObject
+ {
+ private static CinemachineLensPresets sInstance = null;
+ private static bool alreadySearched = false;
+
+ /// <summary>Get the singleton instance of this object, or null if it doesn't exist</summary>
+ public static CinemachineLensPresets InstanceIfExists
+ {
+ get
+ {
+ if (!alreadySearched)
+ {
+ alreadySearched = true;
+ var guids = AssetDatabase.FindAssets("t:CinemachineLensPresets");
+ for (int i = 0; i < guids.Length && sInstance == null; ++i)
+ sInstance = AssetDatabase.LoadAssetAtPath<CinemachineLensPresets>(
+ AssetDatabase.GUIDToAssetPath(guids[i]));
+ }
+ return sInstance;
+ }
+ }
+
+ /// <summary>Get the singleton instance of this object. Creates asset if nonexistant</summary>
+ public static CinemachineLensPresets Instance
+ {
+ get
+ {
+ if (InstanceIfExists == null)
+ {
+ string newAssetPath = EditorUtility.SaveFilePanelInProject(
+ "Create Lens Presets asset", "CinemachineLensPresets", "asset",
+ "This editor-only file will contain the lens presets for this project");
+ if (!string.IsNullOrEmpty(newAssetPath))
+ {
+ sInstance = CreateInstance<CinemachineLensPresets>();
+ // Create some sample presets
+ List<Preset> defaults = new List<Preset>();
+ defaults.Add(new Preset() { m_Name = "21mm", m_FieldOfView = 60f } );
+ defaults.Add(new Preset() { m_Name = "35mm", m_FieldOfView = 38f } );
+ defaults.Add(new Preset() { m_Name = "58mm", m_FieldOfView = 23f } );
+ defaults.Add(new Preset() { m_Name = "80mm", m_FieldOfView = 17f } );
+ defaults.Add(new Preset() { m_Name = "125mm", m_FieldOfView = 10f } );
+ sInstance.m_Presets = defaults.ToArray();
+ AssetDatabase.CreateAsset(sInstance, newAssetPath);
+ AssetDatabase.SaveAssets();
+ AssetDatabase.Refresh();
+ }
+ }
+ return sInstance;
+ }
+ }
+
+ /// <summary>Lens Preset</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct Preset
+ {
+ [Tooltip("Lens Name")]
+ public string m_Name;
+
+ /// <summary>
+ /// This is the camera view in vertical degrees. For cinematic people, a 50mm lens
+ /// on a super-35mm sensor would equal a 19.6 degree FOV
+ /// </summary>
+ [Range(1f, 179f)]
+ [Tooltip("This is the camera view in vertical degrees. For cinematic people, a 50mm lens on a super-35mm sensor would equal a 19.6 degree FOV")]
+ public float m_FieldOfView;
+ }
+ /// <summary>The array containing Preset definitions for nonphysical cameras</summary>
+ [Tooltip("The array containing Preset definitions, for nonphysical cameras")]
+ public Preset[] m_Presets = new Preset[0];
+
+ /// <summary>Physical Lens Preset</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct PhysicalPreset
+ {
+ /// <summary>
+ /// This is the camera focal length in mm
+ /// </summary>
+ [Tooltip("This is the camera focal length in mm")]
+ public float m_FocalLength;
+ }
+
+ /// <summary>The array containing Preset definitions, for physical cameras</summary>
+ [Tooltip("The array containing Preset definitions, for physical cameras")]
+ public PhysicalPreset[] m_PhysicalPresets = new PhysicalPreset[0];
+
+ /// <summary>Get the index of the preset that matches the lens settings</summary>
+ /// <returns>the preset index, or -1 if no matching preset</returns>
+ public int GetMatchingPreset(float fov)
+ {
+ for (int i = 0; i < m_Presets.Length; ++i)
+ if (Mathf.Approximately(m_Presets[i].m_FieldOfView, fov))
+ return i;
+ return -1;
+ }
+
+ /// <summary>Get the index of the physical preset that matches the lens settings</summary>
+ /// <returns>the preset index, or -1 if no matching preset</returns>
+ public int GetMatchingPhysicalPreset(float focalLength)
+ {
+ for (int i = 0; i < m_PhysicalPresets.Length; ++i)
+ if (Mathf.Approximately(m_PhysicalPresets[i].m_FocalLength, focalLength))
+ return i;
+ return -1;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 87edaa385191f4e43ac1e2831a02159f
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System;
+
+namespace Cinemachine.Editor
+{
+ /// <summary>
+ /// Helper for drawing embedded asset editors
+ /// </summary>
+ internal class EmbeddeAssetEditor<T> where T : ScriptableObject
+ {
+ /// <summary>
+ /// Create in OnEnable()
+ /// </summary>
+ public EmbeddeAssetEditor(string propertyName, UnityEditor.Editor owner)
+ {
+ m_PropertyName = propertyName;
+ m_Owner = owner;
+ m_DoVersionControlChecks = UnityEditor.VersionControl.Provider.isActive;
+ m_CreateButtonGUIContent = new GUIContent(
+ "Create Asset", "Create a new shared settings asset");
+ }
+
+ /// <summary>
+ /// Called after the asset editor is created, in case it needs
+ /// to be customized
+ /// </summary>
+ public OnCreateEditorDelegate OnCreateEditor;
+ public delegate void OnCreateEditorDelegate(UnityEditor.Editor editor);
+
+ /// <summary>
+ /// Called when the asset being edited was changed by the user.
+ /// </summary>
+ public OnChangedDelegate OnChanged;
+ public delegate void OnChangedDelegate(T obj);
+
+ /// <summary>
+ /// Free the resources in OnDisable()
+ /// </summary>
+ public void OnDisable()
+ {
+ DestroyEditor();
+ m_Owner = null;
+ }
+
+ /// <summary>
+ /// Customize this after creation if you want
+ /// </summary>
+ public GUIContent m_CreateButtonGUIContent;
+
+ private string m_PropertyName;
+ private UnityEditor.Editor m_Editor = null;
+ private UnityEditor.Editor m_Owner = null;
+ private bool m_DoVersionControlChecks = false;
+
+ const int kIndentOffset = 6;
+
+ /// <summary>
+ /// Call this from OnInspectorGUI. Will draw the asset reference field, and
+ /// the embedded editor, or a Create Asset button, if no asset is set.
+ /// </summary>
+ public void DrawEditorCombo(
+ string title, string defaultName, string extension, string message,
+ string showLabel, bool indent)
+ {
+ SerializedProperty property = m_Owner.serializedObject.FindProperty(m_PropertyName);
+ if (m_Editor == null)
+ UpdateEditor();
+ if (m_Editor == null)
+ AssetFieldWithCreateButton(property, title, defaultName, extension, message);
+ else
+ {
+ EditorGUILayout.BeginVertical(GUI.skin.box);
+ Rect rect = EditorGUILayout.GetControlRect(true);
+ rect.height = EditorGUIUtility.singleLineHeight;
+ EditorGUI.BeginChangeCheck();
+ EditorGUI.PropertyField(rect, property);
+ if (EditorGUI.EndChangeCheck())
+ {
+ m_Owner.serializedObject.ApplyModifiedProperties();
+ UpdateEditor();
+ }
+ if (m_Editor != null)
+ {
+ Rect foldoutRect = new Rect(
+ rect.x - kIndentOffset, rect.y, rect.width + kIndentOffset, rect.height);
+ property.isExpanded = EditorGUI.Foldout(
+ foldoutRect, property.isExpanded, GUIContent.none, true);
+
+ UnityEditor.VersionControl.Asset targetAsset
+ = UnityEditor.VersionControl.Provider.GetAssetByPath(
+ AssetDatabase.GetAssetPath(m_Editor.target));
+ bool isLockedFile = m_DoVersionControlChecks
+ && !targetAsset.IsOneOfStates(new[] {
+ UnityEditor.VersionControl.Asset.States.CheckedOutLocal,
+ UnityEditor.VersionControl.Asset.States.AddedLocal,
+ });
+
+ GUI.enabled = !isLockedFile;
+ if (property.isExpanded)
+ {
+ EditorGUILayout.Separator();
+ EditorGUILayout.HelpBox(
+ "This is a shared asset. Changes made here will apply to all users of this asset.",
+ MessageType.Info);
+ EditorGUI.BeginChangeCheck();
+ if (indent)
+ ++EditorGUI.indentLevel;
+ m_Editor.OnInspectorGUI();
+ if (indent)
+ --EditorGUI.indentLevel;
+ if (EditorGUI.EndChangeCheck() && (OnChanged != null))
+ OnChanged(property.objectReferenceValue as T);
+ }
+ GUI.enabled = true;
+ if (isLockedFile && GUILayout.Button("Check out"))
+ {
+ UnityEditor.VersionControl.Provider.Checkout(
+ targetAsset, UnityEditor.VersionControl.CheckoutMode.Both);
+ }
+ }
+ EditorGUILayout.EndVertical();
+ }
+ }
+
+ private void AssetFieldWithCreateButton(
+ SerializedProperty property,
+ string title, string defaultName, string extension, string message)
+ {
+ EditorGUI.BeginChangeCheck();
+
+ float hSpace = 5;
+ float buttonWidth = GUI.skin.button.CalcSize(m_CreateButtonGUIContent).x;
+ Rect r = EditorGUILayout.GetControlRect(true);
+ r.width -= buttonWidth + hSpace;
+ EditorGUI.PropertyField(r, property);
+ r.x += r.width + hSpace; r.width = buttonWidth;
+ if (GUI.Button(r, m_CreateButtonGUIContent))
+ {
+ string newAssetPath = EditorUtility.SaveFilePanelInProject(
+ title, defaultName, extension, message);
+ if (!string.IsNullOrEmpty(newAssetPath))
+ {
+ T asset = ScriptableObjectUtility.CreateAt<T>(newAssetPath);
+ property.objectReferenceValue = asset;
+ m_Owner.serializedObject.ApplyModifiedProperties();
+ }
+ }
+ if (EditorGUI.EndChangeCheck())
+ {
+ m_Owner.serializedObject.ApplyModifiedProperties();
+ UpdateEditor();
+ }
+ }
+
+ public void DestroyEditor()
+ {
+ if (m_Editor != null)
+ {
+ UnityEngine.Object.DestroyImmediate(m_Editor);
+ m_Editor = null;
+ }
+ }
+
+ public void UpdateEditor()
+ {
+ DestroyEditor();
+ SerializedProperty property = m_Owner.serializedObject.FindProperty(m_PropertyName);
+ if (property.objectReferenceValue != null)
+ {
+ m_Editor = UnityEditor.Editor.CreateEditor(property.objectReferenceValue);
+ if (OnCreateEditor != null)
+ OnCreateEditor(m_Editor);
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: d30409ab90458e5409807c8b0274ac9c
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+namespace Cinemachine.Editor
+{
+ public class InspectorUtility
+ {
+ /// <summary>Put multiple properties on a single inspector line, with
+ /// optional label overrides. Passing null as a label (or sublabel) override will
+ /// cause the property's displayName to be used as a label. For no label at all,
+ /// pass GUIContent.none.</summary>
+ public static void MultiPropertyOnLine(
+ Rect rect,
+ GUIContent label,
+ SerializedProperty[] props, GUIContent[] subLabels)
+ {
+ if (props == null || props.Length == 0)
+ return;
+
+ const int hSpace = 2;
+ int indentLevel = EditorGUI.indentLevel;
+ float labelWidth = EditorGUIUtility.labelWidth;
+
+ float totalSubLabelWidth = 0;
+ int numBoolColumns = 0;
+ List<GUIContent> actualLabels = new List<GUIContent>();
+ for (int i = 0; i < props.Length; ++i)
+ {
+ GUIContent sublabel = new GUIContent(props[i].displayName, props[i].tooltip);
+ if (subLabels != null && subLabels.Length > i && subLabels[i] != null)
+ sublabel = subLabels[i];
+ actualLabels.Add(sublabel);
+ totalSubLabelWidth += GUI.skin.label.CalcSize(sublabel).x;
+ if (i > 0)
+ totalSubLabelWidth += hSpace;
+ // Special handling for toggles, or it looks stupid
+ if (props[i].propertyType == SerializedPropertyType.Boolean)
+ {
+ totalSubLabelWidth += rect.height;
+ ++numBoolColumns;
+ }
+ }
+
+ float subFieldWidth = rect.width - labelWidth - totalSubLabelWidth;
+ float numCols = props.Length - numBoolColumns;
+ float colWidth = numCols == 0 ? 0 : subFieldWidth / numCols;
+
+ // Main label. If no first sublabel, then main label must take on that
+ // role, for mouse dragging value-scrolling support
+ int subfieldStartIndex = 0;
+ if (label == null)
+ label = new GUIContent(props[0].displayName, props[0].tooltip);
+ if (actualLabels[0] != GUIContent.none)
+ rect = EditorGUI.PrefixLabel(rect, label);
+ else
+ {
+ rect.width = labelWidth + colWidth;
+ EditorGUI.PropertyField(rect, props[0], label);
+ rect.x += rect.width + hSpace;
+ subfieldStartIndex = 1;
+ }
+
+ for (int i = subfieldStartIndex; i < props.Length; ++i)
+ {
+ EditorGUI.indentLevel = 0;
+ EditorGUIUtility.labelWidth = GUI.skin.label.CalcSize(actualLabels[i]).x;
+ if (props[i].propertyType == SerializedPropertyType.Boolean)
+ {
+ rect.width = EditorGUIUtility.labelWidth + rect.height;
+ props[i].boolValue = EditorGUI.ToggleLeft(rect, actualLabels[i], props[i].boolValue);
+ }
+ else
+ {
+ rect.width = EditorGUIUtility.labelWidth + colWidth;
+ EditorGUI.PropertyField(rect, props[i], actualLabels[i]);
+ }
+ rect.x += rect.width + hSpace;
+ }
+
+ EditorGUIUtility.labelWidth = labelWidth;
+ EditorGUI.indentLevel = indentLevel;
+ }
+
+ public static AnimationCurve NormalizeCurve(AnimationCurve curve)
+ {
+ Keyframe[] keys = curve.keys;
+ if (keys.Length > 0)
+ {
+ float minTime = keys[0].time;
+ float maxTime = minTime;
+ float minVal = keys[0].value;
+ float maxVal = minVal;
+ for (int i = 0; i < keys.Length; ++i)
+ {
+ minTime = Mathf.Min(minTime, keys[i].time);
+ maxTime = Mathf.Max(maxTime, keys[i].time);
+ minVal = Mathf.Min(minVal, keys[i].value);
+ maxVal = Mathf.Max(maxVal, keys[i].value);
+ }
+ float range = maxTime - minTime;
+ float timeScale = range < 0.0001f ? 1 : 1 / range;
+ range = maxVal - minVal;
+ float valScale = range < 1 ? 1 : 1 / range;
+ float valOffset = 0;
+ if (range < 1)
+ {
+ if (minVal > 0 && minVal + range <= 1)
+ valOffset = minVal;
+ else
+ valOffset = 1 - range;
+ }
+ for (int i = 0; i < keys.Length; ++i)
+ {
+ keys[i].time = (keys[i].time - minTime) * timeScale;
+ keys[i].value = ((keys[i].value - minVal) * valScale) + valOffset;
+ }
+ curve.keys = keys;
+ }
+ return curve;
+ }
+
+ public static string NicifyClassName(string name)
+ {
+ if (name.StartsWith("Cinemachine"))
+ name = name.Substring(11); // Trim the prefix
+ return ObjectNames.NicifyVariableName(name);
+ }
+
+ public static void AddAssetsFromPackageSubDirectory(
+ Type type, List<ScriptableObject> assets, string path)
+ {
+ try
+ {
+ path = "/" + path;
+ var info = new DirectoryInfo(ScriptableObjectUtility.CinemachineInstallPath + path);
+ path = ScriptableObjectUtility.kPackageRoot + path + "/";
+ var fileInfo = info.GetFiles();
+ foreach (var file in fileInfo)
+ {
+ if (file.Extension != ".asset")
+ continue;
+ string name = path + file.Name;
+ ScriptableObject a = AssetDatabase.LoadAssetAtPath(name, type) as ScriptableObject;
+ if (a != null)
+ assets.Add(a);
+ }
+ }
+ catch
+ {
+ }
+ }
+
+ // Temporarily here
+ public static GameObject CreateGameObject(string name, params Type[] types)
+ {
+#if UNITY_2018_3_OR_NEWER
+ return ObjectFactory.CreateGameObject(name, types);
+#else
+ return new GameObject(name, types);
+#endif
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: ebb13519e7af50b4dbc59d78b3bb6a32
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Reflection;
+using System.Text;
+
+namespace Cinemachine.Utility
+{
+ /// <summary>An ad-hoc collection of helpers for reflection, used by Cinemachine
+ /// or its editor tools in various places</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.Undoc)]
+ public static class ReflectionHelpers
+ {
+ /// <summary>Copy the fields from one object to another</summary>
+ /// <param name="src">The source object to copy from</param>
+ /// <param name="dst">The destination object to copy to</param>
+ /// <param name="bindingAttr">The mask to filter the attributes.
+ /// Only those fields that get caught in the filter will be copied</param>
+ public static void CopyFields(
+ System.Object src, System.Object dst,
+ System.Reflection.BindingFlags bindingAttr
+ = System.Reflection.BindingFlags.Public
+ | System.Reflection.BindingFlags.NonPublic
+ | System.Reflection.BindingFlags.Instance)
+ {
+ if (src != null && dst != null)
+ {
+ Type type = src.GetType();
+ FieldInfo[] fields = type.GetFields(bindingAttr);
+ for (int i = 0; i < fields.Length; ++i)
+ if (!fields[i].IsStatic)
+ fields[i].SetValue(dst, fields[i].GetValue(src));
+ }
+ }
+
+ /// <summary>Search the assembly for all types that match a predicate</summary>
+ /// <param name="assembly">The assembly to search</param>
+ /// <param name="predicate">The type to look for</param>
+ /// <returns>A list of types found in the assembly that inherit from the predicate</returns>
+ public static IEnumerable<Type> GetTypesInAssembly(
+ Assembly assembly, Predicate<Type> predicate)
+ {
+ if (assembly == null)
+ return null;
+
+ Type[] types = new Type[0];
+ try
+ {
+ types = assembly.GetTypes();
+ }
+ catch (Exception)
+ {
+ // Can't load the types in this assembly
+ }
+ types = (from t in types
+ where t != null && predicate(t)
+ select t).ToArray();
+ return types;
+ }
+
+ /// <summary>Get a type from a name</summary>
+ /// <param name="typeName">The name of the type to search for</param>
+ /// <returns>The type matching the name, or null if not found</returns>
+ public static Type GetTypeInAllDependentAssemblies(string typeName)
+ {
+ foreach (Type type in GetTypesInAllDependentAssemblies(t => t.Name == typeName))
+ return type;
+ return null;
+ }
+
+ /// <summary>Search all assemblies for all types that match a predicate</summary>
+ /// <param name="predicate">The type to look for</param>
+ /// <returns>A list of types found in the assembly that inherit from the predicate</returns>
+ public static IEnumerable<Type> GetTypesInAllDependentAssemblies(Predicate<Type> predicate)
+ {
+ List<Type> foundTypes = new List<Type>(100);
+ Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
+ string definedIn = typeof(CinemachineComponentBase).Assembly.GetName().Name;
+ foreach (Assembly assembly in assemblies)
+ {
+ // Note that we have to call GetName().Name. Just GetName() will not work.
+ if ((!assembly.GlobalAssemblyCache)
+ && ((assembly.GetName().Name == definedIn)
+ || assembly.GetReferencedAssemblies().Any(a => a.Name == definedIn)))
+ try
+ {
+ foreach (Type foundType in GetTypesInAssembly(assembly, predicate))
+ foundTypes.Add(foundType);
+ }
+ catch (Exception) {} // Just skip uncooperative assemblies
+ }
+ return foundTypes;
+ }
+#if false
+ /// <summary>call GetTypesInAssembly() for all assemblies that match a predicate</summary>
+ /// <param name="assemblyPredicate">Which assemblies to search</param>
+ /// <param name="predicate">What type to look for</param>
+ public static IEnumerable<Type> GetTypesInLoadedAssemblies(
+ Predicate<Assembly> assemblyPredicate, Predicate<Type> predicate)
+ {
+ Assembly[] assemblies = System.AppDomain.CurrentDomain.GetAssemblies();
+ assemblies = assemblies.Where((Assembly assembly)
+ => { return assemblyPredicate(assembly); }).OrderBy((Assembly ass)
+ => { return ass.FullName; }).ToArray();
+
+ List<Type> foundTypes = new List<Type>(100);
+ foreach (Assembly assembly in assemblies)
+ {
+ foreach (Type foundType in GetTypesInAssembly(assembly, predicate))
+ foundTypes.Add(foundType);
+ }
+
+ return foundTypes;
+ }
+
+ /// <summary>Is a type defined and visible</summary>
+ /// <param name="fullname">Fullly-qualified type name</param>
+ /// <returns>true if the type exists</returns>
+ public static bool TypeIsDefined(string fullname)
+ {
+ Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
+ foreach (Assembly assembly in assemblies)
+ {
+ try
+ {
+ foreach (var type in assembly.GetTypes())
+ if (type.FullName == fullname)
+ return true;
+ }
+ catch (System.Exception) {} // Just skip uncooperative assemblies
+ }
+ return false;
+ }
+#endif
+ /// <summary>Cheater extension to access internal field of an object</summary>
+ /// <param name="type">The type of the field</param>
+ /// <param name="obj">The object to access</param>
+ /// <param name="memberName">The string name of the field to access</param>
+ /// <returns>The value of the field in the objects</returns>
+ public static T AccessInternalField<T>(this Type type, object obj, string memberName)
+ {
+ if (string.IsNullOrEmpty(memberName) || (type == null))
+ return default(T);
+
+ System.Reflection.BindingFlags bindingFlags = System.Reflection.BindingFlags.NonPublic;
+ if (obj != null)
+ bindingFlags |= System.Reflection.BindingFlags.Instance;
+ else
+ bindingFlags |= System.Reflection.BindingFlags.Static;
+
+ FieldInfo field = type.GetField(memberName, bindingFlags);
+ if ((field != null) && (field.FieldType == typeof(T)))
+ return (T)field.GetValue(obj);
+ else
+ return default(T);
+ }
+
+#if false
+ /// <summary>Cheater extension to access internal property of an object</summary>
+ /// <param name="type">The type of the field</param>
+ /// <param name="obj">The object to access</param>
+ /// <param name="memberName">The string name of the field to access</param>
+ /// <returns>The value of the field in the objects</returns>
+ public static T AccessInternalProperty<T>(this Type type, object obj, string memberName)
+ {
+ if (string.IsNullOrEmpty(memberName) || (type == null))
+ return default(T);
+
+ System.Reflection.BindingFlags bindingFlags = System.Reflection.BindingFlags.NonPublic;
+ if (obj != null)
+ bindingFlags |= System.Reflection.BindingFlags.Instance;
+ else
+ bindingFlags |= System.Reflection.BindingFlags.Static;
+
+ PropertyInfo pi = type.GetProperty(memberName, bindingFlags);
+ if ((pi != null) && (pi.PropertyType == typeof(T)))
+ return (T)pi.GetValue(obj, null);
+ else
+ return default(T);
+ }
+#endif
+
+ /// <summary>Get the object owner of a field. This method processes
+ /// the '.' separator to get from the object that owns the compound field
+ /// to the object that owns the leaf field</summary>
+ /// <param name="path">The name of the field, which may contain '.' separators</param>
+ /// <param name="obj">the owner of the compound field</param>
+ public static object GetParentObject(string path, object obj)
+ {
+ var fields = path.Split('.');
+ if (fields.Length == 1)
+ return obj;
+
+ var info = obj.GetType().GetField(
+ fields[0], System.Reflection.BindingFlags.Public
+ | System.Reflection.BindingFlags.NonPublic
+ | System.Reflection.BindingFlags.Instance);
+ obj = info.GetValue(obj);
+
+ return GetParentObject(string.Join(".", fields, 1, fields.Length - 1), obj);
+ }
+
+ /// <summary>Returns a string path from an expression - mostly used to retrieve serialized properties
+ /// without hardcoding the field path. Safer, and allows for proper refactoring.</summary>
+ public static string GetFieldPath<TType, TValue>(Expression<Func<TType, TValue>> expr)
+ {
+ MemberExpression me;
+ switch (expr.Body.NodeType)
+ {
+ case ExpressionType.MemberAccess:
+ me = expr.Body as MemberExpression;
+ break;
+ default:
+ throw new InvalidOperationException();
+ }
+
+ var members = new List<string>();
+ while (me != null)
+ {
+ members.Add(me.Member.Name);
+ me = me.Expression as MemberExpression;
+ }
+
+ var sb = new StringBuilder();
+ for (int i = members.Count - 1; i >= 0; i--)
+ {
+ sb.Append(members[i]);
+ if (i > 0) sb.Append('.');
+ }
+ return sb.ToString();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 8986fa27e90db314d8a3359520e7fd1a
+timeCreated: 1487370732
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace SaveDuringPlay
+{
+ /// <summary>A collection of tools for finding objects</summary>
+ internal static class ObjectTreeUtil
+ {
+ /// <summary>
+ /// Get the full name of an object, travelling up the transform parents to the root.
+ /// </summary>
+ public static string GetFullName(GameObject current)
+ {
+ if (current == null)
+ return "";
+ if (current.transform.parent == null)
+ return "/" + current.name;
+ return GetFullName(current.transform.parent.gameObject) + "/" + current.name;
+ }
+
+ /// <summary>
+ /// Will find the named object, active or inactive, from the full path.
+ /// </summary>
+ public static GameObject FindObjectFromFullName(string fullName, GameObject[] roots)
+ {
+ if (fullName == null || fullName.Length == 0 || roots == null)
+ return null;
+
+ string[] path = fullName.Split('/');
+ if (path.Length < 2) // skip leading '/'
+ return null;
+
+ Transform root = null;
+ for (int i = 0; root == null && i < roots.Length; ++i)
+ if (roots[i].name == path[1])
+ root = roots[i].transform;
+
+ if (root == null)
+ return null;
+
+ for (int i = 2; i < path.Length; ++i) // skip root
+ {
+ bool found = false;
+ for (int c = 0; c < root.childCount; ++c)
+ {
+ Transform child = root.GetChild(c);
+ if (child.name == path[i])
+ {
+ found = true;
+ root = child;
+ break;
+ }
+ }
+ if (!found)
+ return null;
+ }
+ return root.gameObject;
+ }
+
+ /// <summary>Finds all the root objects in a scene, active or not</summary>
+ public static GameObject[] FindAllRootObjectsInScene()
+ {
+ return UnityEngine.SceneManagement.SceneManager.GetActiveScene().GetRootGameObjects();
+ }
+
+
+ /// <summary>
+ /// This finds all the behaviours in scene, active or inactive, excluding prefabs
+ /// </summary>
+ public static T[] FindAllBehavioursInScene<T>() where T : MonoBehaviour
+ {
+ List<T> objectsInScene = new List<T>();
+ foreach (T b in Resources.FindObjectsOfTypeAll<T>())
+ {
+ GameObject go = b.gameObject;
+ if (go.hideFlags == HideFlags.NotEditable || go.hideFlags == HideFlags.HideAndDontSave)
+ continue;
+ if (EditorUtility.IsPersistent(go.transform.root.gameObject))
+ continue;
+ objectsInScene.Add(b);
+ }
+ return objectsInScene.ToArray();
+ }
+ }
+
+ class GameObjectFieldScanner
+ {
+ /// <summary>
+ /// Called for each leaf field. Return value should be true if action was taken.
+ /// It will be propagated back to the caller.
+ /// </summary>
+ public OnLeafFieldDelegate OnLeafField;
+ public delegate bool OnLeafFieldDelegate(string fullName, Type type, ref object value);
+
+ /// <summary>
+ /// Called for each field node, if and only if OnLeafField() for it or one
+ /// of its leaves returned true.
+ /// </summary>
+ public OnFieldValueChangedDelegate OnFieldValueChanged;
+ public delegate bool OnFieldValueChangedDelegate(
+ string fullName, FieldInfo fieldInfo, object fieldOwner, object value);
+
+ /// <summary>
+ /// Called for each field, to test whether to proceed with scanning it. Return true to scan.
+ /// </summary>
+ public FilterFieldDelegate FilterField;
+ public delegate bool FilterFieldDelegate(string fullName, FieldInfo fieldInfo);
+
+ /// <summary>
+ /// Which fields will be scanned
+ /// </summary>
+ public BindingFlags bindingFlags = BindingFlags.Public | BindingFlags.Instance;
+
+ bool ScanFields(string fullName, Type type, ref object obj)
+ {
+ bool doneSomething = false;
+
+ // Check if it's a complex type
+ bool isLeaf = true;
+ if (obj != null
+ && !typeof(Component).IsAssignableFrom(type)
+ && !typeof(ScriptableObject).IsAssignableFrom(type)
+ && !typeof(GameObject).IsAssignableFrom(type))
+ {
+ // Is it an array?
+ if (type.IsArray)
+ {
+ isLeaf = false;
+ Array array = obj as Array;
+ object arrayLength = array.Length;
+ if (OnLeafField != null && OnLeafField(
+ fullName + ".Length", arrayLength.GetType(), ref arrayLength))
+ {
+ Array newArray = Array.CreateInstance(
+ array.GetType().GetElementType(), Convert.ToInt32(arrayLength));
+ Array.Copy(array, 0, newArray, 0, Math.Min(array.Length, newArray.Length));
+ array = newArray;
+ doneSomething = true;
+ }
+ for (int i = 0; i < array.Length; ++i)
+ {
+ object element = array.GetValue(i);
+ if (ScanFields(fullName + "[" + i + "]", array.GetType().GetElementType(), ref element))
+ {
+ array.SetValue(element, i);
+ doneSomething = true;
+ }
+ }
+ if (doneSomething)
+ obj = array;
+ }
+ else
+ {
+ // Check if it's a complex type
+ FieldInfo[] fields = obj.GetType().GetFields(bindingFlags);
+ if (fields.Length > 0)
+ {
+ isLeaf = false;
+ for (int i = 0; i < fields.Length; ++i)
+ {
+ string name = fullName + "." + fields[i].Name;
+ if (FilterField == null || FilterField(name, fields[i]))
+ {
+ object fieldValue = fields[i].GetValue(obj);
+ if (ScanFields(name, fields[i].FieldType, ref fieldValue))
+ {
+ doneSomething = true;
+ if (OnFieldValueChanged != null)
+ OnFieldValueChanged(name, fields[i], obj, fieldValue);
+ }
+ }
+ }
+ }
+ }
+ }
+ // If it's a leaf field then call the leaf handler
+ if (isLeaf && OnLeafField != null)
+ if (OnLeafField(fullName, type, ref obj))
+ doneSomething = true;
+
+ return doneSomething;
+ }
+
+ public bool ScanFields(string fullName, MonoBehaviour b)
+ {
+ bool doneSomething = false;
+ FieldInfo[] fields = b.GetType().GetFields(bindingFlags);
+ if (fields.Length > 0)
+ {
+ for (int i = 0; i < fields.Length; ++i)
+ {
+ string name = fullName + "." + fields[i].Name;
+ if (FilterField == null || FilterField(name, fields[i]))
+ {
+ object fieldValue = fields[i].GetValue(b);
+ if (ScanFields(name, fields[i].FieldType, ref fieldValue))
+ doneSomething = true;
+
+ // If leaf action was taken, propagate it up to the parent node
+ if (doneSomething && OnFieldValueChanged != null)
+ OnFieldValueChanged(fullName, fields[i], b, fieldValue);
+ }
+ }
+ }
+ return doneSomething;
+ }
+
+ /// <summary>
+ /// Recursively scan the MonoBehaviours of a GameObject and its children.
+ /// For each leaf field found, call the OnFieldValue delegate.
+ /// </summary>
+ public bool ScanFields(GameObject go, string prefix = null)
+ {
+ bool doneSomething = false;
+ if (prefix == null)
+ prefix = "";
+ else if (prefix.Length > 0)
+ prefix += ".";
+
+ MonoBehaviour[] components = go.GetComponents<MonoBehaviour>();
+ for (int i = 0; i < components.Length; ++i)
+ {
+ MonoBehaviour c = components[i];
+ if (c != null && ScanFields(prefix + c.GetType().FullName + i, c))
+ doneSomething = true;
+ }
+ return doneSomething;
+ }
+ };
+
+
+ /// <summary>
+ /// Using reflection, this class scans a GameObject (and optionally its children)
+ /// and records all the field settings. This only works for "nice" field settings
+ /// within MonoBehaviours. Changes to the behaviour stack made between saving
+ /// and restoring will fool this class.
+ /// </summary>
+ class ObjectStateSaver
+ {
+ string mObjectFullPath;
+
+ Dictionary<string, string> mValues = new Dictionary<string, string>();
+
+ /// <summary>
+ /// Recursively collect all the field values in the MonoBehaviours
+ /// owned by this object and its descendants. The values are stored
+ /// in an internal dictionary.
+ /// </summary>
+ public void CollectFieldValues(GameObject go)
+ {
+ mObjectFullPath = ObjectTreeUtil.GetFullName(go);
+ GameObjectFieldScanner scanner = new GameObjectFieldScanner();
+ scanner.FilterField = FilterField;
+ scanner.OnLeafField = (string fullName, Type type, ref object value) =>
+ {
+ // Save the value in the dictionary
+ mValues[fullName] = StringFromLeafObject(value);
+ //Debug.Log(mObjectFullPath + "." + fullName + " = " + mValues[fullName]);
+ return false;
+ };
+ scanner.ScanFields(go);
+ }
+
+ public GameObject FindSavedGameObject(GameObject[] roots)
+ {
+ return ObjectTreeUtil.FindObjectFromFullName(mObjectFullPath, roots);
+ }
+ public string ObjetFullPath { get { return mObjectFullPath; } }
+
+ /// <summary>
+ /// Recursively scan the MonoBehaviours of a GameObject and its children.
+ /// For each field found, look up its value in the internal dictionary.
+ /// If it's present and its value in the dictionary differs from the actual
+ /// value in the game object, Set the GameObject's value using the value
+ /// recorded in the dictionary.
+ /// </summary>
+ public bool PutFieldValues(GameObject go, GameObject[] roots)
+ {
+ GameObjectFieldScanner scanner = new GameObjectFieldScanner();
+ scanner.FilterField = FilterField;
+ scanner.OnLeafField = (string fullName, Type type, ref object value) =>
+ {
+ // Lookup the value in the dictionary
+ string savedValue;
+ if (mValues.TryGetValue(fullName, out savedValue)
+ && StringFromLeafObject(value) != savedValue)
+ {
+ //Debug.Log("Put " + mObjectFullPath + "." + fullName + " = " + mValues[fullName]);
+ value = LeafObjectFromString(type, mValues[fullName].Trim(), roots);
+ return true; // changed
+ }
+ return false;
+ };
+ scanner.OnFieldValueChanged = (fullName, fieldInfo, fieldOwner, value) =>
+ {
+ fieldInfo.SetValue(fieldOwner, value);
+ return true;
+ };
+ return scanner.ScanFields(go);
+ }
+
+ /// Ignore fields marked with the [NoSaveDuringPlay] attribute
+ bool FilterField(string fullName, FieldInfo fieldInfo)
+ {
+ var attrs = fieldInfo.GetCustomAttributes(false);
+ foreach (var attr in attrs)
+ if (attr.GetType().Name.Contains("NoSaveDuringPlay"))
+ return false;
+ return true;
+ }
+
+ /// <summary>
+ /// Parse a string to generate an object.
+ /// Only very limited primitive object types are supported.
+ /// Enums, Vectors and most other structures are automatically supported,
+ /// because the reflection system breaks them down into their primitive components.
+ /// You can add more support here, as needed.
+ /// </summary>
+ static object LeafObjectFromString(Type type, string value, GameObject[] roots)
+ {
+ if (type == typeof(Single))
+ return float.Parse(value);
+ if (type == typeof(Double))
+ return double.Parse(value);
+ if (type == typeof(Boolean))
+ return Boolean.Parse(value);
+ if (type == typeof(string))
+ return value;
+ if (type == typeof(Int32))
+ return Int32.Parse(value);
+ if (type == typeof(UInt32))
+ return UInt32.Parse(value);
+ if (typeof(Component).IsAssignableFrom(type))
+ {
+ // Try to find the named game object
+ GameObject go = ObjectTreeUtil.FindObjectFromFullName(value, roots);
+ return (go != null) ? go.GetComponent(type) : null;
+ }
+ if (typeof(GameObject).IsAssignableFrom(type))
+ {
+ // Try to find the named game object
+ return GameObject.Find(value);
+ }
+ if (typeof(ScriptableObject).IsAssignableFrom(type))
+ {
+ return AssetDatabase.LoadAssetAtPath(value, type);
+ }
+ return null;
+ }
+
+ static string StringFromLeafObject(object obj)
+ {
+ if (obj == null)
+ return string.Empty;
+
+ if (typeof(Component).IsAssignableFrom(obj.GetType()))
+ {
+ Component c = (Component)obj;
+ if (c == null) // Component overrides the == operator, so we have to check
+ return string.Empty;
+ return ObjectTreeUtil.GetFullName(c.gameObject);
+ }
+ if (typeof(GameObject).IsAssignableFrom(obj.GetType()))
+ {
+ GameObject go = (GameObject)obj;
+ if (go == null) // GameObject overrides the == operator, so we have to check
+ return string.Empty;
+ return ObjectTreeUtil.GetFullName(go);
+ }
+ if (typeof(ScriptableObject).IsAssignableFrom(obj.GetType()))
+ {
+ return AssetDatabase.GetAssetPath(obj as ScriptableObject);
+ }
+ return obj.ToString();
+ }
+ };
+
+
+ /// <summary>
+ /// For all registered object types, record their state when exiting Play Mode,
+ /// and restore that state to the objects in the scene. This is a very limited
+ /// implementation which has not been rigorously tested with many objects types.
+ /// It's quite possible that not everything will be saved.
+ ///
+ /// This class is expected to become obsolete when Unity implements this functionality
+ /// in a more general way.
+ ///
+ /// To use this class,
+ /// drop this script into your project, and add the [SaveDuringPlay] attribute to your class.
+ ///
+ /// Note: if you want some specific field in your class NOT to be saved during play,
+ /// add a property attribute whose class name contains the string "NoSaveDuringPlay"
+ /// and the field will not be saved.
+ /// </summary>
+ [InitializeOnLoad]
+ public class SaveDuringPlay
+ {
+ public static string kEnabledKey = "SaveDuringPlay_Enabled";
+ public static bool Enabled
+ {
+ get { return EditorPrefs.GetBool(kEnabledKey, false); }
+ set
+ {
+ if (value != Enabled)
+ {
+ EditorPrefs.SetBool(kEnabledKey, value);
+ }
+ }
+ }
+
+ static SaveDuringPlay()
+ {
+ // Install our callbacks
+#if UNITY_2017_2_OR_NEWER
+ EditorApplication.playModeStateChanged += OnPlayStateChanged;
+#else
+ EditorApplication.update += OnEditorUpdate;
+ EditorApplication.playmodeStateChanged += OnPlayStateChanged;
+#endif
+ }
+
+#if UNITY_2017_2_OR_NEWER
+ static void OnPlayStateChanged(PlayModeStateChange pmsc)
+ {
+ if (Enabled)
+ {
+ // If exiting playmode, collect the state of all interesting objects
+ if (pmsc == PlayModeStateChange.ExitingPlayMode)
+ SaveAllInterestingStates();
+ else if (pmsc == PlayModeStateChange.EnteredEditMode && sSavedStates != null)
+ RestoreAllInterestingStates();
+ }
+ }
+#else
+ static void OnPlayStateChanged()
+ {
+ // If exiting playmode, collect the state of all interesting objects
+ if (Enabled)
+ {
+ if (!EditorApplication.isPlayingOrWillChangePlaymode && EditorApplication.isPlaying)
+ SaveAllInterestingStates();
+ }
+ }
+
+ static float sWaitStartTime = 0;
+ static void OnEditorUpdate()
+ {
+ if (Enabled && sSavedStates != null && !Application.isPlaying)
+ {
+ // Wait a bit for things to settle before applying the saved state
+ const float WaitTime = 1f; // GML todo: is there a better way to do this?
+ float time = Time.realtimeSinceStartup;
+ if (sWaitStartTime == 0)
+ sWaitStartTime = time;
+ else if (time - sWaitStartTime > WaitTime)
+ {
+ RestoreAllInterestingStates();
+ sWaitStartTime = 0;
+ }
+ }
+ }
+#endif
+
+ /// <summary>
+ /// If you need to get notified before state is collected for hotsave, this is the place
+ /// </summary>
+ public static OnHotSaveDelegate OnHotSave;
+ public delegate void OnHotSaveDelegate();
+
+ /// Collect all relevant objects, active or not
+ static Transform[] FindInterestingObjects()
+ {
+ List<Transform> objects = new List<Transform>();
+ MonoBehaviour[] everything = ObjectTreeUtil.FindAllBehavioursInScene<MonoBehaviour>();
+ foreach (var b in everything)
+ {
+ var attrs = b.GetType().GetCustomAttributes(true);
+ foreach (var attr in attrs)
+ {
+ if (attr.GetType().Name.Contains("SaveDuringPlay"))
+ {
+ //Debug.Log("Found " + ObjectTreeUtil.GetFullName(b.gameObject) + " for hot-save");
+ objects.Add(b.transform);
+ break;
+ }
+ }
+ }
+ return objects.ToArray();
+ }
+
+ static List<ObjectStateSaver> sSavedStates = null;
+ static GameObject sSaveStatesGameObject;
+ static void SaveAllInterestingStates()
+ {
+ //Debug.Log("Exiting play mode: Saving state for all interesting objects");
+ if (OnHotSave != null)
+ OnHotSave();
+
+ sSavedStates = new List<ObjectStateSaver>();
+ Transform[] objects = FindInterestingObjects();
+ foreach (Transform obj in objects)
+ {
+ ObjectStateSaver saver = new ObjectStateSaver();
+ saver.CollectFieldValues(obj.gameObject);
+ sSavedStates.Add(saver);
+ }
+ if (sSavedStates.Count == 0)
+ sSavedStates = null;
+ }
+
+ static void RestoreAllInterestingStates()
+ {
+ //Debug.Log("Updating state for all interesting objects");
+ bool dirty = false;
+ GameObject[] roots = ObjectTreeUtil.FindAllRootObjectsInScene();
+ foreach (ObjectStateSaver saver in sSavedStates)
+ {
+ GameObject go = saver.FindSavedGameObject(roots);
+ if (go != null)
+ {
+ Undo.RegisterFullObjectHierarchyUndo(go, "SaveDuringPlay");
+ if (saver.PutFieldValues(go, roots))
+ {
+ //Debug.Log("SaveDuringPlay: updated settings of " + saver.ObjetFullPath);
+ EditorUtility.SetDirty(go);
+ dirty = true;
+ }
+ }
+ }
+ if (dirty)
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ sSavedStates = null;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 24ec24775a1b45e4ea81ac13002dee32
+timeCreated: 1485895820
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+using System;
+
+namespace Cinemachine.Editor
+{
+ internal class ScriptableObjectUtility : ScriptableObject
+ {
+ public static string kPackageRoot = "Packages/com.unity.cinemachine";
+
+ /// <summary>Get the Cinemachine package install path. Works whether CM is
+ /// a packman package or an ordinary asset.</summary>
+ public static string CinemachineInstallPath
+ {
+ get
+ {
+ // First see if we're a UPM package - use some asset that we expect to find
+ string path = Path.GetFullPath(kPackageRoot + "/Editor/Resources/cm_logo_sm.png");
+ int index = path.LastIndexOf("/Editor");
+ if (index < 0 || !File.Exists(path))
+ {
+ // Try as an ordinary asset
+ ScriptableObject dummy = ScriptableObject.CreateInstance<ScriptableObjectUtility>();
+ path = AssetDatabase.GetAssetPath(MonoScript.FromScriptableObject(dummy));
+ if (path.Length > 0)
+ path = Path.GetFullPath(path);
+ DestroyImmediate(dummy);
+ }
+ path = path.Replace('\\', '/'); // because of GetFullPath()
+ index = path.LastIndexOf("/Editor");
+ if (index >= 0)
+ path = path.Substring(0, index);
+ if (path.Length > 0)
+ path = Path.GetFullPath(path); // stupid backslashes
+ return path;
+ }
+ }
+
+ /// <summary>Create a scriptable object asset</summary>
+ public static T CreateAt<T>(string assetPath) where T : ScriptableObject
+ {
+ return CreateAt(typeof(T), assetPath) as T;
+ }
+
+ /// <summary>Create a scriptable object asset</summary>
+ public static ScriptableObject CreateAt(Type assetType, string assetPath)
+ {
+ ScriptableObject asset = ScriptableObject.CreateInstance(assetType);
+ if (asset == null)
+ {
+ Debug.LogError("failed to create instance of " + assetType.Name + " at " + assetPath);
+ return null;
+ }
+ AssetDatabase.CreateAsset(asset, assetPath);
+ return asset;
+ }
+
+ public static void Create<T>(bool prependFolderName = false, bool trimName = true) where T : ScriptableObject
+ {
+ string className = typeof(T).Name;
+ string assetName = className;
+ string folder = GetSelectedAssetFolder();
+
+ if (trimName)
+ {
+ string[] standardNames = new string[] { "Asset", "Attributes", "Container" };
+ foreach (string standardName in standardNames)
+ {
+ assetName = assetName.Replace(standardName, "");
+ }
+ }
+
+ if (prependFolderName)
+ {
+ string folderName = Path.GetFileName(folder);
+ assetName = (string.IsNullOrEmpty(assetName) ? folderName : string.Format("{0}_{1}", folderName, assetName));
+ }
+
+ Create(className, assetName, folder);
+ }
+
+ private static ScriptableObject Create(string className, string assetName, string folder)
+ {
+ ScriptableObject asset = ScriptableObject.CreateInstance(className);
+ if (asset == null)
+ {
+ Debug.LogError("failed to create instance of " + className);
+ return null;
+ }
+
+ asset.name = assetName ?? className;
+
+ string assetPath = GetUnusedAssetPath(folder, asset.name);
+ AssetDatabase.CreateAsset(asset, assetPath);
+
+ return asset;
+ }
+
+ private static string GetSelectedAssetFolder()
+ {
+ if ((Selection.activeObject != null) && AssetDatabase.Contains(Selection.activeObject))
+ {
+ string assetPath = AssetDatabase.GetAssetPath(Selection.activeObject);
+ string assetPathAbsolute = string.Format("{0}/{1}", Path.GetDirectoryName(Application.dataPath), assetPath);
+
+ if (Directory.Exists(assetPathAbsolute))
+ {
+ return assetPath;
+ }
+ else
+ {
+ return Path.GetDirectoryName(assetPath);
+ }
+ }
+
+ return "Assets";
+ }
+
+ private static string GetUnusedAssetPath(string folder, string assetName)
+ {
+ for (int n = 0; n < 9999; n++)
+ {
+ string assetPath = string.Format("{0}/{1}{2}.asset", folder, assetName, (n == 0 ? "" : n.ToString()));
+ string existingGUID = AssetDatabase.AssetPathToGUID(assetPath);
+ if (string.IsNullOrEmpty(existingGUID))
+ {
+ return assetPath;
+ }
+ }
+
+ return null;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: ba59c38a116ff2f4fb69f825ba0da3bc
+timeCreated: 1481654957
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using System.Linq.Expressions;
+using UnityEditor;
+
+namespace Cinemachine.Editor
+{
+ /// <summary>
+ /// Helpers for the editor
+ /// </summary>
+ public static class SerializedPropertyHelper
+ {
+ /// This is a way to get a field name string in such a manner that the compiler will
+ /// generate errors for invalid fields. Much better than directly using strings.
+ /// Usage: instead of
+ /// <example>
+ /// "m_MyField";
+ /// </example>
+ /// do this:
+ /// <example>
+ /// MyClass myclass = null;
+ /// SerializedPropertyHelper.PropertyName( () => myClass.m_MyField);
+ /// </example>
+ public static string PropertyName(Expression<Func<object>> exp)
+ {
+ var body = exp.Body as MemberExpression;
+ if (body == null)
+ {
+ var ubody = (UnaryExpression)exp.Body;
+ body = ubody.Operand as MemberExpression;
+ }
+ return body.Member.Name;
+ }
+
+ /// Usage: instead of
+ /// <example>
+ /// mySerializedObject.FindProperty("m_MyField");
+ /// </example>
+ /// do this:
+ /// <example>
+ /// MyClass myclass = null;
+ /// mySerializedObject.FindProperty( () => myClass.m_MyField);
+ /// </example>
+ public static SerializedProperty FindProperty(this SerializedObject obj, Expression<Func<object>> exp)
+ {
+ return obj.FindProperty(PropertyName(exp));
+ }
+
+ /// Usage: instead of
+ /// <example>
+ /// mySerializedProperty.FindPropertyRelative("m_MyField");
+ /// </example>
+ /// do this:
+ /// <example>
+ /// MyClass myclass = null;
+ /// mySerializedProperty.FindPropertyRelative( () => myClass.m_MyField);
+ /// </example>
+ public static SerializedProperty FindPropertyRelative(this SerializedProperty obj, Expression<Func<object>> exp)
+ {
+ return obj.FindPropertyRelative(PropertyName(exp));
+ }
+
+ /// <summary>Get the value of a proprty, as an object</summary>
+ public static object GetPropertyValue(SerializedProperty property)
+ {
+ var targetObject = property.serializedObject.targetObject;
+ var targetObjectClassType = targetObject.GetType();
+ var field = targetObjectClassType.GetField(property.propertyPath);
+ if (field != null)
+ return field.GetValue(targetObject);
+ return null;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: a60d9407e2bb20e4ea00281b1e33eae7
+timeCreated: 1488400542
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 9c644b247df49ee47957d373411a85c3
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+namespace Cinemachine.Editor
+{
+ [InitializeOnLoad]
+ internal class AboutWindow : EditorWindow
+ {
+ private const string kLastVersionOpened = "CNMCN_Last_Version_Loaded";
+ private const string kInvalidVersionNumber = "0.0";
+
+ private static readonly Vector2 kMinWindowSize = new Vector2(550f, 550f);
+
+ private static string LastVersionLoaded
+ {
+ get { return EditorPrefs.GetString(kLastVersionOpened, kInvalidVersionNumber); }
+ set { EditorPrefs.SetString(kLastVersionOpened, value); }
+ }
+
+ private GUIStyle mButtonStyle;
+ private GUIStyle mLabelStyle;
+ private GUIStyle mHeaderStyle;
+ private GUIStyle mNotesStyle;
+ private Vector2 mReleaseNoteScrollPos = Vector2.zero;
+
+ string mReleaseNotes;
+
+ private void OnEnable()
+ {
+ string path = ScriptableObjectUtility.CinemachineInstallPath + "/Extras~/ReleaseNotes.txt";
+ try
+ {
+ StreamReader reader = new StreamReader(path);
+ mReleaseNotes = reader.ReadToEnd();
+ reader.Close();
+ }
+ catch (System.Exception)
+ {
+ mReleaseNotes = path + " not found";
+ }
+ }
+
+ private void OnGUI()
+ {
+ if (EditorApplication.isCompiling)
+ {
+ Close();
+ }
+
+ if (mButtonStyle == null)
+ {
+ mButtonStyle = new GUIStyle(GUI.skin.button);
+ mButtonStyle.richText = true;
+ }
+
+ if (mLabelStyle == null)
+ {
+ mLabelStyle = new GUIStyle(EditorStyles.label);
+ mLabelStyle.wordWrap = true;
+ mLabelStyle.richText = true;
+ }
+
+ if (mHeaderStyle == null)
+ {
+ mHeaderStyle = new GUIStyle(EditorStyles.boldLabel);
+ mHeaderStyle.wordWrap = true;
+ }
+
+ if (mNotesStyle == null)
+ {
+ mNotesStyle = new GUIStyle(EditorStyles.textArea);
+ mNotesStyle.richText = true;
+ mNotesStyle.wordWrap = true;
+ }
+
+ using (var vertScope = new EditorGUILayout.VerticalScope())
+ {
+ if (CinemachineSettings.CinemachineHeader != null)
+ {
+ float headerWidth = position.width;
+ float aspectRatio = (float)CinemachineSettings.CinemachineHeader.height / (float)CinemachineSettings.CinemachineHeader.width;
+ GUILayout.BeginScrollView(Vector2.zero, false, false, GUILayout.Width(headerWidth), GUILayout.Height(headerWidth * aspectRatio));
+ Rect texRect = new Rect(0f, 0f, headerWidth, headerWidth * aspectRatio);
+
+ GUILayout.FlexibleSpace();
+ GUILayout.BeginArea(texRect);
+ GUI.DrawTexture(texRect, CinemachineSettings.CinemachineHeader, ScaleMode.ScaleToFit);
+ GUILayout.EndArea();
+ GUILayout.FlexibleSpace();
+
+ GUILayout.EndScrollView();
+ }
+
+ EditorGUILayout.LabelField("Welcome to Cinemachine!", mLabelStyle);
+ EditorGUILayout.LabelField("Smart camera tools for passionate creators.", mLabelStyle);
+ EditorGUILayout.LabelField("Below are links to the forums, please reach out if you have any questions or feedback", mLabelStyle);
+
+ if (GUILayout.Button("<b>Forum</b>\n<i>Discuss</i>", mButtonStyle))
+ {
+ Application.OpenURL("https://forum.unity3d.com/forums/cinemachine.136/");
+ }
+
+ if (GUILayout.Button("<b>Rate it!</b>\nUnity Asset Store", mButtonStyle))
+ {
+ Application.OpenURL("https://www.assetstore.unity3d.com/en/#!/content/79898");
+ }
+ }
+
+ EditorGUILayout.LabelField("Release Notes", mHeaderStyle);
+ using (var scrollScope = new EditorGUILayout.ScrollViewScope(mReleaseNoteScrollPos, GUI.skin.box))
+ {
+ mReleaseNoteScrollPos = scrollScope.scrollPosition;
+ EditorGUILayout.LabelField(mReleaseNotes, mNotesStyle);
+ }
+ }
+
+ [MenuItem("Cinemachine/About")]
+ private static void OpenWindow()
+ {
+ EditorApplication.update += ShowWindowDeferred;
+ }
+
+ private static void ShowWindowDeferred()
+ {
+ string loadedVersion = LastVersionLoaded;
+ if (loadedVersion != CinemachineCore.kVersionString)
+ LastVersionLoaded = CinemachineCore.kVersionString;
+
+ AboutWindow window = EditorWindow.GetWindow<AboutWindow>();
+
+ window.titleContent = new UnityEngine.GUIContent(
+ "About", CinemachineSettings.CinemachineLogoTexture);
+ window.minSize = kMinWindowSize;
+ window.Show(true);
+
+ EditorApplication.update -= ShowWindowDeferred;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 829e606f890b35c47aa29643517add2e
+timeCreated: 1481654956
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+
+using Cinemachine.Editor;
+
+namespace Cinemachine
+{
+ [InitializeOnLoad]
+ internal static class CinemachineColliderPrefs
+ {
+ private static bool SettingsFoldedOut
+ {
+ get { return EditorPrefs.GetBool(kColliderSettingsFoldoutKey, false); }
+ set
+ {
+ if (value != SettingsFoldedOut)
+ {
+ EditorPrefs.SetBool(kColliderSettingsFoldoutKey, value);
+ }
+ }
+ }
+
+ public static Color FeelerHitColor
+ {
+ get
+ {
+ return CinemachineSettings.UnpackColour(EditorPrefs.GetString(kFeelerHitColourKey, CinemachineSettings.PackColor(Color.yellow)));
+ }
+
+ set
+ {
+ if (value != FeelerHitColor)
+ {
+ EditorPrefs.SetString(kFeelerHitColourKey, CinemachineSettings.PackColor(value));
+ }
+ }
+ }
+
+ public static Color FeelerColor
+ {
+ get
+ {
+ return CinemachineSettings.UnpackColour(EditorPrefs.GetString(kFeelerColourKey, CinemachineSettings.PackColor(Color.gray)));
+ }
+
+ set
+ {
+ if (value != FeelerColor)
+ {
+ EditorPrefs.SetString(kFeelerColourKey, CinemachineSettings.PackColor(value));
+ }
+ }
+ }
+
+ private const string kColliderSettingsFoldoutKey = "CNMCN_Collider_Foldout";
+ private const string kFeelerHitColourKey = "CNMCN_Collider_FeelerHit_Colour";
+ private const string kFeelerColourKey = "CNMCN_Collider_Feeler_Colour";
+
+ static CinemachineColliderPrefs()
+ {
+ Cinemachine.Editor.CinemachineSettings.AdditionalCategories += DrawColliderSettings;
+ }
+
+ private static void DrawColliderSettings()
+ {
+ SettingsFoldedOut = EditorGUILayout.Foldout(SettingsFoldedOut, "Collider Settings");
+ if (SettingsFoldedOut)
+ {
+ EditorGUI.indentLevel++;
+
+ EditorGUI.BeginChangeCheck();
+
+ FeelerHitColor = EditorGUILayout.ColorField("Feeler Hit", FeelerHitColor);
+ FeelerColor = EditorGUILayout.ColorField("Feeler", FeelerColor);
+
+ if (EditorGUI.EndChangeCheck())
+ {
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+
+ EditorGUI.indentLevel--;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: aceb1a3f85f55c249bba6eaade29f2aa
+timeCreated: 1484415513
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System;
+
+namespace Cinemachine.Editor
+{
+ [InitializeOnLoad]
+ internal sealed class CinemachineSettings
+ {
+ public static class CinemachineCoreSettings
+ {
+ private static readonly string hShowInGameGuidesKey = "CNMCN_Core_ShowInGameGuides";
+ public static bool ShowInGameGuides
+ {
+ get { return EditorPrefs.GetBool(hShowInGameGuidesKey, true); }
+ set
+ {
+ if (ShowInGameGuides != value)
+ {
+ EditorPrefs.SetBool(hShowInGameGuidesKey, value);
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+ }
+ }
+
+ private static readonly string kCoreActiveGizmoColourKey = "CNMCN_Core_Active_Gizmo_Colour";
+ public static readonly Color kDefaultActiveColour = new Color32(255, 0, 0, 100);
+ public static Color ActiveGizmoColour
+ {
+ get
+ {
+ string packedColour = EditorPrefs.GetString(kCoreActiveGizmoColourKey, PackColor(kDefaultActiveColour));
+ return UnpackColour(packedColour);
+ }
+
+ set
+ {
+ if (ActiveGizmoColour != value)
+ {
+ string packedColour = PackColor(value);
+ EditorPrefs.SetString(kCoreActiveGizmoColourKey, packedColour);
+ }
+ }
+ }
+
+ private static readonly string kCoreInactiveGizmoColourKey = "CNMCN_Core_Inactive_Gizmo_Colour";
+ public static readonly Color kDefaultInactiveColour = new Color32(9, 54, 87, 100);
+ public static Color InactiveGizmoColour
+ {
+ get
+ {
+ string packedColour = EditorPrefs.GetString(kCoreInactiveGizmoColourKey, PackColor(kDefaultInactiveColour));
+ return UnpackColour(packedColour);
+ }
+
+ set
+ {
+ if (InactiveGizmoColour != value)
+ {
+ string packedColour = PackColor(value);
+ EditorPrefs.SetString(kCoreInactiveGizmoColourKey, packedColour);
+ }
+ }
+ }
+ }
+
+ public static class ComposerSettings
+ {
+ private static readonly string kOverlayOpacityKey = "CNMCN_Overlay_Opacity";
+ private static readonly string kComposerHardBoundsColourKey = "CNMCN_Composer_HardBounds_Colour";
+ private static readonly string kComposerSoftBoundsColourKey = "CNMCN_Composer_SoftBounds_Colour";
+ private static readonly string kComposerTargetColourKey = "CNMCN_Composer_Target_Colour";
+ private static readonly string kComposerTargetSizeKey = "CNMCN_Composer_Target_Size";
+
+ public const float kDefaultOverlayOpacity = 0.15f;
+ public static readonly Color kDefaultHardBoundsColour = new Color32(255, 0, 72, 255);
+ public static readonly Color kDefaultSoftBoundsColour = new Color32(0, 194, 255, 255);
+ public static readonly Color kDefaultTargetColour = new Color32(255, 254, 25, 255);
+
+ public static float OverlayOpacity
+ {
+ get { return EditorPrefs.GetFloat(kOverlayOpacityKey, kDefaultOverlayOpacity); }
+ set
+ {
+ if (value != OverlayOpacity)
+ {
+ EditorPrefs.SetFloat(kOverlayOpacityKey, value);
+ }
+ }
+ }
+
+ public static Color HardBoundsOverlayColour
+ {
+ get
+ {
+ string packedColour = EditorPrefs.GetString(kComposerHardBoundsColourKey, PackColor(kDefaultHardBoundsColour));
+ return UnpackColour(packedColour);
+ }
+
+ set
+ {
+ if (HardBoundsOverlayColour != value)
+ {
+ string packedColour = PackColor(value);
+ EditorPrefs.SetString(kComposerHardBoundsColourKey, packedColour);
+ }
+ }
+ }
+
+ public static Color SoftBoundsOverlayColour
+ {
+ get
+ {
+ string packedColour = EditorPrefs.GetString(kComposerSoftBoundsColourKey, PackColor(kDefaultSoftBoundsColour));
+ return UnpackColour(packedColour);
+ }
+
+ set
+ {
+ if (SoftBoundsOverlayColour != value)
+ {
+ string packedColour = PackColor(value);
+ EditorPrefs.SetString(kComposerSoftBoundsColourKey, packedColour);
+ }
+ }
+ }
+
+ public static Color TargetColour
+ {
+ get
+ {
+ string packedColour = EditorPrefs.GetString(kComposerTargetColourKey, PackColor(kDefaultTargetColour));
+ return UnpackColour(packedColour);
+ }
+
+ set
+ {
+ if (TargetColour != value)
+ {
+ string packedColour = PackColor(value);
+ EditorPrefs.SetString(kComposerTargetColourKey, packedColour);
+ }
+ }
+ }
+
+ public static float TargetSize
+ {
+ get
+ {
+ return EditorPrefs.GetFloat(kComposerTargetSizeKey, 5f);
+ }
+
+ set
+ {
+ if (TargetSize != value)
+ {
+ EditorPrefs.SetFloat(kComposerTargetSizeKey, value);
+ }
+ }
+ }
+ }
+
+ private static bool ShowCoreSettings
+ {
+ get { return EditorPrefs.GetBool(kCoreSettingsFoldKey, false); }
+ set
+ {
+ if (value != ShowCoreSettings)
+ {
+ EditorPrefs.SetBool(kCoreSettingsFoldKey, value);
+ }
+ }
+ }
+
+ private static bool ShowComposerSettings
+ {
+ get { return EditorPrefs.GetBool(kComposerSettingsFoldKey, false); }
+ set
+ {
+ if (value != ShowComposerSettings)
+ {
+ EditorPrefs.SetBool(kComposerSettingsFoldKey, value);
+ }
+ }
+ }
+
+ private static Texture2D sCinemachineLogoTexture = null;
+ internal static Texture2D CinemachineLogoTexture
+ {
+ get
+ {
+ if (sCinemachineLogoTexture == null)
+ sCinemachineLogoTexture = Resources.Load<Texture2D>("cm_logo_sm");
+ if (sCinemachineLogoTexture != null)
+ sCinemachineLogoTexture.hideFlags = HideFlags.DontSaveInEditor;
+ return sCinemachineLogoTexture;
+ }
+ }
+
+ private static Texture2D sCinemachineHeader = null;
+ internal static Texture2D CinemachineHeader
+ {
+ get
+ {
+ if (sCinemachineHeader == null)
+ sCinemachineHeader = Resources.Load<Texture2D>("cinemachine_header");
+ ;
+ if (sCinemachineHeader != null)
+ sCinemachineHeader.hideFlags = HideFlags.DontSaveInEditor;
+ return sCinemachineHeader;
+ }
+ }
+
+ private static readonly string kCoreSettingsFoldKey = "CNMCN_Core_Folded";
+ private static readonly string kComposerSettingsFoldKey = "CNMCN_Composer_Folded";
+
+ internal static event Action AdditionalCategories = null;
+
+ static CinemachineSettings()
+ {
+ if (CinemachineLogoTexture != null)
+ {
+ EditorApplication.hierarchyWindowItemOnGUI += OnHierarchyGUI;
+ }
+ }
+
+ class Styles {
+ //private static readonly GUIContent sCoreShowHiddenObjectsToggle = new GUIContent("Show Hidden Objects", "If checked, Cinemachine hidden objects will be shown in the inspector. This might be necessary to repair broken script mappings when upgrading from a pre-release version");
+ public static readonly GUIContent sCoreActiveGizmosColour = new GUIContent("Active Virtual Camera", "The colour for the active virtual camera's gizmos");
+ public static readonly GUIContent sCoreInactiveGizmosColour = new GUIContent("Inactive Virtual Camera", "The colour for all inactive virtual camera gizmos");
+ public static readonly GUIContent sComposerOverlayOpacity = new GUIContent("Overlay Opacity", "The alpha of the composer's overlay when a virtual camera is selected with composer module enabled");
+ public static readonly GUIContent sComposerHardBoundsOverlay = new GUIContent("Hard Bounds Overlay", "The colour of the composer overlay's hard bounds region");
+ public static readonly GUIContent sComposerSoftBoundsOverlay = new GUIContent("Soft Bounds Overlay", "The colour of the composer overlay's soft bounds region");
+ public static readonly GUIContent sComposerTargetOverlay = new GUIContent("Composer Target", "The colour of the composer overlay's target");
+ public static readonly GUIContent sComposerTargetOverlayPixels = new GUIContent("Composer Target Size(px)", "The size of the composer overlay's target box in pixels");
+ }
+
+ private const string kCinemachineHeaderPath = "cinemachine_header.tif";
+ private const string kCinemachineDocURL = @"http://www.cinemachineimagery.com/documentation/";
+
+ private static Vector2 sScrollPosition = Vector2.zero;
+
+#if UNITY_2019_1_OR_NEWER
+ [SettingsProvider]
+ static SettingsProvider CreateProjectSettingsProvider()
+ {
+ var provider = new SettingsProvider("Preferences/Cinemachine", SettingsScope.User, SettingsProvider.GetSearchKeywordsFromGUIContentProperties<Styles>());
+ provider.guiHandler = (sarchContext) => OnGUI();
+ return provider;
+ }
+#else
+ [PreferenceItem("Cinemachine")]
+#endif
+ private static void OnGUI()
+ {
+ if (CinemachineHeader != null)
+ {
+ const float kWidth = 350f;
+ float aspectRatio = (float)CinemachineHeader.height / (float)CinemachineHeader.width;
+ GUILayout.BeginScrollView(Vector2.zero, false, false, GUILayout.Width(kWidth), GUILayout.Height(kWidth * aspectRatio));
+ Rect texRect = new Rect(0f, 0f, kWidth, kWidth * aspectRatio);
+
+ GUILayout.BeginArea(texRect);
+ GUI.DrawTexture(texRect, CinemachineHeader, ScaleMode.ScaleToFit);
+ GUILayout.EndArea();
+
+ GUILayout.EndScrollView();
+ }
+
+ sScrollPosition = GUILayout.BeginScrollView(sScrollPosition);
+
+ //CinemachineCore.sShowHiddenObjects
+ // = EditorGUILayout.Toggle("Show Hidden Objects", CinemachineCore.sShowHiddenObjects);
+
+ ShowCoreSettings = EditorGUILayout.Foldout(ShowCoreSettings, "Runtime Settings");
+ if (ShowCoreSettings)
+ {
+ EditorGUI.indentLevel++;
+ EditorGUI.BeginChangeCheck();
+ EditorGUILayout.BeginHorizontal();
+ EditorGUI.BeginChangeCheck();
+ Color newActiveGizmoColour = EditorGUILayout.ColorField(Styles.sCoreActiveGizmosColour, CinemachineCoreSettings.ActiveGizmoColour);
+
+ if (EditorGUI.EndChangeCheck())
+ {
+ CinemachineCoreSettings.ActiveGizmoColour = newActiveGizmoColour;
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+
+ if (GUILayout.Button("Reset"))
+ {
+ CinemachineCoreSettings.ActiveGizmoColour = CinemachineCoreSettings.kDefaultActiveColour;
+ }
+ EditorGUILayout.EndHorizontal();
+
+ EditorGUILayout.BeginHorizontal();
+ EditorGUI.BeginChangeCheck();
+ Color newInactiveGizmoColour = EditorGUILayout.ColorField(Styles.sCoreInactiveGizmosColour, CinemachineCoreSettings.InactiveGizmoColour);
+
+ if (EditorGUI.EndChangeCheck())
+ {
+ CinemachineCoreSettings.InactiveGizmoColour = newInactiveGizmoColour;
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ }
+
+ if (GUILayout.Button("Reset"))
+ {
+ CinemachineCoreSettings.InactiveGizmoColour = CinemachineCoreSettings.kDefaultInactiveColour;
+ }
+ EditorGUILayout.EndHorizontal();
+ EditorGUI.indentLevel--;
+ }
+
+ ShowComposerSettings = EditorGUILayout.Foldout(ShowComposerSettings, "Composer Settings");
+ if (ShowComposerSettings)
+ {
+ EditorGUI.indentLevel++;
+ EditorGUILayout.BeginHorizontal();
+ EditorGUI.BeginChangeCheck();
+
+ float overlayOpacity = EditorGUILayout.Slider(Styles.sComposerOverlayOpacity, ComposerSettings.OverlayOpacity, 0f, 1f);
+
+ if (EditorGUI.EndChangeCheck())
+ {
+ ComposerSettings.OverlayOpacity = overlayOpacity;
+ }
+
+ if (GUILayout.Button("Reset"))
+ {
+ ComposerSettings.OverlayOpacity = ComposerSettings.kDefaultOverlayOpacity;
+ }
+ EditorGUILayout.EndHorizontal();
+
+ EditorGUILayout.BeginHorizontal();
+ EditorGUI.BeginChangeCheck();
+ Color newHardEdgeColor = EditorGUILayout.ColorField(Styles.sComposerHardBoundsOverlay, ComposerSettings.HardBoundsOverlayColour);
+
+ if (EditorGUI.EndChangeCheck())
+ {
+ ComposerSettings.HardBoundsOverlayColour = newHardEdgeColor;
+ }
+
+ if (GUILayout.Button("Reset"))
+ {
+ ComposerSettings.HardBoundsOverlayColour = ComposerSettings.kDefaultHardBoundsColour;
+ }
+ EditorGUILayout.EndHorizontal();
+
+ EditorGUILayout.BeginHorizontal();
+ EditorGUI.BeginChangeCheck();
+ Color newSoftEdgeColor = EditorGUILayout.ColorField(Styles.sComposerSoftBoundsOverlay, ComposerSettings.SoftBoundsOverlayColour);
+
+ if (EditorGUI.EndChangeCheck())
+ {
+ ComposerSettings.SoftBoundsOverlayColour = newSoftEdgeColor;
+ }
+
+ if (GUILayout.Button("Reset"))
+ {
+ ComposerSettings.SoftBoundsOverlayColour = ComposerSettings.kDefaultSoftBoundsColour;
+ }
+ EditorGUILayout.EndHorizontal();
+
+ EditorGUILayout.BeginHorizontal();
+ EditorGUI.BeginChangeCheck();
+ Color newTargetColour = EditorGUILayout.ColorField(Styles.sComposerTargetOverlay, ComposerSettings.TargetColour);
+
+ if (EditorGUI.EndChangeCheck())
+ {
+ ComposerSettings.TargetColour = newTargetColour;
+ }
+
+ if (GUILayout.Button("Reset"))
+ {
+ ComposerSettings.TargetColour = ComposerSettings.kDefaultTargetColour;
+ }
+ EditorGUILayout.EndHorizontal();
+
+ EditorGUI.BeginChangeCheck();
+ float targetSide = EditorGUILayout.FloatField(Styles.sComposerTargetOverlayPixels, ComposerSettings.TargetSize);
+
+ if (EditorGUI.EndChangeCheck())
+ {
+ ComposerSettings.TargetSize = targetSide;
+ }
+ EditorGUI.indentLevel--;
+ }
+
+ if (AdditionalCategories != null)
+ {
+ AdditionalCategories();
+ }
+
+ GUILayout.EndScrollView();
+
+ //if (GUILayout.Button("Open Documentation"))
+ //{
+ // Application.OpenURL(kCinemachineDocURL);
+ //}
+ }
+
+ private static void OnHierarchyGUI(int instanceID, Rect selectionRect)
+ {
+ GameObject instance = EditorUtility.InstanceIDToObject(instanceID) as GameObject;
+ if (instance == null)
+ {
+ // Object in process of being deleted?
+ return;
+ }
+
+ if (instance.GetComponent<CinemachineBrain>() != null)
+ {
+ Rect texRect = new Rect(selectionRect.xMax - selectionRect.height, selectionRect.yMin, selectionRect.height, selectionRect.height);
+ GUI.DrawTexture(texRect, CinemachineLogoTexture, ScaleMode.ScaleAndCrop);
+ }
+ }
+
+ internal static Color UnpackColour(string str)
+ {
+ if (!string.IsNullOrEmpty(str))
+ {
+ byte[] bytes = Base64Decode(str);
+
+ if ((bytes != null) && bytes.Length == 16)
+ {
+ float r = BitConverter.ToSingle(bytes, 0);
+ float g = BitConverter.ToSingle(bytes, 4);
+ float b = BitConverter.ToSingle(bytes, 8);
+ float a = BitConverter.ToSingle(bytes, 12);
+
+ return new Color(r, g, b, a);
+ }
+ }
+
+ return Color.white;
+ }
+
+ internal static string PackColor(Color col)
+ {
+ byte[] bytes = new byte[16];
+
+ byte[] rBytes = BitConverter.GetBytes(col.r);
+ byte[] gBytes = BitConverter.GetBytes(col.g);
+ byte[] bBytes = BitConverter.GetBytes(col.b);
+ byte[] aBytes = BitConverter.GetBytes(col.a);
+
+ Buffer.BlockCopy(rBytes, 0, bytes, 0, 4);
+ Buffer.BlockCopy(gBytes, 0, bytes, 4, 4);
+ Buffer.BlockCopy(bBytes, 0, bytes, 8, 4);
+ Buffer.BlockCopy(aBytes, 0, bytes, 12, 4);
+
+ return Base64Encode(bytes);
+ }
+
+ private static string Base64Encode(byte[] data)
+ {
+ return Convert.ToBase64String(data);
+ }
+
+ private static byte[] Base64Decode(string base64EncodedData)
+ {
+ return Convert.FromBase64String(base64EncodedData);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 74d8c4d6e5d0338469ae46c13725f3ce
+timeCreated: 1488314898
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+using System.Collections.Generic;
+using UnityEngine.Rendering;
+
+namespace Cinemachine.Editor
+{
+ internal class WaveformWindow : EditorWindow
+ {
+ WaveformGenerator mWaveformGenerator;
+ Texture2D mScreenshot;
+ string mScreenshotFilename;
+
+ // Controls how frequently (in seconds) the view will update.
+ // Performance is really bad, so keep this as large as possible.
+ public static float UpdateInterval = 0.5f;
+ public static void SetDefaultUpdateInterval() { UpdateInterval = 0.5f; }
+
+ //[MenuItem("Window/Waveform Monitor")]
+ public static void OpenWindow()
+ {
+ WaveformWindow window = EditorWindow.GetWindow<WaveformWindow>(false);
+ window.autoRepaintOnSceneChange = true;
+ //window.position = new Rect(100, 100, 400, 400);
+ window.Show(true);
+ }
+
+ private void OnEnable()
+ {
+ titleContent = new GUIContent("Waveform", CinemachineSettings.CinemachineLogoTexture);
+ mWaveformGenerator = new WaveformGenerator();
+
+ mScreenshotFilename = Path.GetFullPath(FileUtil.GetUniqueTempPathInProject() + ".png");
+ ScreenCapture.CaptureScreenshot(mScreenshotFilename);
+ EditorApplication.update += UpdateScreenshot;
+ }
+
+ private void OnDisable()
+ {
+ EditorApplication.update -= UpdateScreenshot;
+ if (!string.IsNullOrEmpty(mScreenshotFilename) && File.Exists(mScreenshotFilename))
+ File.Delete(mScreenshotFilename);
+ mScreenshotFilename = null;
+ mWaveformGenerator.DestroyBuffers();
+ if (mScreenshot != null)
+ DestroyImmediate(mScreenshot);
+ mScreenshot = null;
+ }
+
+ private void OnGUI()
+ {
+ Rect rect = EditorGUILayout.GetControlRect(true);
+ EditorGUIUtility.labelWidth /= 2;
+ EditorGUI.BeginChangeCheck();
+ mWaveformGenerator.m_Exposure = EditorGUI.Slider(
+ rect, "Exposure", mWaveformGenerator.m_Exposure, 0.01f, 2);
+ if (EditorGUI.EndChangeCheck())
+ UnityEditorInternal.InternalEditorUtility.RepaintAllViews();
+ EditorGUIUtility.labelWidth *= 2;
+ rect.y += rect.height;
+ rect.height = position.height - rect.height;
+ var tex = mWaveformGenerator.Result;
+ if (tex != null)
+ GUI.DrawTexture(rect, tex);
+ }
+
+ float mLastUpdateTime = 0;
+ private void UpdateScreenshot()
+ {
+ // Don't do this too often
+ float now = Time.time;
+ if (mScreenshot != null && now - mLastUpdateTime < UpdateInterval)
+ return;
+
+ mLastUpdateTime = now;
+ if (!string.IsNullOrEmpty(mScreenshotFilename) && File.Exists(mScreenshotFilename))
+ {
+ byte[] fileData = File.ReadAllBytes(mScreenshotFilename);
+ if (mScreenshot == null)
+ mScreenshot = new Texture2D(2, 2);
+ mScreenshot.LoadImage(fileData); // this will auto-resize the texture dimensions.
+ mWaveformGenerator.RenderWaveform(mScreenshot);
+
+ // Capture the next one
+ ScreenCapture.CaptureScreenshot(mScreenshotFilename);
+ }
+ }
+
+ class WaveformGenerator
+ {
+ public float m_Exposure = 0.2f;
+
+ RenderTexture mOutput;
+ ComputeBuffer mData;
+
+ int mThreadGroupSize;
+ int mThreadGroupSizeX;
+ int mThreadGroupSizeY;
+
+ ComputeShader mWaveformCompute;
+ MaterialPropertyBlock mWaveformProperties;
+ Material mWaveformMaterial;
+ CommandBuffer mCmd;
+
+ static Mesh sFullscreenTriangle;
+ static Mesh FullscreenTriangle
+ {
+ get
+ {
+ if (sFullscreenTriangle == null)
+ {
+ sFullscreenTriangle = new Mesh { name = "Fullscreen Triangle" };
+ sFullscreenTriangle.SetVertices(new List<Vector3>
+ {
+ new Vector3(-1f, -1f, 0f),
+ new Vector3(-1f, 3f, 0f),
+ new Vector3( 3f, -1f, 0f)
+ });
+ sFullscreenTriangle.SetIndices(
+ new [] { 0, 1, 2 }, MeshTopology.Triangles, 0, false);
+ sFullscreenTriangle.UploadMeshData(false);
+ }
+ return sFullscreenTriangle;
+ }
+ }
+
+ public WaveformGenerator()
+ {
+ mWaveformCompute = Resources.Load<ComputeShader>("CMWaveform");
+ mWaveformProperties = new MaterialPropertyBlock();
+ mWaveformMaterial = new Material(Resources.Load<Shader>("CMWaveform"))
+ {
+ name = "CMWaveformMaterial",
+ hideFlags = HideFlags.DontSave
+ };
+ mCmd = new CommandBuffer();
+ }
+
+ void CreateBuffers(int width, int height)
+ {
+ if (mOutput == null || !mOutput.IsCreated()
+ || mOutput.width != width || mOutput.height != height)
+ {
+ DestroyImmediate(mOutput);
+ mOutput = new RenderTexture(width, height, 0, RenderTextureFormat.ARGB32)
+ {
+ anisoLevel = 0,
+ filterMode = FilterMode.Bilinear,
+ wrapMode = TextureWrapMode.Clamp,
+ useMipMap = false
+ };
+ mOutput.Create();
+ }
+
+ int count = Mathf.CeilToInt(width / (float)mThreadGroupSizeX) * mThreadGroupSizeX * height;
+ if (mData == null)
+ mData = new ComputeBuffer(count, sizeof(uint) << 2);
+ else if (mData.count < count)
+ {
+ mData.Release();
+ mData = new ComputeBuffer(count, sizeof(uint) << 2);
+ }
+ }
+
+ public void DestroyBuffers()
+ {
+ if (mData != null)
+ mData.Release();
+ mData = null;
+ DestroyImmediate(mOutput);
+ mOutput = null;
+ }
+
+ public RenderTexture Result { get { return mOutput; } }
+
+ public void RenderWaveform(Texture2D source)
+ {
+ if (mWaveformMaterial == null)
+ return;
+
+ int width = source.width;
+ int height = source.height;
+ int histogramResolution = 256;
+
+ mThreadGroupSize = 256;
+ mThreadGroupSizeX = 16;
+ mThreadGroupSizeY = 16;
+ CreateBuffers(width, histogramResolution);
+
+ mCmd.Clear();
+ mCmd.BeginSample("CMWaveform");
+
+ var parameters = new Vector4(
+ width, height,
+ QualitySettings.activeColorSpace == ColorSpace.Linear ? 1 : 0,
+ histogramResolution);
+
+ // Clear the buffer on every frame
+ int kernel = mWaveformCompute.FindKernel("KCMWaveformClear");
+ mCmd.SetComputeBufferParam(mWaveformCompute, kernel, "_WaveformBuffer", mData);
+ mCmd.SetComputeVectorParam(mWaveformCompute, "_Params", parameters);
+ mCmd.DispatchCompute(mWaveformCompute, kernel,
+ Mathf.CeilToInt(width / (float)mThreadGroupSizeX),
+ Mathf.CeilToInt(histogramResolution / (float)mThreadGroupSizeY), 1);
+
+ // Gather all pixels and fill in our waveform
+ kernel = mWaveformCompute.FindKernel("KCMWaveformGather");
+ mCmd.SetComputeBufferParam(mWaveformCompute, kernel, "_WaveformBuffer", mData);
+ mCmd.SetComputeTextureParam(mWaveformCompute, kernel, "_Source", source);
+ mCmd.SetComputeVectorParam(mWaveformCompute, "_Params", parameters);
+ mCmd.DispatchCompute(mWaveformCompute, kernel, width,
+ Mathf.CeilToInt(height / (float)mThreadGroupSize), 1);
+
+ // Generate the waveform texture
+ float exposure = Mathf.Max(0f, m_Exposure);
+ exposure *= (float)histogramResolution / height;
+ mWaveformProperties.SetVector(Shader.PropertyToID("_Params"),
+ new Vector4(width, histogramResolution, exposure, 0f));
+ mWaveformProperties.SetBuffer(Shader.PropertyToID("_WaveformBuffer"), mData);
+ mCmd.SetRenderTarget(mOutput);
+ mCmd.DrawMesh(
+ FullscreenTriangle, Matrix4x4.identity,
+ mWaveformMaterial, 0, 0, mWaveformProperties);
+ mCmd.EndSample("CMWaveform");
+
+ Graphics.ExecuteCommandBuffer(mCmd);
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: a8725b08dfa3851468b1f029bb53c966
+timeCreated: 1517576612
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+{
+ "name": "com.unity.cinemachine.editor",
+ "references": [
+ "Cinemachine",
+ "Unity.Timeline",
+ "Unity.Timeline.Editor",
+ "Unity.Postprocessing.Runtime",
+ "Unity.Postprocessing.Editor",
+ "Unity.RenderPipelines.Core.Runtime",
+ "Unity.RenderPipelines.Core.Editor",
+ "Unity.RenderPipelines.HighDefinition.Runtime",
+ "Unity.RenderPipelines.HighDefinition.Editor",
+ "Unity.ugui"
+ ],
+ "includePlatforms": [
+ "Editor"
+ ],
+ "excludePlatforms": [],
+ "allowUnsafeCode": false,
+ "overrideReferences": false,
+ "precompiledReferences": [],
+ "autoReferenced": true,
+ "defineConstraints": [],
+ "versionDefines": [
+ {
+ "name": "com.unity.postprocessing",
+ "expression": "2.1.0",
+ "define": "CINEMACHINE_POST_PROCESSING_V2"
+ },
+ {
+ "name": "com.unity.timeline",
+ "expression": "0.0.0-builtin",
+ "define": "CINEMACHINE_TIMELINE"
+ },
+ {
+ "name": "com.unity.render-pipelines.high-definition",
+ "expression": "5.3.1",
+ "define": "CINEMACHINE_POST_PROCESSING_V3"
+ },
+ {
+ "name": "com.unity.modules.physics2d",
+ "expression": "1.0.0",
+ "define": "CINEMACHINE_PHYSICS_2D"
+ },
+ {
+ "name": "com.unity.modules.physics",
+ "expression": "1.0.0",
+ "define": "CINEMACHINE_PHYSICS"
+ },
+ {
+ "name": "com.unity.ugui",
+ "expression": "1.0.0",
+ "define": "CINEMACHINE_UGUI"
+ }
+ ]
+}
\ No newline at end of file
--- /dev/null
+fileFormatVersion: 2
+guid: ba8c092d026123a418fb4bfb797a7bd8
+AssemblyDefinitionImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+<size=20><b>Version 2.3.4</b></size>
+
+- Added support for PostProcessing V3 - now called CinemachineVolumeSttings
+- Added CinemachineCore.GetBlendOverride delegate to allow applications to override any vcam blend when it happens
+- When a blend is cancelled by the opposite blend, reduce the blend time
+- Orthographic cameras allow a Near Clip of 0
+- Timeline won't auto-create CM brains when something dragged onto it
+- Confiner: Improvement in automatic path invalidation when number of path points path changes
+- Added CinemachineInpuitAxisDriver utility for overriding the default AxisState behaviour
+- CinemachineCameraOffset: added customizable stage for when to apply the offset
+- Added Loop option to BlendList Camera
+- Improved Lookahead: does not automatically recenter
+- Brain no longer applies time scaling to fixed delta
+- Added dependency on Unity.ugui (2019.2 and up)
+- Bugfix: potential endless loop when using Ignore tag in Collider
+- Bugfix: Allow externally-driven FeeLook XAxis to work properly with SimpleFollow
+- Bugfix: vcams with noise would sometimes show one noiseless frame when they were activated and standby update was not Always
+- Bugfix: Generate a cut event if cutting to a blend-in-progess (fogbugz 1150847)
+- Bugfix: reset lens shift if not physical camera
+- Bugfix: Collider must consider actual target position, not lookahead position
+- Bugfix: FreeLook heading RecenterNow was not working
+- Bugfix: lookahead now takes the overridden Up into account
+- Bugfix: screen composer guides drawn in wrong place for picture-in-picture
+- Bugfix: FreeLook now draws only 1 active composer guide at a time (fogbugz 1138263)
+- Bugfix: cameras sometimes snapped when interrupting blends
+- Bugfix: Path handles no longer scale with the path object
+- Bugfix: Framing Transposer Center on Activate was not working properly (fogbugz 1129824)
+- Bugfix: FreeLook inherit position
+- Bugfix: collider was pushing camera too far if there were multiple overlapping obstacles
+- Bugfix: use IsAssignableFrom instead of IsSubclass in several places
+- Bugfix: when interrupting a blend in progress, Cut was not respected
+- Bugfix: collider minimum occlusion time and smoothing time interaction
+- Bugfix: TargetGroup.RemoveMember error (fogbugz 1119028)
+- Bugfix: TargetGroup member lerping jerk when member weight near 0
+- Bugfix: Transposer angular damping should be 0 only if binding mode not LockToTarget
+
+
+<size=20><b>Version 2.3.3</b></size>
+
+- Removed Cinemachine.Timeline namespace, as a workaround for fogbugz 1115321
+
+
+<size=20><b>Version 2.3.1</b></size>
+
+- Added timeline dependency
+- OnTargetObjectWarped no longer generates garbage
+
+
+<size=20><b>Version 2.3.0</b></size>
+
+- Added dependency on new unity.timeline
+- Added conditional dependence on PostProcessingV2
+- No copying CM gizmo into assets folder
+- FreeLook: if inherit position from similar FreeLooks, bypass damping
+- Timeline: improve handling when vcam values are tweaked inside shot inspector (fogbugz 1109024)
+
+
+<size=20><b>Version 2.2.8</b></size>
+
+- Transposer: added Angular Damping Mode, to support quaternion calculations in gimbal-lock situations
+- Framing Transposer and Group Transposer: group composing bugfixes, respect min/max limits
+- Added ConemachineCameraOffset extension, to offset the camera a fixed distance at the end of the pipeline
+- Dolly Cart: added support for LateUpdate
+- State-driven-camera: added [NoSaveDuringPlay] to Animated Target and Layer Index
+- Added AxisState.Recentering.RecenterNow() API call to skip wait time and start recentering now (if enabled)
+- Added NoLens blend hint, to leave camera Lens settings alone
+- Updated documentation (corrections, and relocation to prevent importing)
+- Upgrade: added support for nested prefabs in Unity 2018.3 (fogbugz 1077395)
+- Optimization: position predictor is more efficient
+- Optimization: Composer caches some calculations
+- Optimization: Fix editor slowdown when Lens Presets asset is missing
+- Experimental: Optional new damping algorithm: attempt to reduce sensitivity to variable framerate
+- Experimental: Optional new extra-efficient versions of vcam and FreeLook (not back-compatible)
+- Timeline: play/pause doesn't kick out the timeline vcam
+- Path editor: make sure game view gets updated when a path waypoint is dragged in the scene view
+- Composer guides are shown even if Camera is attached to a renderTexture
+- Bugfix: allow impulse definition to be a non-public field (property drawer was complaining)
+- Bugfix: added null check for when there is no active virtual camera
+- Bugfix: CollisionImpulseSource typo in detection of 2D collider
+- Bugfix: PasteComponentValues to prefab vcams and FreeLooks were corrupting scene and prefabs
+- Bugfix: Timeline mixer was glitching for single frames at the end of blends
+- Bugfix: Added OnTransitionFromCamera() to POV and OrbitalTransposer, to transition axes intelligently
+- Regression fix: if no active vcam, don't set the Camera's transform
+
+
+<size=20><b>Version 2.2.7</b></size>
+
+- Bugfix: fogbugz case 1053595: Cinemachine Collider leaves hidden collider at origin that interferes with scene objects
+- Bugfix: fogbugz case 1063754: empty target group produces console messages
+- Bugfix: FreeLook Paste Component Values now pastes the CM subcomponents as well
+- Bugfix: added extra null checks to support cases where current vcam is dynamically deleted
+- Bugfix: reset BlendList when enabled
+- Regression fix: FreeLook axis values get transferred when similar vcams transition
+- Bugfix: cutting to BlendList vcam sometimes produced a few bad frames
+- Bugfix: smart update tracks the targets more efficiently and correctly, and supports RigidBody interpolation (2018.2 and up)
+- Enhancement: POV component interprets POV as relative to parent transform if there is one
+- API change: OnCameraLive and CameraActivated events take outgoing vcam also as parameter (may be null)
+
+<size=20><b>Version 2.2.0</b></size>
+
+- New Cinemachine Impulse module for event-driven camera shakes
+- New Event Helper script CinemachineTriggerAction takes action on Collider and Collider2D enter/exit events, and exposes them as UnityEvents
+- New performance-tuning feature: Standby Update. Controls how often to update the vcam when it's in Standby.
+- New NoiseSettings editor with signal preview
+- Added Focal Length or Named FOV presets for Camera Lens
+- Added support for Physical Camera: focal length and Lens Offset
+- New improved Group framing algorithm: tighter group framing in GroupComposer and FramingTransposer
+- Collider: now returns TargetIsObscured if the target is offscreen (great for cameras with fixed aim)
+- Collider: added Minimum Occlusion Time setting, to ignore fleeting obstructions
+- Collider: added Transparent Layers mask, to specify solid objects that don't obstruct view
+- Collider: damping will no longer take the camera through obstacles
+- Collider: Added separate damping setting for when target is being occluded vs when camera is being returned to its normal position
+- Collider: added Smoothing setting, to reduce camera jumpiness in environements with lots of obstacles
+- NoiseSettings: added checkbox for pure sine-wave instead of Perlin wave
+- If no LookAt target, PostProcessing FocusTracksTarget offset is relative to camera
+- TrackedDolly: Default up mode sets Up to World Up
+- Virtual Camera: New Transitions section in inspector that gives more control over blending:
+ - Blend Hint provides some control over how the position and rotation are interpolated
+ - Inherit Position checkbox to ensure smooth positional handoff from outgoing camera
+ - OnCameraLive event gets fired when the camera activates. Useful for custom handlers.
+- Added ScreenSpaceAimWhenTargetsDiffer as a vcam blend hint. This influences what happens when blending between vcams with different LookAt targets
+- Increased stability of vcams with very small FOVs
+- Framing Transposer no longer requires LookAt to be null
+- LensSettings Aspect, Orthographic, IsPhysicalCamera, SensorSize properties no longer internal
+- Noise Profiles: don't magically create assets. Prompt user for filename and location of new or cloned profiles
+- Refactored interaction between timeline and CM brain, to improve handling of edge cases (fogbugz case 1048497)
+- Bugfix: StateDrivenCamera Editor was not finding states if target was OverrideController
+- Bugfix when dragging orbital transposer transform: take bias into account
+- Bugfix: SaveDuringPlay was not handling asset fields correctly - was sometimes crushing assets
+- Bugfix: SimpleFollow transposers were not initilizing their position correctly at game start
+- Bugfix: Timeline with CM shot was causing jitter in some FixedUpdate situations
+- Bugfix: Multiple brains with heterogeneous update methods were not behaving correctly. CM will now support this, but you must make sure that the brains have different layer masks.
+- Example scenes now include use of CinemachineTriggerAction script.
+
+<size=20><b>Version 2.1.13</b></size>
+
+- Bugfix: Custom Blends "Any to Any" was not working (regression)
+- Bugfix: Composer was sometimes getting wrong aspect if multiple brains with different aspect ratios
+- Bugfix: could not drag vcam transforms if multiple inspectors and one is hidden
+- Bugfix: Framing Transposer initializes in the wrong place - noticeable if dead zone
+
+<size=20><b>Version 2.1.12</b></size>
+
+- Project restructure: Removed Base, Timeline, and PostFX folders from project root. PostProcessing code must now be manually imported from Cinemachine menu. No more dependencies on scripting defines.
+- New Storyboard extension, to display images over the vcams. Comes with a Waveform monitor window for color grading
+- New option to specify vcam position blend style: linear, spherical, or cylindrical, based on LookAt target
+- Added API to support seamless position warping of target objects: OnTargetObjectWarped().
+- Added support for custom blend curves
+- Lookahead: added Ignore Y Axis Movement option
+- Added support for cascading blends (i.e. blending from mid-blend looks better)
+- POV/Orbital/FreeLook axis: exposed Min, Max, and Wrap in the UI, for customized axis range
+- FreeLook: added Y Axis recentering
+- Added recentering feature to both axes POV Aim component
+- Path: Added Normalized Path units option: 0 is start of path, 1 is end.
+- Path: added length display in inspector
+- Timeline Clip Editor: vcam sections are now collapsible
+- API enhancement: added Finalize to Pipeline stages, called even for manager-style vcams
+- Bugfix: PostProcessing V2 DoF blending works better
+- Bugfix: OrbitalTransposer works better with WorldUp overrides
+- Bugfix: Remove StateDrivenCamera "not playing a controller" warning
+- Bugfix: Handle exceptions thrown by assemblies that don't want to be introspected
+- Bugfix: vcams following physics objects incorrectly snapped to origin after exiting play mode
+- Bugfix: predictor now supports time pause
+- Bugfix: Moved StartCoroutine in Brain to OnEnable()
+- Bugfix: Collider was causing problems in Physics on Android platforms
+- Bugfix: dragging a vcam's position updtaes prefabs properly
+- Bugfix: All extension now respect the "enabled" checkbox
+- Bugfix: Undo for Extasion add will no longer generate null references
+
+<size=20><b>Version 2.1.10</b></size>
+
+- New Aim component: Same As Follow Target simply uses the same orientation as the Follow target
+- Perlin Noise component: added UI to clone or locate existing Noise profiles, and to create new ones inspector
+- Noise Presets were moved outside of the Examples folder
+- Example Assets are now included as embedded package, not imported by default
+- Bugfix: FreeLook with PositionDelta was not properly updating the heading
+- Bugfix: Transitioning between FreeLooks simetimes caused a short camera freeze
+- Bugfix: Added some null checks to FreeLook, to prevent error messages at build time
+
+
+<size=20><b>Version 2.1.09</b></size>
+
+<size=12><b>New Features</b></size>
+
+- <b>PostProcessing V2</b> is now supported.
+- New <b>Collider</b> implementation. Curb feelers are gone, replaced by a clever camera-repositioning algorithm that will try to preserve camera height or distance from target (strategy is user-selectable).
+- New <b>CinemachineConfiner</b>: confine a virtual camera to a simple bounding volume or PolygonCollider2D.
+- New <b>Framing Transposer</b>. This is a special transposer that will respect composition and framing rules by moving the camera without rotating it. Takes only a Follow Target (no LookAt - this is important). Designed for Orthographic cameras, but will also work for Perspective cameras. If Follow target is a CinemachineTargetGroup, then will also provide Group Framing options.
+- New <b>CinemachinePOV</b> Aim component. Camera aim is entirely controlled by user, using 2 input axes.
+- New <b>CinemachineMixingCamera</b>. Drive a continuous blend of up to 8 virtual cameras from timeline or game logic. Create complex rigs with custom blends and expose them as ordinary vcams.
+- New <b>CinemachineBlendListCamera</b>. A mini vcam sequencer that provides a quick and easy way to do AB camera moves on the fly.
+- New <b>CinemachineDollyCart</b> behaviour, for moving anything along a path. No need to create dummy vcams just for that.
+- New <b>CinemachineSmoothPath</b> component. You can use it instead of the old CinemachinePath. The difference is that the SmoothPath guarantees second-order continuity, which means that there will never be any sudden camera rotation changes baked into the path tangents. Easier to use, too: no tangents to mess around with (they get automatically set for smoothness).
+- Path now supports <b>Distance Units</b> in addition to Path units, making it easy to create steady motion.
+- TrackedDolly: added ability to use <b>Distance or Path units</b> for path position.
+- Transposer and TrackedDolly: added target <b>angular damping</b> on 3 axes.
+- OrbitalTransposer and FreeLook: added <b>angular damping and binding mode</b>, same as Transposer.
+- OrbitalTransopser and freelook: added checkbox to <b>invert input axis</b>.
+- Transposer, OrbitalTransposer, and FreeLook: added new <b>Simple Follow</b> binding mode, which will follow the target using rotation as much as possible, changing position as little as possible. Like a lazy cameraman.
+- Added <b>IgnoreTimeScale</b> option to Brain. Useful for snappy cameras even in slo-mo.
+- Added <b>Lookahead Time</b> to composer. Composer will look at the point where it estimates the target will be at some time in the near future. This gives much more natural framing of a moving target.
+
+
+<size=12><b>Improvements</b></size>
+
+- SmartUpdate is smarter: added support for <b>Interpolation</b> when target is animated by physics system.
+- Added off-button for SaveDuringPlay.
+- No SaveDuringPlay for vcam priority, LookAt and Follow targets, GroupTarget members.
+- Added IsBlending API method to StateDrivenCamera and ClearShot.
+- TargetGroup now has a user-selectable update method.
+- TargetGroup now respects the weight when computing bounding box, so it's possible to gradually add or remove members by manipulating the weight.
+- Clearshot: if randomize, then re-randomize whenever it becomes active.
+- ClearShot: default blend is cut.
+- ClearShot create menu: add a Collider by default.
+- FollowZoom: min/max FOV defaults changed to 3/60.
+- Composer damping range is now 0-20 instead of 0-100.
+- Orbital and FreeLook: Heading Bias can now be animated on the timeline.
+- Orbital and FreeLook: damping no longer interferes with camera response to user input. Axis movement bypasses all damping.
+- TrackedDolly: added path position offset to Auto-Dolly. Stays on the path (unlike path offset, which is based on the path tangent and so can go off the path)
+- Noise component inspector now has a dropdown for Profile presets, instead of directly allowing editing of the Profile asset.
+- Added concept of <b>Cinemachine Extension</b>. Collider, confiner, PostProcessing, etc are now Extensions. They are available via a dropdown at the bottom of the inspection for virtual cameras. They will no longer appear in the standard Components menu.
+- Time.timeScale = 0 is now supported. Pausing the game will also pause the virtual cameras.
+- HardConstraint has been split into two settings: Do Nothing and Hard LookAt/Follow. Do Nothing will leave the camera's transform alone, ignoring any target that may have been set.
+- CinemachineBrain no longer requires a Camera component. Can be used with any GameObject, making it possible to use Cinemachine to control the transforms of arbitrary objects.
+- Improved logic for AxisState accel/decel. More realistic behaviour.
+
+
+<size=12><b>Bugfixes</b></size>
+
+- SaveDuringPlay obsolete API fix for 2017.2.
+- Fixed build errors when building for UWP.
+- Clearshot and SDC: don't reset state if deactivated.
+- FreeLook destroy - no more orphan rigs.
+- Fixed strange build error that only showed up in MonoDevelop.
+- FreeLook was not respecting X-axis accel and decel. Heading speed had to be crazy high. Now same as Orbital (warning: may have to re-tune settings on existing FreeLooks).
+- Recenter to target heading was not moving smoothly in some circumstances.
+- Collider raycasts no longer hit triggers.
+- Noise: handle variable deltaTime gracefully.
+- State-Driven-Camera: don't generate errors when animated target is inactive.
+- Several jitter and judder issues resolved.
--- /dev/null
+fileFormatVersion: 2
+guid: d9ca844c06be1ab40a3f7fc9e3c42c55
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: b8ba3923a6094cd48b85425f47fd7450
+TextureImporter:
+ fileIDToRecycleName: {}
+ externalObjects: {}
+ serializedVersion: 5
+ mipmaps:
+ mipMapMode: 1
+ enableMipMap: 1
+ sRGBTexture: 1
+ linearTexture: 0
+ fadeOut: 0
+ borderMipMap: 0
+ mipMapsPreserveCoverage: 0
+ alphaTestReferenceValue: 0.5
+ mipMapFadeDistanceStart: 1
+ mipMapFadeDistanceEnd: 3
+ bumpmap:
+ convertToNormalMap: 0
+ externalNormalMap: 0
+ heightScale: 0.25
+ normalMapFilter: 0
+ isReadable: 0
+ grayScaleToAlpha: 0
+ generateCubemap: 6
+ cubemapConvolution: 0
+ seamlessCubemap: 0
+ textureFormat: -1
+ maxTextureSize: 2048
+ textureSettings:
+ serializedVersion: 2
+ filterMode: -1
+ aniso: -1
+ mipBias: -1
+ wrapU: -1
+ wrapV: -1
+ wrapW: -1
+ nPOTScale: 1
+ lightmap: 0
+ compressionQuality: 50
+ spriteMode: 0
+ spriteExtrude: 1
+ spriteMeshType: 1
+ alignment: 0
+ spritePivot: {x: 0.5, y: 0.5}
+ spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+ spritePixelsToUnits: 100
+ alphaUsage: 1
+ alphaIsTransparency: 0
+ spriteTessellationDetail: -1
+ textureType: 0
+ textureShape: 1
+ singleChannelComponent: 0
+ maxTextureSizeSet: 0
+ compressionQualitySet: 0
+ textureFormatSet: 0
+ platformSettings:
+ - serializedVersion: 2
+ buildTarget: DefaultTexturePlatform
+ maxTextureSize: 2048
+ resizeAlgorithm: 0
+ textureFormat: -1
+ textureCompression: 1
+ compressionQuality: 50
+ crunchedCompression: 0
+ allowsAlphaSplitting: 0
+ overridden: 0
+ androidETC2FallbackOverride: 0
+ - serializedVersion: 2
+ buildTarget: Standalone
+ maxTextureSize: 2048
+ resizeAlgorithm: 0
+ textureFormat: -1
+ textureCompression: 1
+ compressionQuality: 50
+ crunchedCompression: 0
+ allowsAlphaSplitting: 0
+ overridden: 0
+ androidETC2FallbackOverride: 0
+ spriteSheet:
+ serializedVersion: 2
+ sprites: []
+ outline: []
+ physicsShape: []
+ bones: []
+ spriteID:
+ vertices: []
+ indices:
+ edges: []
+ weights: []
+ spritePackingTag:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+Cinemachine copyright © 2018 Unity Technologies ApS
+
+Licensed under the Unity Companion License for Unity-dependent projects--see [Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License).
+
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
--- /dev/null
+fileFormatVersion: 2
+guid: c0d6910df7c989c4abc7d5ddf0e421b2
+TextScriptImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 9f96161bfc85a364aac3baa0b7279f94
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 8f107aadf823af24889bc290a1cca90d
+folderAsset: yes
+timeCreated: 1455314775
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+ m_ObjectHideFlags: 0
+ m_PrefabParentObject: {fileID: 0}
+ m_PrefabInternal: {fileID: 0}
+ m_GameObject: {fileID: 0}
+ m_Enabled: 1
+ m_EditorHideFlags: 0
+ m_Script: {fileID: 11500000, guid: b7f59e54f2bfd184b9dd451a678d089b, type: 3}
+ m_Name: 6D Shake
+ m_EditorClassIdentifier:
+ PositionNoise:
+ - X:
+ Frequency: 3.2
+ Amplitude: 0.011
+ Constant: 1
+ Y:
+ Frequency: 1.9
+ Amplitude: 0.059
+ Constant: 1
+ Z:
+ Frequency: 3.33
+ Amplitude: 0.021
+ Constant: 1
+ - X:
+ Frequency: 7.7
+ Amplitude: 0.009
+ Constant: 1
+ Y:
+ Frequency: 9.1
+ Amplitude: 0.04
+ Constant: 0
+ Z:
+ Frequency: 9.22
+ Amplitude: 0.009
+ Constant: 1
+ - X:
+ Frequency: 51.51
+ Amplitude: 0.002
+ Constant: 1
+ Y:
+ Frequency: 55.54
+ Amplitude: 0.05
+ Constant: 1
+ Z:
+ Frequency: 58.55
+ Amplitude: 0.017
+ Constant: 1
+ OrientationNoise:
+ - X:
+ Frequency: 5.83
+ Amplitude: 0.09
+ Constant: 1
+ Y:
+ Frequency: 1.8
+ Amplitude: 0.059
+ Constant: 1
+ Z:
+ Frequency: 2.38
+ Amplitude: 0.017
+ Constant: 1
+ - X:
+ Frequency: 9.17
+ Amplitude: 0.14
+ Constant: 1
+ Y:
+ Frequency: 11.35
+ Amplitude: 0.041
+ Constant: 1
+ Z:
+ Frequency: 10.52
+ Amplitude: 0.009
+ Constant: 1
+ - X:
+ Frequency: 57.17
+ Amplitude: 0.15
+ Constant: 1
+ Y:
+ Frequency: 54.17
+ Amplitude: 0.048
+ Constant: 1
+ Z:
+ Frequency: 63.76
+ Amplitude: 0.016
+ Constant: 1
--- /dev/null
+fileFormatVersion: 2
+guid: 69ce8388f6785dd4c8c39915efece2f4
+timeCreated: 1518036470
+licenseType: Pro
+NativeFormatImporter:
+ externalObjects: {}
+ mainObjectFileID: 11400000
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+ m_ObjectHideFlags: 0
+ m_PrefabParentObject: {fileID: 0}
+ m_PrefabInternal: {fileID: 0}
+ m_GameObject: {fileID: 0}
+ m_Enabled: 1
+ m_EditorHideFlags: 0
+ m_Script: {fileID: 11500000, guid: b7f59e54f2bfd184b9dd451a678d089b, type: 3}
+ m_Name: Handheld_normal_extreme
+ m_EditorClassIdentifier:
+ m_Position: []
+ m_Orientation:
+ - X:
+ Amplitude: 15
+ Frequency: 0.2
+ Y:
+ Amplitude: 7
+ Frequency: 0.25
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 5
+ Frequency: 0.9
+ Y:
+ Amplitude: 3
+ Frequency: 1
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 2
+ Frequency: 2
+ Y:
+ Amplitude: 1
+ Frequency: 0
+ Z:
+ Amplitude: 0
+ Frequency: 0
--- /dev/null
+fileFormatVersion: 2
+guid: 20a705aea2d80e0478fb89b6f43d8530
+timeCreated: 1465497741
+licenseType: Pro
+NativeFormatImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+ m_ObjectHideFlags: 0
+ m_PrefabParentObject: {fileID: 0}
+ m_PrefabInternal: {fileID: 0}
+ m_GameObject: {fileID: 0}
+ m_Enabled: 1
+ m_EditorHideFlags: 0
+ m_Script: {fileID: 11500000, guid: b7f59e54f2bfd184b9dd451a678d089b, type: 3}
+ m_Name: Handheld_normal_mild
+ m_EditorClassIdentifier:
+ m_Position: []
+ m_Orientation:
+ - X:
+ Amplitude: 7
+ Frequency: 0.15
+ Y:
+ Amplitude: 5
+ Frequency: 0.1
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 4
+ Frequency: 0.8
+ Y:
+ Amplitude: 2
+ Frequency: 0.75
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 1
+ Frequency: 1.2
+ Y:
+ Amplitude: 0.8
+ Frequency: 1.5
+ Z:
+ Amplitude: 0
+ Frequency: 0
--- /dev/null
+fileFormatVersion: 2
+guid: 46965f9cbaf525742a6da4c2172a99cd
+timeCreated: 1461691296
+licenseType: Pro
+NativeFormatImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+ m_ObjectHideFlags: 0
+ m_PrefabParentObject: {fileID: 0}
+ m_PrefabInternal: {fileID: 0}
+ m_GameObject: {fileID: 0}
+ m_Enabled: 1
+ m_EditorHideFlags: 0
+ m_Script: {fileID: 11500000, guid: b7f59e54f2bfd184b9dd451a678d089b, type: 3}
+ m_Name: Handheld_normal_strong
+ m_EditorClassIdentifier:
+ m_Position: []
+ m_Orientation:
+ - X:
+ Amplitude: 10
+ Frequency: .400000006
+ Y:
+ Amplitude: 10
+ Frequency: .0599999987
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 5
+ Frequency: 1.44000006
+ Y:
+ Amplitude: 3
+ Frequency: .730000019
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 3
+ Frequency: 2.49000001
+ Y:
+ Amplitude: 1
+ Frequency: 2
+ Z:
+ Amplitude: 0
+ Frequency: 0
--- /dev/null
+fileFormatVersion: 2
+guid: b241f91b9ccf8ff489abf204b30d3112
+timeCreated: 1461691296
+licenseType: Pro
+NativeFormatImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+ m_ObjectHideFlags: 0
+ m_PrefabParentObject: {fileID: 0}
+ m_PrefabInternal: {fileID: 0}
+ m_GameObject: {fileID: 0}
+ m_Enabled: 1
+ m_EditorHideFlags: 0
+ m_Script: {fileID: 11500000, guid: b7f59e54f2bfd184b9dd451a678d089b, type: 3}
+ m_Name: Handheld_tele_mild
+ m_EditorClassIdentifier:
+ m_Position: []
+ m_Orientation:
+ - X:
+ Amplitude: 4
+ Frequency: .200000003
+ Y:
+ Amplitude: 2
+ Frequency: .150000006
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 2
+ Frequency: .400000006
+ Y:
+ Amplitude: 2
+ Frequency: .5
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 1
+ Frequency: .699999988
+ Y:
+ Amplitude: 1
+ Frequency: .600000024
+ Z:
+ Amplitude: 0
+ Frequency: 0
--- /dev/null
+fileFormatVersion: 2
+guid: a3dacaec0287d7444b4bd276816e1666
+timeCreated: 1461691921
+licenseType: Pro
+NativeFormatImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+ m_ObjectHideFlags: 0
+ m_PrefabParentObject: {fileID: 0}
+ m_PrefabInternal: {fileID: 0}
+ m_GameObject: {fileID: 0}
+ m_Enabled: 1
+ m_EditorHideFlags: 0
+ m_Script: {fileID: 11500000, guid: b7f59e54f2bfd184b9dd451a678d089b, type: 3}
+ m_Name: Handheld_tele_strong
+ m_EditorClassIdentifier:
+ m_Position: []
+ m_Orientation:
+ - X:
+ Amplitude: 6.19000006
+ Frequency: .389999986
+ Y:
+ Amplitude: 4
+ Frequency: .150000006
+ Z:
+ Amplitude: 1
+ Frequency: .100000001
+ - X:
+ Amplitude: 1.84000003
+ Frequency: 1.75
+ Y:
+ Amplitude: .5
+ Frequency: .899999976
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 2.29999995
+ Frequency: 2
+ Y:
+ Amplitude: .5
+ Frequency: 1.39999998
+ Z:
+ Amplitude: 0
+ Frequency: 0
--- /dev/null
+fileFormatVersion: 2
+guid: 554b0ed52734c154eab51f6cedd3a7d7
+timeCreated: 1461691296
+licenseType: Pro
+NativeFormatImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+ m_ObjectHideFlags: 0
+ m_PrefabParentObject: {fileID: 0}
+ m_PrefabInternal: {fileID: 0}
+ m_GameObject: {fileID: 0}
+ m_Enabled: 1
+ m_EditorHideFlags: 0
+ m_Script: {fileID: 11500000, guid: b7f59e54f2bfd184b9dd451a678d089b, type: 3}
+ m_Name: Handheld_wideangle_mild
+ m_EditorClassIdentifier:
+ m_Position: []
+ m_Orientation:
+ - X:
+ Amplitude: 12
+ Frequency: .150000006
+ Y:
+ Amplitude: 5
+ Frequency: .100000001
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 5
+ Frequency: .600000024
+ Y:
+ Amplitude: 4
+ Frequency: .449999988
+ Z:
+ Amplitude: 0
+ Frequency: 0
+ - X:
+ Amplitude: 1
+ Frequency: 1.5
+ Y:
+ Amplitude: 1
+ Frequency: 1.20000005
+ Z:
+ Amplitude: 0
+ Frequency: 0
--- /dev/null
+fileFormatVersion: 2
+guid: 8608ec81ee27a15488d33f9dad239e91
+timeCreated: 1461691111
+licenseType: Pro
+NativeFormatImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+ m_ObjectHideFlags: 0
+ m_PrefabParentObject: {fileID: 0}
+ m_PrefabInternal: {fileID: 0}
+ m_GameObject: {fileID: 0}
+ m_Enabled: 1
+ m_EditorHideFlags: 0
+ m_Script: {fileID: 11500000, guid: b7f59e54f2bfd184b9dd451a678d089b, type: 3}
+ m_Name: Handheld_wideangle_strong
+ m_EditorClassIdentifier:
+ m_Position: []
+ m_Orientation:
+ - X:
+ Amplitude: 17.4599991
+ Frequency: .5
+ Y:
+ Amplitude: 5
+ Frequency: .25
+ Z:
+ Amplitude: 0
+ Frequency: .100000001
+ - X:
+ Amplitude: 12.4700003
+ Frequency: .939999998
+ Y:
+ Amplitude: 4
+ Frequency: .5
+ Z:
+ Amplitude: 1
+ Frequency: .400000006
+ - X:
+ Amplitude: 4
+ Frequency: 1.20000005
+ Y:
+ Amplitude: 2
+ Frequency: 1.29999995
+ Z:
+ Amplitude: 0
+ Frequency: 0
--- /dev/null
+fileFormatVersion: 2
+guid: 20e46be82478fa24b90f748044c06b4b
+timeCreated: 1461691111
+licenseType: Pro
+NativeFormatImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+# Cinemachine
+
+## What is Cinemachine?
+Cinemachine is a suite of ‘smart’ procedural modules which allow you to define the shot and
+they’ll dynamically follow your direction. Set up shots which track and compose motion in
+realtime, like AI camera operators. The procedural nature makes them bug-resistant as they
+always work to make the shot based on your direction. They’re great for gameplay, but they’re
+also amazingly fast for cutscenes. Change an animation, a vehicle speed, ground terrain -
+whatever - and Cinemachine will dynamically make the shot. You can use really telephoto
+lenses and not have to update the cutscene if things change.
+
+## Setup
+Cinemachine works out of the box with no dependencies other than Unity itself.
+Just install it and you're ready to go. It's pure c-sharp, fully open-source,
+and the public API has complete XML documentation built right in.
+
+## History
+Cinemachine has been in development over a number of years across multiple projects. We’ve
+been designing camera systems for almost 20 years and have shipped millions of AAA titles
+across numerous genres. The Cinemachine team has an award winning cinematographer and
+a senior engineer with heavy math skills. Also, we love this stuff to bits.
+
+## Mission
+Our mission with Cinemachine is to build an entirely unifed camera system bridging
+gameplay, cutscenes, from fully procedural cameras to entirely canned sequences and
+everything in between.
+
+## Example Scenes
+Please have a look at our example scenes. They are shipped with the package and can be imported
+via the Cinemachine menu.
+
+## Forums
+We have a busy discussion area on the forums.
+https://forum.unity3d.com/forums/cinemachine.136/
+
--- /dev/null
+fileFormatVersion: 2
+guid: 7e37f2a64474b3948b3a169780e54779
+TextScriptImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: e8413e2c94231d544b120f2b71d432e2
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System.Runtime.CompilerServices;
+[assembly: InternalsVisibleTo("com.unity.cinemachine.editor")]
\ No newline at end of file
--- /dev/null
+fileFormatVersion: 2
+guid: c64ec1fa74cb7174da4b9f561a7dffe1
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: fd10c4a322c950342a9d03a14ae879b7
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a virtual camera "manager" that owns and manages a collection
+ /// of child Virtual Cameras. When the camera goes live, these child vcams
+ /// are enabled, one after another, holding each camera for a designated time.
+ /// Blends between cameras are specified.
+ /// The last camera is held indefinitely.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineBlendListCamera")]
+ public class CinemachineBlendListCamera : CinemachineVirtualCameraBase
+ {
+ /// <summary>Default object for the camera children to look at (the aim target), if not specified in a child rig. May be empty</summary>
+ [Tooltip("Default object for the camera children to look at (the aim target), if not specified in a child camera. May be empty if all of the children define targets of their own.")]
+ [NoSaveDuringPlay]
+ public Transform m_LookAt = null;
+
+ /// <summary>Default object for the camera children wants to move with (the body target), if not specified in a child rig. May be empty</summary>
+ [Tooltip("Default object for the camera children wants to move with (the body target), if not specified in a child camera. May be empty if all of the children define targets of their own.")]
+ [NoSaveDuringPlay]
+ public Transform m_Follow = null;
+
+ /// <summary>When enabled, the current camera and blend will be indicated in the game window, for debugging</summary>
+ [Tooltip("When enabled, the current child camera and blend will be indicated in the game window, for debugging")]
+ public bool m_ShowDebugText = false;
+
+ /// <summary>When enabled, the child vcams will cycle indefinitely instead of just stopping at the last onesummary>
+ [Tooltip("When enabled, the child vcams will cycle indefinitely instead of just stopping at the last one")]
+ public bool m_Loop = false;
+
+ /// <summary>Internal API for the editor. Do not use this field</summary>
+ [SerializeField][HideInInspector][NoSaveDuringPlay]
+ internal CinemachineVirtualCameraBase[] m_ChildCameras = null;
+
+ /// <summary>This represents a single entry in the instrunction list of the BlendListCamera.</summary>
+ [Serializable]
+ public struct Instruction
+ {
+ /// <summary>The virtual camera to activate when this instruction becomes active</summary>
+ [Tooltip("The virtual camera to activate when this instruction becomes active")]
+ public CinemachineVirtualCameraBase m_VirtualCamera;
+ /// <summary>How long to wait (in seconds) before activating the next virtual camera in the list (if any)</summary>
+ [Tooltip("How long to wait (in seconds) before activating the next virtual camera in the list (if any)")]
+ public float m_Hold;
+ /// <summary>How to blend to the next virtual camera in the list (if any)</summary>
+ [CinemachineBlendDefinitionProperty]
+ [Tooltip("How to blend to the next virtual camera in the list (if any)")]
+ public CinemachineBlendDefinition m_Blend;
+ };
+
+ /// <summary>The set of instructions associating virtual cameras with states.
+ /// The set of instructions for enabling child cameras</summary>
+ [Tooltip("The set of instructions for enabling child cameras.")]
+ public Instruction[] m_Instructions;
+
+ /// <summary>Gets a brief debug description of this virtual camera, for use when displayiong debug info</summary>
+ public override string Description
+ {
+ get
+ {
+ // Show the active camera and blend
+ if (mActiveBlend != null)
+ return mActiveBlend.Description;
+
+ ICinemachineCamera vcam = LiveChild;
+ if (vcam == null)
+ return "(none)";
+ var sb = CinemachineDebug.SBFromPool();
+ sb.Append("["); sb.Append(vcam.Name); sb.Append("]");
+ string text = sb.ToString();
+ CinemachineDebug.ReturnToPool(sb);
+ return text;
+ }
+ }
+
+ /// <summary>Get the current "best" child virtual camera, that would be chosen
+ /// if the State Driven Camera were active.</summary>
+ public ICinemachineCamera LiveChild { set; get; }
+
+ /// <summary>Check whether the vcam a live child of this camera.</summary>
+ /// <param name="vcam">The Virtual Camera to check</param>
+ /// <param name="dominantChildOnly">If truw, will only return true if this vcam is the dominat live child</param>
+ /// <returns>True if the vcam is currently actively influencing the state of this vcam</returns>
+ public override bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false)
+ {
+ return vcam == LiveChild || (mActiveBlend != null && mActiveBlend.Uses(vcam));
+ }
+
+ /// <summary>The State of the current live child</summary>
+ public override CameraState State { get { return m_State; } }
+
+ /// <summary>Get the current LookAt target. Returns parent's LookAt if parent
+ /// is non-null and no specific LookAt defined for this camera</summary>
+ override public Transform LookAt
+ {
+ get { return ResolveLookAt(m_LookAt); }
+ set { m_LookAt = value; }
+ }
+
+ /// <summary>Get the current Follow target. Returns parent's Follow if parent
+ /// is non-null and no specific Follow defined for this camera</summary>
+ override public Transform Follow
+ {
+ get { return ResolveFollow(m_Follow); }
+ set { m_Follow = value; }
+ }
+
+ /// <summary>This is called to notify the vcam that a target got warped,
+ /// so that the vcam can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ UpdateListOfChildren();
+ foreach (var vcam in m_ChildCameras)
+ vcam.OnTargetObjectWarped(target, positionDelta);
+ base.OnTargetObjectWarped(target, positionDelta);
+ }
+
+ /// <summary>Notification that this virtual camera is going live.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ mActivationTime = Time.time;
+ mCurrentInstruction = 0;
+ LiveChild = null;
+ mActiveBlend = null;
+ TransitioningFrom = fromCam;
+ InternalUpdateCameraState(worldUp, deltaTime);
+ }
+
+ ICinemachineCamera TransitioningFrom { get; set; }
+
+ /// <summary>Called by CinemachineCore at designated update time
+ /// so the vcam can position itself and track its targets. This implementation
+ /// updates all the children, chooses the best one, and implements any required blending.</summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ if (!PreviousStateIsValid)
+ deltaTime = -1;
+
+ UpdateListOfChildren();
+ AdvanceCurrentInstruction(deltaTime);
+
+ CinemachineVirtualCameraBase best = null;
+ if (mCurrentInstruction >= 0 && mCurrentInstruction < m_Instructions.Length)
+ best = m_Instructions[mCurrentInstruction].m_VirtualCamera;
+
+ if (best != null)
+ {
+ if (!best.gameObject.activeInHierarchy)
+ {
+ best.gameObject.SetActive(true);
+ best.UpdateCameraState(worldUp, deltaTime);
+ }
+ ICinemachineCamera previousCam = LiveChild;
+ LiveChild = best;
+
+ // Are we transitioning cameras?
+ if (previousCam != LiveChild && LiveChild != null)
+ {
+ // Notify incoming camera of transition
+ LiveChild.OnTransitionFromCamera(previousCam, worldUp, deltaTime);
+
+ // Generate Camera Activation event in the brain if live
+ CinemachineCore.Instance.GenerateCameraActivationEvent(LiveChild, previousCam);
+
+ if (previousCam != null)
+ {
+ // Create a blend (will be null if a cut)
+ mActiveBlend = CreateBlend(
+ previousCam, LiveChild,
+ m_Instructions[mCurrentInstruction].m_Blend,
+ mActiveBlend);
+
+ // If cutting, generate a camera cut event if live
+ if (mActiveBlend == null || !mActiveBlend.Uses(previousCam))
+ CinemachineCore.Instance.GenerateCameraCutEvent(LiveChild);
+ }
+ }
+ }
+
+ // Advance the current blend (if any)
+ if (mActiveBlend != null)
+ {
+ mActiveBlend.TimeInBlend += (deltaTime >= 0) ? deltaTime : mActiveBlend.Duration;
+ if (mActiveBlend.IsComplete)
+ mActiveBlend = null;
+ }
+
+ if (mActiveBlend != null)
+ {
+ mActiveBlend.UpdateCameraState(worldUp, deltaTime);
+ m_State = mActiveBlend.State;
+ }
+ else if (LiveChild != null)
+ {
+ if (TransitioningFrom != null)
+ LiveChild.OnTransitionFromCamera(TransitioningFrom, worldUp, deltaTime);
+ m_State = LiveChild.State;
+ }
+ TransitioningFrom = null;
+ InvokePostPipelineStageCallback(
+ this, CinemachineCore.Stage.Finalize, ref m_State, deltaTime);
+ PreviousStateIsValid = true;
+ }
+
+ /// <summary>Makes sure the internal child cache is up to date</summary>
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ InvalidateListOfChildren();
+ LiveChild = null;
+ mActiveBlend = null;
+ CinemachineDebug.OnGUIHandlers -= OnGuiHandler;
+ CinemachineDebug.OnGUIHandlers += OnGuiHandler;
+ }
+
+ protected override void OnDisable()
+ {
+ base.OnDisable();
+ CinemachineDebug.OnGUIHandlers -= OnGuiHandler;
+ }
+
+ /// <summary>Makes sure the internal child cache is up to date</summary>
+ void OnTransformChildrenChanged()
+ {
+ InvalidateListOfChildren();
+ }
+
+ /// Will only be called if Unity Editor - never in build
+ private void OnGuiHandler()
+ {
+ if (!m_ShowDebugText)
+ CinemachineDebug.ReleaseScreenPos(this);
+ else
+ {
+ var sb = CinemachineDebug.SBFromPool();
+ sb.Append(Name); sb.Append(": "); sb.Append(Description);
+ string text = sb.ToString();
+ Rect r = CinemachineDebug.GetScreenPos(this, text, GUI.skin.box);
+ GUI.Label(r, text, GUI.skin.box);
+ CinemachineDebug.ReturnToPool(sb);
+ }
+ }
+
+ CameraState m_State = CameraState.Default;
+
+ /// <summary>The list of child cameras. These are just the immediate children in the hierarchy.</summary>
+ public CinemachineVirtualCameraBase[] ChildCameras { get { UpdateListOfChildren(); return m_ChildCameras; }}
+
+ /// <summary>Is there a blend in progress?</summary>
+ public bool IsBlending { get { return mActiveBlend != null; } }
+
+ /// <summary>The time at which the current instruction went live</summary>
+ float mActivationTime = -1;
+ int mCurrentInstruction = 0;
+ private CinemachineBlend mActiveBlend = null;
+
+ void InvalidateListOfChildren() { m_ChildCameras = null; LiveChild = null; }
+
+ void UpdateListOfChildren()
+ {
+ if (m_ChildCameras != null)
+ return;
+ List<CinemachineVirtualCameraBase> list = new List<CinemachineVirtualCameraBase>();
+ CinemachineVirtualCameraBase[] kids = GetComponentsInChildren<CinemachineVirtualCameraBase>(true);
+ foreach (CinemachineVirtualCameraBase k in kids)
+ if (k.transform.parent == transform)
+ list.Add(k);
+ m_ChildCameras = list.ToArray();
+ ValidateInstructions();
+ }
+
+ /// <summary>Internal API for the inspector editor.</summary>
+ /// // GML todo: make this private, part of UpdateListOfChildren()
+ internal void ValidateInstructions()
+ {
+ if (m_Instructions == null)
+ m_Instructions = new Instruction[0];
+ for (int i = 0; i < m_Instructions.Length; ++i)
+ {
+ if (m_Instructions[i].m_VirtualCamera != null
+ && m_Instructions[i].m_VirtualCamera.transform.parent != transform)
+ {
+ m_Instructions[i].m_VirtualCamera = null;
+ }
+ }
+ mActiveBlend = null;
+ }
+
+ private void AdvanceCurrentInstruction(float deltaTime)
+ {
+ if (m_ChildCameras == null || m_ChildCameras.Length == 0
+ || mActivationTime < 0 || m_Instructions.Length == 0)
+ {
+ mActivationTime = -1;
+ mCurrentInstruction = -1;
+ mActiveBlend = null;
+ return;
+ }
+
+ float now = Time.time;
+ if (mCurrentInstruction < 0 || deltaTime < 0)
+ {
+ mActivationTime = now;
+ mCurrentInstruction = 0;
+ }
+ if (mCurrentInstruction > m_Instructions.Length - 1)
+ {
+ mActivationTime = now;
+ mCurrentInstruction = m_Instructions.Length - 1;
+ }
+
+ var minHold = mCurrentInstruction < m_Instructions.Length - 1 || m_Loop ? 0 : float.MaxValue;
+ if (now - mActivationTime > Mathf.Max(minHold, m_Instructions[mCurrentInstruction].m_Hold))
+ {
+ mActivationTime = now;
+ ++mCurrentInstruction;
+ if (m_Loop && mCurrentInstruction == m_Instructions.Length)
+ mCurrentInstruction = 0;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 53258ad9ad6e71e48bb8643c9522112e
+timeCreated: 1509546373
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// CinemachineBrain is the link between the Unity Camera and the Cinemachine Virtual
+ /// Cameras in the scene. It monitors the priority stack to choose the current
+ /// Virtual Camera, and blend with another if necessary. Finally and most importantly,
+ /// it applies the Virtual Camera state to the attached Unity Camera.
+ ///
+ /// The CinemachineBrain is also the place where rules for blending between virtual cameras
+ /// are defined. Camera blending is an interpolation over time of one virtual camera
+ /// position and state to another. If you think of virtual cameras as cameramen, then
+ /// blending is a little like one cameraman smoothly passing the camera to another cameraman.
+ /// You can specify the time over which to blend, as well as the blend curve shape.
+ /// Note that a camera cut is just a zero-time blend.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+// [RequireComponent(typeof(Camera))] // strange but true: we can live without it
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineBrain")]
+ [SaveDuringPlay]
+ public class CinemachineBrain : MonoBehaviour
+ {
+ /// <summary>
+ /// When enabled, the current camera and blend will be indicated in the game window, for debugging.
+ /// </summary>
+ [Tooltip("When enabled, the current camera and blend will be indicated in the game window, for debugging")]
+ public bool m_ShowDebugText = false;
+
+ /// <summary>
+ /// When enabled, shows the camera's frustum in the scene view.
+ /// </summary>
+ [Tooltip("When enabled, the camera's frustum will be shown at all times in the scene view")]
+ public bool m_ShowCameraFrustum = true;
+
+ /// <summary>
+ /// When enabled, the cameras will always respond in real-time to user input and damping,
+ /// even if the game is running in slow motion
+ /// </summary>
+ [Tooltip("When enabled, the cameras will always respond in real-time to user input and damping, even if the game is running in slow motion")]
+ public bool m_IgnoreTimeScale = false;
+
+ /// <summary>
+ /// If set, this object's Y axis will define the worldspace Up vector for all the
+ /// virtual cameras. This is useful in top-down game environments. If not set, Up is worldspace Y.
+ /// </summary>
+ [Tooltip("If set, this object's Y axis will define the worldspace Up vector for all the virtual cameras. This is useful for instance in top-down game environments. If not set, Up is worldspace Y. Setting this appropriately is important, because Virtual Cameras don't like looking straight up or straight down.")]
+ public Transform m_WorldUpOverride;
+
+ /// <summary>This enum defines the options available for the update method.</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum UpdateMethod
+ {
+ /// <summary>Virtual cameras are updated in sync with the Physics module, in FixedUpdate</summary>
+ FixedUpdate,
+ /// <summary>Virtual cameras are updated in MonoBehaviour LateUpdate.</summary>
+ LateUpdate,
+ /// <summary>Virtual cameras are updated according to how the target is updated.</summary>
+ SmartUpdate
+ };
+
+ /// <summary>Depending on how the target objects are animated, adjust the update method to
+ /// minimize the potential jitter. Use FixedUpdate if all your targets are animated with for RigidBody animation.
+ /// SmartUpdate will choose the best method for each virtual camera, depending
+ /// on how the target is animated.</summary>
+ [Tooltip("Use FixedUpdate if all your targets are animated during FixedUpdate (e.g. RigidBodies), LateUpdate if all your targets are animated during the normal Update loop, and SmartUpdate if you want Cinemachine to do the appropriate thing on a per-target basis. SmartUpdate is the recommended setting")]
+ public UpdateMethod m_UpdateMethod = UpdateMethod.SmartUpdate;
+
+ /// <summary>
+ /// The blend which is used if you don't explicitly define a blend between two Virtual Cameras.
+ /// </summary>
+ [CinemachineBlendDefinitionProperty]
+ [Tooltip("The blend that is used in cases where you haven't explicitly defined a blend between two Virtual Cameras")]
+ public CinemachineBlendDefinition m_DefaultBlend
+ = new CinemachineBlendDefinition(CinemachineBlendDefinition.Style.EaseInOut, 2f);
+
+ /// <summary>
+ /// This is the asset which contains custom settings for specific blends.
+ /// </summary>
+ [Tooltip("This is the asset that contains custom settings for blends between specific virtual cameras in your scene")]
+ public CinemachineBlenderSettings m_CustomBlends = null;
+
+ /// <summary>
+ /// Get the Unity Camera that is attached to this GameObject. This is the camera
+ /// that will be controlled by the brain.
+ /// </summary>
+ public Camera OutputCamera
+ {
+ get
+ {
+ if (m_OutputCamera == null && !Application.isPlaying)
+ m_OutputCamera = GetComponent<Camera>();
+ return m_OutputCamera;
+ }
+ }
+ private Camera m_OutputCamera = null; // never use directly - use accessor
+
+ /// <summary>Event with a CinemachineBrain parameter</summary>
+ [Serializable] public class BrainEvent : UnityEvent<CinemachineBrain> {}
+
+ /// <summary>Event with a ICinemachineCamera parameter</summary>
+ [Serializable] public class VcamActivatedEvent : UnityEvent<ICinemachineCamera, ICinemachineCamera> {}
+
+ /// <summary>This event will fire whenever a virtual camera goes live and there is no blend</summary>
+ [Tooltip("This event will fire whenever a virtual camera goes live and there is no blend")]
+ public BrainEvent m_CameraCutEvent = new BrainEvent();
+
+ /// <summary>This event will fire whenever a virtual camera goes live. If a blend is involved,
+ /// then the event will fire on the first frame of the blend</summary>
+ [Tooltip("This event will fire whenever a virtual camera goes live. If a blend is involved, then the event will fire on the first frame of the blend.")]
+ public VcamActivatedEvent m_CameraActivatedEvent = new VcamActivatedEvent();
+
+ /// <summary>
+ /// API for the Unity Editor.
+ /// Show this camera no matter what. This is static, and so affects all Cinemachine brains.
+ /// </summary>
+ public static ICinemachineCamera SoloCamera
+ {
+ get { return mSoloCamera; }
+ set
+ {
+ if (value != null && !CinemachineCore.Instance.IsLive(value))
+ value.OnTransitionFromCamera(null, Vector3.up, Time.deltaTime);
+ mSoloCamera = value;
+ }
+ }
+
+ /// <summary>API for the Unity Editor.</summary>
+ /// <returns>Color used to indicate that a camera is in Solo mode.</returns>
+ public static Color GetSoloGUIColor() { return Color.Lerp(Color.red, Color.yellow, 0.8f); }
+
+ /// <summary>Get the default world up for the virtual cameras.</summary>
+ public Vector3 DefaultWorldUp
+ { get { return (m_WorldUpOverride != null) ? m_WorldUpOverride.transform.up : Vector3.up; } }
+
+ private static ICinemachineCamera mSoloCamera;
+ private Coroutine mPhysicsCoroutine;
+
+ private void OnEnable()
+ {
+ // Make sure there is a first stack frame
+ if (mFrameStack.Count == 0)
+ mFrameStack.Add(new BrainFrame());
+
+ m_OutputCamera = GetComponent<Camera>();
+ CinemachineCore.Instance.AddActiveBrain(this);
+ CinemachineDebug.OnGUIHandlers -= OnGuiHandler;
+ CinemachineDebug.OnGUIHandlers += OnGuiHandler;
+
+ // We check in after the physics system has had a chance to move things
+ mPhysicsCoroutine = StartCoroutine(AfterPhysics());
+ }
+
+ private void OnDisable()
+ {
+ CinemachineDebug.OnGUIHandlers -= OnGuiHandler;
+ CinemachineCore.Instance.RemoveActiveBrain(this);
+ mFrameStack.Clear();
+ StopCoroutine(mPhysicsCoroutine);
+ }
+
+ private void Start()
+ {
+ UpdateVirtualCameras(CinemachineCore.UpdateFilter.Late, -1f);
+ }
+
+ private void OnGuiHandler()
+ {
+ if (!m_ShowDebugText)
+ CinemachineDebug.ReleaseScreenPos(this);
+ else
+ {
+ // Show the active camera and blend
+ var sb = CinemachineDebug.SBFromPool();
+ Color color = GUI.color;
+ sb.Length = 0;
+ sb.Append("CM ");
+ sb.Append(gameObject.name);
+ sb.Append(": ");
+ if (SoloCamera != null)
+ {
+ sb.Append("SOLO ");
+ GUI.color = GetSoloGUIColor();
+ }
+
+ if (IsBlending)
+ sb.Append(ActiveBlend.Description);
+ else
+ {
+ ICinemachineCamera vcam = ActiveVirtualCamera;
+ if (vcam == null)
+ sb.Append("(none)");
+ else
+ {
+ sb.Append("[");
+ sb.Append(vcam.Name);
+ sb.Append("]");
+ }
+ }
+ string text = sb.ToString();
+ Rect r = CinemachineDebug.GetScreenPos(this, text, GUI.skin.box);
+ GUI.Label(r, text, GUI.skin.box);
+ GUI.color = color;
+ CinemachineDebug.ReturnToPool(sb);
+ }
+ }
+
+#if UNITY_EDITOR
+ private void OnGUI()
+ {
+ if (CinemachineDebug.OnGUIHandlers != null)
+ CinemachineDebug.OnGUIHandlers();
+ }
+#endif
+
+ WaitForFixedUpdate mWaitForFixedUpdate = new WaitForFixedUpdate();
+ private IEnumerator AfterPhysics()
+ {
+ while (true)
+ {
+ // FixedUpdate can be called multiple times per frame
+ yield return mWaitForFixedUpdate;
+ if (m_UpdateMethod != UpdateMethod.LateUpdate)
+ {
+ CinemachineCore.UpdateFilter filter = CinemachineCore.UpdateFilter.Fixed;
+ if (m_UpdateMethod == UpdateMethod.SmartUpdate)
+ {
+ // Track the targets
+ UpdateTracker.OnUpdate(UpdateTracker.UpdateClock.Fixed);
+ filter = CinemachineCore.UpdateFilter.SmartFixed;
+ }
+ UpdateVirtualCameras(filter, GetEffectiveDeltaTime(true));
+ }
+ }
+ }
+
+ private void LateUpdate()
+ {
+ float deltaTime = GetEffectiveDeltaTime(false);
+ UpdateFrame0(deltaTime);
+ UpdateCurrentLiveCameras();
+
+ if (m_UpdateMethod == UpdateMethod.FixedUpdate)
+ {
+ // Special handling for fixed update: cameras that have been enabled
+ // since the last physics frame must be updated now
+ CinemachineCore.Instance.CurrentUpdateFilter = CinemachineCore.UpdateFilter.Fixed;
+ if (SoloCamera != null)
+ SoloCamera.UpdateCameraState(DefaultWorldUp, deltaTime);
+ mCurrentLiveCameras.UpdateCameraState(DefaultWorldUp, deltaTime);
+ }
+ else
+ {
+ CinemachineCore.UpdateFilter filter = CinemachineCore.UpdateFilter.Late;
+ if (m_UpdateMethod == UpdateMethod.SmartUpdate)
+ {
+ // Track the targets
+ UpdateTracker.OnUpdate(UpdateTracker.UpdateClock.Late);
+ filter = CinemachineCore.UpdateFilter.SmartLate;
+ }
+ UpdateVirtualCameras(filter, deltaTime);
+ }
+ // Choose the active vcam and apply it to the Unity camera
+ ProcessActiveCamera(deltaTime);
+ }
+
+#if UNITY_EDITOR
+ /// This is only needed in editor mode to force timeline to call OnGUI while
+ /// timeline is up and the game is not running, in order to allow dragging
+ /// the composer guide in the game view.
+ private void OnPreCull()
+ {
+ if (!Application.isPlaying)
+ {
+ // Note: this call will cause any screen canvas attached to the camera
+ // to be painted one frame out of sync. It will only happen in the editor when not playing.
+ ProcessActiveCamera(GetEffectiveDeltaTime(false));
+ }
+ }
+#endif
+
+ private float GetEffectiveDeltaTime(bool fixedDelta)
+ {
+ if (SoloCamera != null)
+ return Time.unscaledDeltaTime;
+
+ if (!Application.isPlaying)
+ {
+ for (int i = mFrameStack.Count - 1; i > 0; --i)
+ {
+ var frame = mFrameStack[i];
+ if (frame.Active)
+ return frame.TimeOverrideExpired ? -1 : frame.deltaTimeOverride;
+ }
+ return -1;
+ }
+ if (m_IgnoreTimeScale)
+ return fixedDelta ? Time.fixedDeltaTime : Time.unscaledDeltaTime;
+ return fixedDelta ? Time.fixedDeltaTime : Time.deltaTime;
+ }
+
+ private void UpdateVirtualCameras(CinemachineCore.UpdateFilter updateFilter, float deltaTime)
+ {
+ // We always update all active virtual cameras
+ CinemachineCore.Instance.CurrentUpdateFilter = updateFilter;
+ Camera camera = OutputCamera;
+ CinemachineCore.Instance.UpdateAllActiveVirtualCameras(
+ camera == null ? -1 : camera.cullingMask, DefaultWorldUp, deltaTime);
+
+ // Make sure all live cameras get updated, in case some of them are deactivated
+ if (SoloCamera != null)
+ SoloCamera.UpdateCameraState(DefaultWorldUp, deltaTime);
+ mCurrentLiveCameras.UpdateCameraState(DefaultWorldUp, deltaTime);
+
+ // Restore the filter for general use
+ updateFilter = CinemachineCore.UpdateFilter.Late;
+ if (Application.isPlaying)
+ {
+ if (m_UpdateMethod == UpdateMethod.SmartUpdate)
+ updateFilter |= CinemachineCore.UpdateFilter.Smart;
+ else if (m_UpdateMethod == UpdateMethod.FixedUpdate)
+ updateFilter = CinemachineCore.UpdateFilter.Fixed;
+ }
+ CinemachineCore.Instance.CurrentUpdateFilter = updateFilter;
+ }
+
+ /// <summary>
+ /// Get the current active virtual camera.
+ /// </summary>
+ public ICinemachineCamera ActiveVirtualCamera
+ {
+ get
+ {
+ if (SoloCamera != null)
+ return SoloCamera;
+ return DeepCamBFromBlend(mCurrentLiveCameras);
+ }
+ }
+
+ static ICinemachineCamera DeepCamBFromBlend(CinemachineBlend blend)
+ {
+ ICinemachineCamera vcam = blend.CamB;
+ while (vcam != null)
+ {
+ if (!vcam.IsValid)
+ return null; // deleted!
+ BlendSourceVirtualCamera bs = vcam as BlendSourceVirtualCamera;
+ if (bs == null)
+ break;
+ vcam = bs.Blend.CamB;
+ }
+ return vcam;
+ }
+
+ /// <summary>
+ /// Is there a blend in progress?
+ /// </summary>
+ public bool IsBlending { get { return ActiveBlend != null; } }
+
+ /// <summary>
+ /// Get the current blend in progress. Returns null if none.
+ /// </summary>
+ public CinemachineBlend ActiveBlend
+ {
+ get
+ {
+ if (SoloCamera != null)
+ return null;
+ if (mCurrentLiveCameras.CamA == null || mCurrentLiveCameras.IsComplete)
+ return null;
+ return mCurrentLiveCameras;
+ }
+ }
+
+ private class BrainFrame
+ {
+ public int id;
+ public CinemachineBlend blend = new CinemachineBlend(null, null, null, 0, 0);
+ public bool Active { get { return blend.IsValid; } }
+
+ // Working data - updated every frame
+ public CinemachineBlend workingBlend = new CinemachineBlend(null, null, null, 0, 0);
+ public BlendSourceVirtualCamera workingBlendSource = new BlendSourceVirtualCamera(null);
+
+ // Used by Timeline Preview for overriding the current value of deltaTime
+ public float deltaTimeOverride;
+ public float timeOfOverride;
+ public bool TimeOverrideExpired
+ {
+ get { return Time.realtimeSinceStartup - timeOfOverride > Time.maximumDeltaTime; }
+ }
+ }
+
+ // Current game state is always frame 0, overrides are subsequent frames
+ private List<BrainFrame> mFrameStack = new List<BrainFrame>();
+ private int mNextFrameId = 1;
+
+ /// Get the frame index corresponding to the ID
+ private int GetBrainFrame(int withId)
+ {
+ int count = mFrameStack.Count;
+ for (int i = mFrameStack.Count - 1; i > 0; --i)
+ if (mFrameStack[i].id == withId)
+ return i;
+ // Not found - add it
+ mFrameStack.Add(new BrainFrame() { id = withId });
+ return mFrameStack.Count - 1;
+ }
+
+ // Current Brain State - result of all frames. Blend camB is "current" camera always
+ CinemachineBlend mCurrentLiveCameras = new CinemachineBlend(null, null, null, 0, 0);
+
+ /// <summary>
+ /// This API is specifically for Timeline. Do not use it.
+ /// Override the current camera and current blend. This setting will trump
+ /// any in-game logic that sets virtual camera priorities and Enabled states.
+ /// This is the main API for the timeline.
+ /// </summary>
+ /// <param name="overrideId">Id to represent a specific client. An internal
+ /// stack is maintained, with the most recent non-empty override taking precenence.
+ /// This id must be > 0. If you pass -1, a new id will be created, and returned.
+ /// Use that id for subsequent calls. Don't forget to
+ /// call ReleaseCameraOverride after all overriding is finished, to
+ /// free the OverideStack resources.</param>
+ /// <param name="camA"> The camera to set, corresponding to weight=0</param>
+ /// <param name="camB"> The camera to set, corresponding to weight=1</param>
+ /// <param name="weightB">The blend weight. 0=camA, 1=camB</param>
+ /// <param name="deltaTime">override for deltaTime. Should be Time.FixedDelta for
+ /// time-based calculations to be included, -1 otherwise</param>
+ /// <returns>The oiverride ID. Don't forget to call ReleaseCameraOverride
+ /// after all overriding is finished, to free the OverideStack resources.</returns>
+ internal int SetCameraOverride(
+ int overrideId,
+ ICinemachineCamera camA, ICinemachineCamera camB,
+ float weightB, float deltaTime)
+ {
+ if (overrideId < 0)
+ overrideId = mNextFrameId++;
+
+ BrainFrame frame = mFrameStack[GetBrainFrame(overrideId)];
+ frame.deltaTimeOverride = deltaTime;
+ frame.timeOfOverride = Time.realtimeSinceStartup;
+ frame.blend.CamA = camA;
+ frame.blend.CamB = camB;
+ frame.blend.BlendCurve = AnimationCurve.Linear(0, 0, 1, 1);
+ frame.blend.Duration = 1;
+ frame.blend.TimeInBlend = weightB;
+
+ return overrideId;
+ }
+
+ /// <summary>
+ /// This API is specifically for Timeline. Do not use it.
+ /// Release the resources used for a camera override client.
+ /// See SetCameraOverride.
+ /// </summary>
+ /// <param name="overrideId">The ID to released. This is the value that
+ /// was returned by SetCameraOverride</param>
+ internal void ReleaseCameraOverride(int overrideId)
+ {
+ for (int i = mFrameStack.Count - 1; i > 0; --i)
+ {
+ if (mFrameStack[i].id == overrideId)
+ {
+ mFrameStack.RemoveAt(i);
+ return;
+ }
+ }
+ }
+
+ ICinemachineCamera mActiveCameraPreviousFrame;
+ private void ProcessActiveCamera(float deltaTime)
+ {
+ var activeCamera = ActiveVirtualCamera;
+ if (activeCamera != null)
+ {
+ // Has the current camera changed this frame?
+ if (activeCamera != mActiveCameraPreviousFrame)
+ {
+ // Notify incoming camera of transition
+ activeCamera.OnTransitionFromCamera(
+ mActiveCameraPreviousFrame, DefaultWorldUp, deltaTime);
+ if (m_CameraActivatedEvent != null)
+ m_CameraActivatedEvent.Invoke(activeCamera, mActiveCameraPreviousFrame);
+
+ // If we're cutting without a blend, send an event
+ if (m_CameraCutEvent != null
+ && (!IsBlending || (mActiveCameraPreviousFrame != null
+ && !ActiveBlend.Uses(mActiveCameraPreviousFrame))))
+ m_CameraCutEvent.Invoke(this);
+ }
+ // Apply the vcam state to the Unity camera
+ PushStateToUnityCamera(
+ SoloCamera != null ? SoloCamera.State : mCurrentLiveCameras.State);
+ }
+ mActiveCameraPreviousFrame = activeCamera;
+ }
+
+ private void UpdateFrame0(float deltaTime)
+ {
+ // Update the in-game frame (frame 0)
+ BrainFrame frame = mFrameStack[0];
+
+ // Are we transitioning cameras?
+ var activeCamera = TopCameraFromPriorityQueue();
+ var outGoingCamera = frame.blend.CamB;
+ if (activeCamera != outGoingCamera)
+ {
+ // Do we need to create a game-play blend?
+ if ((UnityEngine.Object)activeCamera != null
+ && (UnityEngine.Object)outGoingCamera != null && deltaTime >= 0)
+ {
+ // Create a blend (curve will be null if a cut)
+ var blendDef = LookupBlend(outGoingCamera, activeCamera);
+ if (blendDef.BlendCurve != null && blendDef.m_Time > 0)
+ {
+ if (frame.blend.IsComplete)
+ frame.blend.CamA = outGoingCamera; // new blend
+ else
+ {
+ // Special case: if backing out of a blend-in-progress
+ // with the same blend in reverse, adjust the belnd time
+ if (frame.blend.CamA == activeCamera
+ && frame.blend.CamB == outGoingCamera
+ && frame.blend.Duration <= blendDef.m_Time)
+ {
+ blendDef.m_Time = frame.blend.TimeInBlend;
+ }
+
+ // Chain to existing blend
+ frame.blend.CamA = new BlendSourceVirtualCamera(
+ new CinemachineBlend(
+ frame.blend.CamA, frame.blend.CamB,
+ frame.blend.BlendCurve, frame.blend.Duration,
+ frame.blend.TimeInBlend));
+ }
+ }
+ frame.blend.BlendCurve = blendDef.BlendCurve;
+ frame.blend.Duration = blendDef.m_Time;
+ frame.blend.TimeInBlend = 0;
+ }
+ // Set the current active camera
+ frame.blend.CamB = activeCamera;
+ }
+
+ // Advance the current blend (if any)
+ if (frame.blend.CamA != null)
+ {
+ frame.blend.TimeInBlend += (deltaTime >= 0) ? deltaTime : frame.blend.Duration;
+ if (frame.blend.IsComplete)
+ {
+ // No more blend
+ frame.blend.CamA = null;
+ frame.blend.BlendCurve = null;
+ frame.blend.Duration = 0;
+ frame.blend.TimeInBlend = 0;
+ }
+ }
+ }
+
+ private void UpdateCurrentLiveCameras()
+ {
+ // Resolve the current working frame states in the stack
+ int lastActive = 0;
+ for (int i = 0; i < mFrameStack.Count; ++i)
+ {
+ BrainFrame frame = mFrameStack[i];
+ if (i == 0 || frame.Active)
+ {
+ frame.workingBlend.CamA = frame.blend.CamA;
+ frame.workingBlend.CamB = frame.blend.CamB;
+ frame.workingBlend.BlendCurve = frame.blend.BlendCurve;
+ frame.workingBlend.Duration = frame.blend.Duration;
+ frame.workingBlend.TimeInBlend = frame.blend.TimeInBlend;
+ if (i > 0 && !frame.blend.IsComplete)
+ {
+ if (frame.workingBlend.CamA == null)
+ {
+ if (mFrameStack[lastActive].blend.IsComplete)
+ frame.workingBlend.CamA = mFrameStack[lastActive].blend.CamB;
+ else
+ {
+ frame.workingBlendSource.Blend = mFrameStack[lastActive].workingBlend;
+ frame.workingBlend.CamA = frame.workingBlendSource;
+ }
+ }
+ else if (frame.workingBlend.CamB == null)
+ {
+ if (mFrameStack[lastActive].blend.IsComplete)
+ frame.workingBlend.CamB = mFrameStack[lastActive].blend.CamB;
+ else
+ {
+ frame.workingBlendSource.Blend = mFrameStack[lastActive].workingBlend;
+ frame.workingBlend.CamB = frame.workingBlendSource;
+ }
+ }
+ }
+ lastActive = i;
+ }
+ }
+ var workingBlend = mFrameStack[lastActive].workingBlend;
+ mCurrentLiveCameras.CamA = workingBlend.CamA;
+ mCurrentLiveCameras.CamB = workingBlend.CamB;
+ mCurrentLiveCameras.BlendCurve = workingBlend.BlendCurve;
+ mCurrentLiveCameras.Duration = workingBlend.Duration;
+ mCurrentLiveCameras.TimeInBlend = workingBlend.TimeInBlend;
+ }
+
+ /// <summary>
+ /// True if the ICinemachineCamera the current active camera,
+ /// or part of a current blend, either directly or indirectly because its parents are live.
+ /// </summary>
+ /// <param name="vcam">The camera to test whether it is live</param>
+ /// <param name="dominantChildOnly">If truw, will only return true if this vcam is the dominat live child</param>
+ /// <returns>True if the camera is live (directly or indirectly)
+ /// or part of a blend in progress.</returns>
+ public bool IsLive(ICinemachineCamera vcam, bool dominantChildOnly = false)
+ {
+ if (SoloCamera == vcam)
+ return true;
+ if (mCurrentLiveCameras.Uses(vcam))
+ return true;
+
+ ICinemachineCamera parent = vcam.ParentCamera;
+ while (parent != null && parent.IsLiveChild(vcam, dominantChildOnly))
+ {
+ if (SoloCamera == parent || mCurrentLiveCameras.Uses(parent))
+ return true;
+ vcam = parent;
+ parent = vcam.ParentCamera;
+ }
+ return false;
+ }
+
+ /// <summary>
+ /// The current state applied to the unity camera (may be the result of a blend)
+ /// </summary>
+ public CameraState CurrentCameraState { get; private set; }
+
+ /// <summary>
+ /// Get the highest-priority Enabled ICinemachineCamera
+ /// that is visible to my camera. Culling Mask is used to test visibility.
+ /// </summary>
+ private ICinemachineCamera TopCameraFromPriorityQueue()
+ {
+ CinemachineCore core = CinemachineCore.Instance;
+ Camera outputCamera = OutputCamera;
+ int mask = outputCamera == null ? ~0 : outputCamera.cullingMask;
+ int numCameras = core.VirtualCameraCount;
+ for (int i = 0; i < numCameras; ++i)
+ {
+ var cam = core.GetVirtualCamera(i);
+ GameObject go = cam != null ? cam.gameObject : null;
+ if (go != null && (mask & (1 << go.layer)) != 0)
+ return cam;
+ }
+ return null;
+ }
+
+ /// <summary>
+ /// Create a blend curve for blending from one ICinemachineCamera to another.
+ /// If there is a specific blend defined for these cameras it will be used, otherwise
+ /// a default blend will be created, which could be a cut.
+ /// </summary>
+ private CinemachineBlendDefinition LookupBlend(
+ ICinemachineCamera fromKey, ICinemachineCamera toKey)
+ {
+ // Get the blend curve that's most appropriate for these cameras
+ CinemachineBlendDefinition blend = m_DefaultBlend;
+ if (m_CustomBlends != null)
+ {
+ string fromCameraName = (fromKey != null) ? fromKey.Name : string.Empty;
+ string toCameraName = (toKey != null) ? toKey.Name : string.Empty;
+ blend = m_CustomBlends.GetBlendForVirtualCameras(
+ fromCameraName, toCameraName, blend);
+ }
+ if (CinemachineCore.GetBlendOverride != null)
+ blend = CinemachineCore.GetBlendOverride(fromKey, toKey, blend, this);
+ return blend;
+ }
+
+ /// <summary> Apply a cref="CameraState"/> to the game object</summary>
+ private void PushStateToUnityCamera(CameraState state)
+ {
+ CurrentCameraState = state;
+ if ((state.BlendHint & CameraState.BlendHintValue.NoPosition) == 0)
+ transform.position = state.FinalPosition;
+ if ((state.BlendHint & CameraState.BlendHintValue.NoOrientation) == 0)
+ transform.rotation = state.FinalOrientation;
+ if ((state.BlendHint & CameraState.BlendHintValue.NoLens) == 0)
+ {
+ Camera cam = OutputCamera;
+ if (cam != null)
+ {
+ cam.nearClipPlane = state.Lens.NearClipPlane;
+ cam.farClipPlane = state.Lens.FarClipPlane;
+ cam.fieldOfView = state.Lens.FieldOfView;
+ if (cam.orthographic)
+ cam.orthographicSize = state.Lens.OrthographicSize;
+#if UNITY_2018_2_OR_NEWER
+ else
+ {
+ cam.usePhysicalProperties = state.Lens.IsPhysicalCamera;
+ cam.lensShift = state.Lens.LensShift;
+ }
+#endif
+ }
+ }
+ if (CinemachineCore.CameraUpdatedEvent != null)
+ CinemachineCore.CameraUpdatedEvent.Invoke(this);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 72ece51f2901e7445ab60da3685d6b5f
+timeCreated: 1493069520
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 100
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using Cinemachine;
+
+/// <summary>
+/// An add-on module for Cinemachine Virtual Camera that adds a final offset to the camera
+/// </summary>
+[AddComponentMenu("")] // Hide in menu
+public class CinemachineCameraOffset : CinemachineExtension
+{
+ [Tooltip("Offset the camera's position by this much (camera space)")]
+ public Vector3 m_Offset = Vector3.zero;
+
+ [Tooltip("When to apply the offset")]
+ public CinemachineCore.Stage m_ApplyAfter = CinemachineCore.Stage.Aim;
+
+ protected override void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
+ {
+ if (stage == m_ApplyAfter)
+ {
+ Vector3 offset = state.FinalOrientation * m_Offset;
+ state.ReferenceLookAt += offset;
+ state.PositionCorrection += offset;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 44d70cc20219cd84593f67d248eafe36
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS
+
+using System.Collections.Generic;
+using UnityEngine;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Cinemachine ClearShot is a "manager camera" that owns and manages a set of
+ /// Virtual Camera gameObject children. When Live, the ClearShot will check the
+ /// children, and choose the one with the best quality shot and make it Live.
+ ///
+ /// This can be a very powerful tool. If the child cameras have CinemachineCollider
+ /// extensions, they will analyze the scene for target obstructions, optimal target
+ /// distance, and other items, and report their assessment of shot quality back to
+ /// the ClearShot parent, who will then choose the best one. You can use this to set
+ /// up complex multi-camera coverage of a scene, and be assured that a clear shot of
+ /// the target will always be available.
+ ///
+ /// If multiple child cameras have the same shot quality, the one with the highest
+ /// priority will be chosen.
+ ///
+ /// You can also define custom blends between the ClearShot children.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineClearShot")]
+ public class CinemachineClearShot : CinemachineVirtualCameraBase
+ {
+ /// <summary>Default object for the camera children to look at (the aim target), if not specified in a child camera. May be empty.</summary>
+ [Tooltip("Default object for the camera children to look at (the aim target), if not specified in a child camera. May be empty if all children specify targets of their own.")]
+ [NoSaveDuringPlay]
+ public Transform m_LookAt = null;
+
+ /// <summary>Default object for the camera children wants to move with (the body target), if not specified in a child camera. May be empty.</summary>
+ [Tooltip("Default object for the camera children wants to move with (the body target), if not specified in a child camera. May be empty if all children specify targets of their own.")]
+ [NoSaveDuringPlay]
+ public Transform m_Follow = null;
+
+ /// <summary>When enabled, the current camera and blend will be indicated in the game window, for debugging</summary>
+ [Tooltip("When enabled, the current child camera and blend will be indicated in the game window, for debugging")]
+ [NoSaveDuringPlay]
+ public bool m_ShowDebugText = false;
+
+ /// <summary>Internal API for the editor. Do not use this filed.</summary>
+ [SerializeField, HideInInspector, NoSaveDuringPlay]
+ internal CinemachineVirtualCameraBase[] m_ChildCameras = null;
+
+ /// <summary>Wait this many seconds before activating a new child camera</summary>
+ [Tooltip("Wait this many seconds before activating a new child camera")]
+ public float m_ActivateAfter;
+
+ /// <summary>An active camera must be active for at least this many seconds</summary>
+ [Tooltip("An active camera must be active for at least this many seconds")]
+ public float m_MinDuration;
+
+ /// <summary>If checked, camera choice will be randomized if multiple cameras are equally desirable. Otherwise, child list order will be used</summary>
+ [Tooltip("If checked, camera choice will be randomized if multiple cameras are equally desirable. Otherwise, child list order and child camera priority will be used.")]
+ public bool m_RandomizeChoice = false;
+
+ /// <summary>The blend which is used if you don't explicitly define a blend between two Virtual Cameras</summary>
+ [CinemachineBlendDefinitionProperty]
+ [Tooltip("The blend which is used if you don't explicitly define a blend between two Virtual Cameras")]
+ public CinemachineBlendDefinition m_DefaultBlend
+ = new CinemachineBlendDefinition(CinemachineBlendDefinition.Style.Cut, 0);
+
+ /// <summary>This is the asset which contains custom settings for specific blends</summary>
+ [HideInInspector]
+ public CinemachineBlenderSettings m_CustomBlends = null;
+
+ /// <summary>Gets a brief debug description of this virtual camera, for use when displayiong debug info</summary>
+ public override string Description
+ {
+ get
+ {
+ // Show the active camera and blend
+ if (mActiveBlend != null)
+ return mActiveBlend.Description;
+
+ ICinemachineCamera vcam = LiveChild;
+ if (vcam == null)
+ return "(none)";
+ var sb = CinemachineDebug.SBFromPool();
+ sb.Append("["); sb.Append(vcam.Name); sb.Append("]");
+ string text = sb.ToString();
+ CinemachineDebug.ReturnToPool(sb);
+ return text;
+ }
+ }
+
+ /// <summary>Get the current "best" child virtual camera, that would be chosen
+ /// if the ClearShot camera were active.</summary>
+ public ICinemachineCamera LiveChild { set; get; }
+
+ /// <summary>The CameraState of the currently live child</summary>
+ public override CameraState State { get { return m_State; } }
+
+ /// <summary>Check whether the vcam a live child of this camera.</summary>
+ /// <param name="vcam">The Virtual Camera to check</param>
+ /// <param name="dominantChildOnly">If truw, will only return true if this vcam is the dominat live child</param>
+ /// <returns>True if the vcam is currently actively influencing the state of this vcam</returns>
+ public override bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false)
+ {
+ return vcam == LiveChild || (mActiveBlend != null && mActiveBlend.Uses(vcam));
+ }
+
+ /// <summary>Get the current LookAt target. Returns parent's LookAt if parent
+ /// is non-null and no specific LookAt defined for this camera</summary>
+ override public Transform LookAt
+ {
+ get { return ResolveLookAt(m_LookAt); }
+ set { m_LookAt = value; }
+ }
+
+ /// <summary>Get the current Follow target. Returns parent's Follow if parent
+ /// is non-null and no specific Follow defined for this camera</summary>
+ override public Transform Follow
+ {
+ get { return ResolveFollow(m_Follow); }
+ set { m_Follow = value; }
+ }
+
+ /// <summary>This is called to notify the vcam that a target got warped,
+ /// so that the vcam can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ UpdateListOfChildren();
+ foreach (var vcam in m_ChildCameras)
+ vcam.OnTargetObjectWarped(target, positionDelta);
+ base.OnTargetObjectWarped(target, positionDelta);
+ }
+
+ /// <summary>Internal use only. Called by CinemachineCore at designated update time
+ /// so the vcam can position itself and track its targets. This implementation
+ /// updates all the children, chooses the best one, and implements any required blending.</summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ public override void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ if (!PreviousStateIsValid)
+ deltaTime = -1;
+
+ // Choose the best camera
+ UpdateListOfChildren();
+ ICinemachineCamera previousCam = LiveChild;
+ LiveChild = ChooseCurrentCamera(worldUp, deltaTime);
+
+ // Are we transitioning cameras?
+ if (previousCam != LiveChild && LiveChild != null)
+ {
+ // Notify incoming camera of transition
+ LiveChild.OnTransitionFromCamera(previousCam, worldUp, deltaTime);
+
+ // Generate Camera Activation event in the brain if live
+ CinemachineCore.Instance.GenerateCameraActivationEvent(LiveChild, previousCam);
+
+ // Are we transitioning cameras?
+ if (previousCam != null)
+ {
+ // Create a blend (will be null if a cut)
+ mActiveBlend = CreateBlend(
+ previousCam, LiveChild,
+ LookupBlend(previousCam, LiveChild), mActiveBlend);
+
+ // If cutting, generate a camera cut event if live
+ if (mActiveBlend == null || !mActiveBlend.Uses(previousCam))
+ CinemachineCore.Instance.GenerateCameraCutEvent(LiveChild);
+ }
+ }
+
+ // Advance the current blend (if any)
+ if (mActiveBlend != null)
+ {
+ mActiveBlend.TimeInBlend += (deltaTime >= 0)
+ ? deltaTime : mActiveBlend.Duration;
+ if (mActiveBlend.IsComplete)
+ mActiveBlend = null;
+ }
+
+ if (mActiveBlend != null)
+ {
+ mActiveBlend.UpdateCameraState(worldUp, deltaTime);
+ m_State = mActiveBlend.State;
+ }
+ else if (LiveChild != null)
+ {
+ if (TransitioningFrom != null)
+ LiveChild.OnTransitionFromCamera(TransitioningFrom, worldUp, deltaTime);
+ m_State = LiveChild.State;
+ }
+ TransitioningFrom = null;
+ InvokePostPipelineStageCallback(this, CinemachineCore.Stage.Finalize, ref m_State, deltaTime);
+ PreviousStateIsValid = true;
+ }
+
+ /// <summary>Makes sure the internal child cache is up to date</summary>
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ InvalidateListOfChildren();
+ mActiveBlend = null;
+ CinemachineDebug.OnGUIHandlers -= OnGuiHandler;
+ CinemachineDebug.OnGUIHandlers += OnGuiHandler;
+ }
+
+ protected override void OnDisable()
+ {
+ base.OnDisable();
+ CinemachineDebug.OnGUIHandlers -= OnGuiHandler;
+ }
+
+ /// <summary>Makes sure the internal child cache is up to date</summary>
+ public void OnTransformChildrenChanged()
+ {
+ InvalidateListOfChildren();
+ }
+
+ /// Will only be called if Unity Editor - never in build
+ private void OnGuiHandler()
+ {
+ if (!m_ShowDebugText)
+ CinemachineDebug.ReleaseScreenPos(this);
+ else
+ {
+ var sb = CinemachineDebug.SBFromPool();
+ sb.Append(Name); sb.Append(": "); sb.Append(Description);
+ string text = sb.ToString();
+ Rect r = CinemachineDebug.GetScreenPos(this, text, GUI.skin.box);
+ GUI.Label(r, text, GUI.skin.box);
+ CinemachineDebug.ReturnToPool(sb);
+ }
+ }
+
+ /// <summary>Is there a blend in progress?</summary>
+ public bool IsBlending { get { return mActiveBlend != null; } }
+
+ CameraState m_State = CameraState.Default;
+
+ /// <summary>The list of child cameras. These are just the immediate children in the hierarchy.</summary>
+ public CinemachineVirtualCameraBase[] ChildCameras
+ {
+ get { UpdateListOfChildren(); return m_ChildCameras; }
+ }
+
+ float mActivationTime = 0;
+ float mPendingActivationTime = 0;
+ ICinemachineCamera mPendingCamera;
+ private CinemachineBlend mActiveBlend = null;
+
+ void InvalidateListOfChildren()
+ {
+ m_ChildCameras = null;
+ m_RandomizedChilden = null;
+ LiveChild = null;
+ }
+
+ /// <summary>If RandomizeChoice is enabled, call this to re-randomize the children next frame.
+ /// This is useful if you want to freshen up the shot.</summary>
+ public void ResetRandomization()
+ {
+ m_RandomizedChilden = null;
+ mRandomizeNow = true;
+ }
+
+ void UpdateListOfChildren()
+ {
+ if (m_ChildCameras != null)
+ return;
+
+ List<CinemachineVirtualCameraBase> list = new List<CinemachineVirtualCameraBase>();
+ CinemachineVirtualCameraBase[] kids = GetComponentsInChildren<CinemachineVirtualCameraBase>(true);
+ foreach (CinemachineVirtualCameraBase k in kids)
+ if (k.transform.parent == transform)
+ list.Add(k);
+ m_ChildCameras = list.ToArray();
+
+ // Zap the cached current instructions
+ mActivationTime = mPendingActivationTime = 0;
+ mPendingCamera = null;
+ LiveChild = null;
+ mActiveBlend = null;
+ }
+
+ private bool mRandomizeNow = false;
+ private CinemachineVirtualCameraBase[] m_RandomizedChilden = null;
+
+ private ICinemachineCamera ChooseCurrentCamera(Vector3 worldUp, float deltaTime)
+ {
+ if (m_ChildCameras == null || m_ChildCameras.Length == 0)
+ {
+ mActivationTime = 0;
+ return null;
+ }
+
+ CinemachineVirtualCameraBase[] childCameras = m_ChildCameras;
+ if (!m_RandomizeChoice)
+ m_RandomizedChilden = null;
+ else if (m_ChildCameras.Length > 1)
+ {
+ if (m_RandomizedChilden == null)
+ m_RandomizedChilden = Randomize(m_ChildCameras);
+ childCameras = m_RandomizedChilden;
+ }
+
+ if (LiveChild != null && !LiveChild.VirtualCameraGameObject.activeSelf)
+ LiveChild = null;
+ ICinemachineCamera best = LiveChild;
+ for (int i = 0; i < childCameras.Length; ++i)
+ {
+ CinemachineVirtualCameraBase vcam = childCameras[i];
+ if (vcam != null && vcam.gameObject.activeInHierarchy)
+ {
+ // Choose the first in the list that is better than the current
+ if (best == null
+ || vcam.State.ShotQuality > best.State.ShotQuality
+ || (vcam.State.ShotQuality == best.State.ShotQuality && vcam.Priority > best.Priority)
+ || (m_RandomizeChoice && mRandomizeNow && (ICinemachineCamera)vcam != LiveChild
+ && vcam.State.ShotQuality == best.State.ShotQuality
+ && vcam.Priority == best.Priority))
+ {
+ best = vcam;
+ }
+ }
+ }
+ mRandomizeNow = false;
+
+ float now = Time.time;
+ if (mActivationTime != 0)
+ {
+ // Is it active now?
+ if (LiveChild == best)
+ {
+ // Yes, cancel any pending
+ mPendingActivationTime = 0;
+ mPendingCamera = null;
+ return best;
+ }
+
+ // Is it pending?
+ if (deltaTime >= 0)
+ {
+ if (mPendingActivationTime != 0 && mPendingCamera == best)
+ {
+ // Has it been pending long enough, and are we allowed to switch away
+ // from the active action?
+ if ((now - mPendingActivationTime) > m_ActivateAfter
+ && (now - mActivationTime) > m_MinDuration)
+ {
+ // Yes, activate it now
+ m_RandomizedChilden = null; // reshuffle the children
+ mActivationTime = now;
+ mPendingActivationTime = 0;
+ mPendingCamera = null;
+ return best;
+ }
+ return LiveChild;
+ }
+ }
+ }
+ // Neither active nor pending.
+ mPendingActivationTime = 0; // cancel the pending, if any
+ mPendingCamera = null;
+
+ // Can we activate it now?
+ if (deltaTime >= 0 && mActivationTime > 0)
+ {
+ if (m_ActivateAfter > 0
+ || (now - mActivationTime) < m_MinDuration)
+ {
+ // Too early - make it pending
+ mPendingCamera = best;
+ mPendingActivationTime = now;
+ return LiveChild;
+ }
+ }
+ // Activate now
+ m_RandomizedChilden = null; // reshuffle the children
+ mActivationTime = now;
+ return best;
+ }
+
+ struct Pair { public int a; public float b; }
+ CinemachineVirtualCameraBase[] Randomize(CinemachineVirtualCameraBase[] src)
+ {
+ List<Pair> pairs = new List<Pair>();
+ for (int i = 0; i < src.Length; ++i)
+ {
+ Pair p = new Pair(); p.a = i; p.b = Random.Range(0, 1000f);
+ pairs.Add(p);
+ }
+ pairs.Sort((p1, p2) => (int)p1.b - (int)p2.b);
+ CinemachineVirtualCameraBase[] dst = new CinemachineVirtualCameraBase[src.Length];
+ Pair[] result = pairs.ToArray();
+ for (int i = 0; i < src.Length; ++i)
+ dst[i] = src[result[i].a];
+ return dst;
+ }
+
+ private CinemachineBlendDefinition LookupBlend(
+ ICinemachineCamera fromKey, ICinemachineCamera toKey)
+ {
+ // Get the blend curve that's most appropriate for these cameras
+ CinemachineBlendDefinition blend = m_DefaultBlend;
+ if (m_CustomBlends != null)
+ {
+ string fromCameraName = (fromKey != null) ? fromKey.Name : string.Empty;
+ string toCameraName = (toKey != null) ? toKey.Name : string.Empty;
+ blend = m_CustomBlends.GetBlendForVirtualCameras(
+ fromCameraName, toCameraName, blend);
+ }
+ if (CinemachineCore.GetBlendOverride != null)
+ blend = CinemachineCore.GetBlendOverride(fromKey, toKey, blend, this);
+ return blend;
+ }
+
+ /// <summary>Notification that this virtual camera is going live.
+ /// This implementation resets the child randomization.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ TransitioningFrom = fromCam;
+ if (m_RandomizeChoice && mActiveBlend == null)
+ {
+ m_RandomizedChilden = null;
+ LiveChild = null;
+ }
+ InternalUpdateCameraState(worldUp, deltaTime);
+ }
+
+ ICinemachineCamera TransitioningFrom { get; set; }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: d62f748f5292bb343be9e6b0c84416d9
+timeCreated: 1489088130
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS
+
+using UnityEngine;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+using UnityEngine.Serialization;
+using System;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// An add-on module for Cinemachine Virtual Camera that post-processes
+ /// the final position of the virtual camera. Based on the supplied settings,
+ /// the Collider will attempt to preserve the line of sight
+ /// with the LookAt target of the virtual camera by moving
+ /// away from objects that will obstruct the view.
+ ///
+ /// Additionally, the Collider can be used to assess the shot quality and
+ /// report this as a field in the camera State.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Hide in menu
+ [SaveDuringPlay]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ public class CinemachineCollider : CinemachineExtension
+ {
+ /// <summary>Objects on these layers will be detected.</summary>
+ [Header("Obstacle Detection")]
+ [Tooltip("Objects on these layers will be detected")]
+ public LayerMask m_CollideAgainst = 1;
+
+ /// <summary>Obstacles with this tag will be ignored. It is a good idea to set this field to the target's tag</summary>
+ [TagField]
+ [Tooltip("Obstacles with this tag will be ignored. It is a good idea to set this field to the target's tag")]
+ public string m_IgnoreTag = string.Empty;
+
+ /// <summary>Objects on these layers will never obstruct view of the target.</summary>
+ [Tooltip("Objects on these layers will never obstruct view of the target")]
+ public LayerMask m_TransparentLayers = 0;
+
+ /// <summary>Obstacles closer to the target than this will be ignored</summary>
+ [Tooltip("Obstacles closer to the target than this will be ignored")]
+ public float m_MinimumDistanceFromTarget = 0.1f;
+
+ /// <summary>
+ /// When enabled, will attempt to resolve situations where the line of sight to the
+ /// target is blocked by an obstacle
+ /// </summary>
+ [Space]
+ [Tooltip("When enabled, will attempt to resolve situations where the line of sight to the target is blocked by an obstacle")]
+ [FormerlySerializedAs("m_PreserveLineOfSight")]
+ public bool m_AvoidObstacles = true;
+
+ /// <summary>
+ /// The raycast distance to test for when checking if the line of sight to this camera's target is clear.
+ /// </summary>
+ [Tooltip("The maximum raycast distance when checking if the line of sight to this camera's target is clear. If the setting is 0 or less, the current actual distance to target will be used.")]
+ [FormerlySerializedAs("m_LineOfSightFeelerDistance")]
+ public float m_DistanceLimit = 0f;
+
+ /// <summary>
+ /// Don't take action unless occlusion has lasted at least this long.
+ /// </summary>
+ [Tooltip("Don't take action unless occlusion has lasted at least this long.")]
+ public float m_MinimumOcclusionTime = 0f;
+
+ /// <summary>
+ /// Camera will try to maintain this distance from any obstacle.
+ /// Increase this value if you are seeing inside obstacles due to a large
+ /// FOV on the camera.
+ /// </summary>
+ [Tooltip("Camera will try to maintain this distance from any obstacle. Try to keep this value small. Increase it if you are seeing inside obstacles due to a large FOV on the camera.")]
+ public float m_CameraRadius = 0.1f;
+
+ /// <summary>The way in which the Collider will attempt to preserve sight of the target.</summary>
+ public enum ResolutionStrategy
+ {
+ /// <summary>Camera will be pulled forward along its Z axis until it is in front of
+ /// the nearest obstacle</summary>
+ PullCameraForward,
+ /// <summary>In addition to pulling the camera forward, an effort will be made to
+ /// return the camera to its original height</summary>
+ PreserveCameraHeight,
+ /// <summary>In addition to pulling the camera forward, an effort will be made to
+ /// return the camera to its original distance from the target</summary>
+ PreserveCameraDistance
+ };
+ /// <summary>The way in which the Collider will attempt to preserve sight of the target.</summary>
+ [Tooltip("The way in which the Collider will attempt to preserve sight of the target.")]
+ public ResolutionStrategy m_Strategy = ResolutionStrategy.PreserveCameraHeight;
+
+ /// <summary>
+ /// Upper limit on how many obstacle hits to process. Higher numbers may impact performance.
+ /// In most environments, 4 is enough.
+ /// </summary>
+ [Range(1, 10)]
+ [Tooltip("Upper limit on how many obstacle hits to process. Higher numbers may impact performance. In most environments, 4 is enough.")]
+ public int m_MaximumEffort = 4;
+
+ /// <summary>
+ /// Smoothing to apply to obstruction resolution. Nearest camera point is held for at least this long.
+ /// </summary>
+ [Range(0, 2)]
+ [Tooltip("Smoothing to apply to obstruction resolution. Nearest camera point is held for at least this long")]
+ public float m_SmoothingTime = 0;
+
+ /// <summary>
+ /// How gradually the camera returns to its normal position after having been corrected.
+ /// Higher numbers will move the camera more gradually back to normal.
+ /// </summary>
+ [Range(0, 10)]
+ [Tooltip("How gradually the camera returns to its normal position after having been corrected. Higher numbers will move the camera more gradually back to normal.")]
+ [FormerlySerializedAs("m_Smoothing")]
+ public float m_Damping = 0;
+
+ /// <summary>
+ /// How gradually the camera moves to resolve an occlusion.
+ /// Higher numbers will move the camera more gradually.
+ /// </summary>
+ [Range(0, 10)]
+ [Tooltip("How gradually the camera moves to resolve an occlusion. Higher numbers will move the camera more gradually.")]
+ public float m_DampingWhenOccluded = 0;
+
+ /// <summary>If greater than zero, a higher score will be given to shots when the target is closer to
+ /// this distance. Set this to zero to disable this feature</summary>
+ [Header("Shot Evaluation")]
+ [Tooltip("If greater than zero, a higher score will be given to shots when the target is closer to this distance. Set this to zero to disable this feature.")]
+ public float m_OptimalTargetDistance = 0;
+
+ /// <summary>See wheter an object is blocking the camera's view of the target</summary>
+ /// <param name="vcam">The virtual camera in question. This might be different from the
+ /// virtual camera that owns the collider, in the event that the camera has children</param>
+ /// <returns>True if something is blocking the view</returns>
+ public bool IsTargetObscured(ICinemachineCamera vcam)
+ {
+ return GetExtraState<VcamExtraState>(vcam).targetObscured;
+ }
+
+ /// <summary>See whether the virtual camera has been moved nby the collider</summary>
+ /// <param name="vcam">The virtual camera in question. This might be different from the
+ /// virtual camera that owns the collider, in the event that the camera has children</param>
+ /// <returns>True if the virtual camera has been displaced due to collision or
+ /// target obstruction</returns>
+ public bool CameraWasDisplaced(ICinemachineCamera vcam)
+ {
+ return GetExtraState<VcamExtraState>(vcam).colliderDisplacement > 0;
+ }
+
+ private void OnValidate()
+ {
+ m_DistanceLimit = Mathf.Max(0, m_DistanceLimit);
+ m_MinimumOcclusionTime = Mathf.Max(0, m_MinimumOcclusionTime);
+ m_CameraRadius = Mathf.Max(0, m_CameraRadius);
+ m_MinimumDistanceFromTarget = Mathf.Max(0.01f, m_MinimumDistanceFromTarget);
+ m_OptimalTargetDistance = Mathf.Max(0, m_OptimalTargetDistance);
+ }
+
+
+ /// This must be small but greater than 0 - reduces false results due to precision
+ const float PrecisionSlush = 0.001f;
+
+ /// <summary>
+ /// Per-vcam extra state info
+ /// </summary>
+ class VcamExtraState
+ {
+ public Vector3 m_previousDisplacement;
+ public Vector3 m_previousDisplacementCorrection;
+ public float colliderDisplacement;
+ public bool targetObscured;
+ public float occlusionStartTime;
+ public List<Vector3> debugResolutionPath;
+
+ public void AddPointToDebugPath(Vector3 p)
+ {
+#if UNITY_EDITOR
+ if (debugResolutionPath == null)
+ debugResolutionPath = new List<Vector3>();
+ debugResolutionPath.Add(p);
+#endif
+ }
+
+ // Thanks to Sebastien LeTouze from Exiin Studio for the smoothing idea
+ private float m_SmoothedDistance;
+ private float m_SmoothedTime;
+ public float ApplyDistanceSmoothing(float distance, float smoothingTime)
+ {
+ if (m_SmoothedTime != 0 && smoothingTime > Epsilon)
+ {
+ float now = Time.timeSinceLevelLoad;
+ if (now - m_SmoothedTime < smoothingTime)
+ return Mathf.Min(distance, m_SmoothedDistance);
+ }
+ return distance;
+ }
+ public void UpdateDistanceSmoothing(float distance, float smoothingTime)
+ {
+ float now = Time.timeSinceLevelLoad;
+ if (m_SmoothedDistance == 0 || distance <= m_SmoothedDistance)
+ {
+ m_SmoothedDistance = distance;
+ m_SmoothedTime = now;
+ }
+ }
+ public void ResetDistanceSmoothing(float smoothingTime)
+ {
+ float now = Time.timeSinceLevelLoad;
+ if (now - m_SmoothedTime >= smoothingTime)
+ m_SmoothedDistance = m_SmoothedTime = 0;
+ }
+ };
+
+ /// <summary>Inspector API for debugging collision resolution path</summary>
+ public List<List<Vector3>> DebugPaths
+ {
+ get
+ {
+ List<List<Vector3>> list = new List<List<Vector3>>();
+ List<VcamExtraState> extraStates = GetAllExtraStates<VcamExtraState>();
+ foreach (var v in extraStates)
+ if (v.debugResolutionPath != null && v.debugResolutionPath.Count > 0)
+ list.Add(v.debugResolutionPath);
+ return list;
+ }
+ }
+
+ /// <summary>Callback to do the collision resolution and shot evaluation</summary>
+ protected override void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
+ {
+ VcamExtraState extra = null;
+ if (stage == CinemachineCore.Stage.Body)
+ {
+ extra = GetExtraState<VcamExtraState>(vcam);
+ extra.targetObscured = false;
+ extra.colliderDisplacement = 0;
+ if (extra.debugResolutionPath != null)
+ extra.debugResolutionPath.RemoveRange(0, extra.debugResolutionPath.Count);
+ }
+
+ // Move the body before the Aim is calculated
+ if (stage == CinemachineCore.Stage.Body)
+ {
+ if (m_AvoidObstacles)
+ {
+ Vector3 displacement = Vector3.zero;
+ displacement = PreserveLignOfSight(ref state, ref extra);
+ if (m_MinimumOcclusionTime > Epsilon)
+ {
+ float now = Time.timeSinceLevelLoad;
+ if (displacement.sqrMagnitude < Epsilon)
+ extra.occlusionStartTime = 0;
+ else
+ {
+ if (extra.occlusionStartTime <= 0)
+ extra.occlusionStartTime = now;
+ if (now - extra.occlusionStartTime < m_MinimumOcclusionTime)
+ displacement = extra.m_previousDisplacement;
+ }
+ }
+
+ // Apply distance smoothing
+ if (m_SmoothingTime > Epsilon)
+ {
+ Vector3 pos = state.CorrectedPosition + displacement;
+ Vector3 dir = pos - state.ReferenceLookAt;
+ float distance = dir.magnitude;
+ if (distance > Epsilon)
+ {
+ dir /= distance;
+ if (!displacement.AlmostZero())
+ extra.UpdateDistanceSmoothing(distance, m_SmoothingTime);
+ distance = extra.ApplyDistanceSmoothing(distance, m_SmoothingTime);
+ displacement += (state.ReferenceLookAt + dir * distance) - pos;
+ }
+ }
+
+ float damping = m_Damping;
+ if (displacement.AlmostZero())
+ extra.ResetDistanceSmoothing(m_SmoothingTime);
+ else
+ damping = m_DampingWhenOccluded;
+ if (damping > 0 && deltaTime >= 0)
+ {
+ Vector3 delta = displacement - extra.m_previousDisplacement;
+ delta = Damper.Damp(delta, damping, deltaTime);
+ displacement = extra.m_previousDisplacement + delta;
+ }
+ extra.m_previousDisplacement = displacement;
+ Vector3 correction = RespectCameraRadius(state.CorrectedPosition + displacement, ref state);
+ if (damping > 0 && deltaTime >= 0)
+ {
+ Vector3 delta = correction - extra.m_previousDisplacementCorrection;
+ delta = Damper.Damp(delta, damping, deltaTime);
+ correction = extra.m_previousDisplacementCorrection + delta;
+ }
+ displacement += correction;
+ extra.m_previousDisplacementCorrection = correction;
+ state.PositionCorrection += displacement;
+ extra.colliderDisplacement += displacement.magnitude;
+ }
+ }
+ // Rate the shot after the aim was set
+ if (stage == CinemachineCore.Stage.Aim)
+ {
+ extra = GetExtraState<VcamExtraState>(vcam);
+ extra.targetObscured = IsTargetOffscreen(state) || CheckForTargetObstructions(state);
+
+ // GML these values are an initial arbitrary attempt at rating quality
+ if (extra.targetObscured)
+ state.ShotQuality *= 0.2f;
+ if (extra.colliderDisplacement > 0)
+ state.ShotQuality *= 0.8f;
+
+ float nearnessBoost = 0;
+ const float kMaxNearBoost = 0.2f;
+ if (m_OptimalTargetDistance > 0 && state.HasLookAt)
+ {
+ float distance = Vector3.Magnitude(state.ReferenceLookAt - state.FinalPosition);
+ if (distance <= m_OptimalTargetDistance)
+ {
+ float threshold = m_OptimalTargetDistance / 2;
+ if (distance >= threshold)
+ nearnessBoost = kMaxNearBoost * (distance - threshold)
+ / (m_OptimalTargetDistance - threshold);
+ }
+ else
+ {
+ distance -= m_OptimalTargetDistance;
+ float threshold = m_OptimalTargetDistance * 3;
+ if (distance < threshold)
+ nearnessBoost = kMaxNearBoost * (1f - (distance / threshold));
+ }
+ state.ShotQuality *= (1f + nearnessBoost);
+ }
+ }
+ }
+
+ private Vector3 PreserveLignOfSight(ref CameraState state, ref VcamExtraState extra)
+ {
+ Vector3 displacement = Vector3.zero;
+ if (state.HasLookAt && m_CollideAgainst != 0
+ && m_CollideAgainst != m_TransparentLayers)
+ {
+ Vector3 cameraPos = state.CorrectedPosition;
+ Vector3 lookAtPos = state.ReferenceLookAt;
+ RaycastHit hitInfo = new RaycastHit();
+ displacement = PullCameraInFrontOfNearestObstacle(
+ cameraPos, lookAtPos, m_CollideAgainst & ~m_TransparentLayers, ref hitInfo);
+ Vector3 pos = cameraPos + displacement;
+ if (hitInfo.collider != null)
+ {
+ extra.AddPointToDebugPath(pos);
+ if (m_Strategy != ResolutionStrategy.PullCameraForward)
+ {
+ Vector3 targetToCamera = cameraPos - lookAtPos;
+ pos = PushCameraBack(
+ pos, targetToCamera, hitInfo, lookAtPos,
+ new Plane(state.ReferenceUp, cameraPos),
+ targetToCamera.magnitude, m_MaximumEffort, ref extra);
+ }
+ }
+ displacement = pos - cameraPos;
+ }
+ return displacement;
+ }
+
+ private Vector3 PullCameraInFrontOfNearestObstacle(
+ Vector3 cameraPos, Vector3 lookAtPos, int layerMask, ref RaycastHit hitInfo)
+ {
+ Vector3 displacement = Vector3.zero;
+ Vector3 dir = cameraPos - lookAtPos;
+ float targetDistance = dir.magnitude;
+ if (targetDistance > Epsilon)
+ {
+ dir /= targetDistance;
+ float minDistanceFromTarget = Mathf.Max(m_MinimumDistanceFromTarget, Epsilon);
+ if (targetDistance < minDistanceFromTarget + Epsilon)
+ displacement = dir * (minDistanceFromTarget - targetDistance);
+ else
+ {
+ float rayLength = targetDistance - minDistanceFromTarget;
+ if (m_DistanceLimit > Epsilon)
+ rayLength = Mathf.Min(m_DistanceLimit, rayLength);
+
+ // Make a ray that looks towards the camera, to get the obstacle closest to target
+ Ray ray = new Ray(cameraPos - rayLength * dir, dir);
+ rayLength += PrecisionSlush;
+ if (rayLength > Epsilon)
+ {
+ if (RaycastIgnoreTag(ray, out hitInfo, rayLength, layerMask))
+ {
+ // Pull camera forward in front of obstacle
+ float adjustment = Mathf.Max(0, hitInfo.distance - PrecisionSlush);
+ displacement = ray.GetPoint(adjustment) - cameraPos;
+ }
+ }
+ }
+ }
+ return displacement;
+ }
+
+ private bool RaycastIgnoreTag(
+ Ray ray, out RaycastHit hitInfo, float rayLength, int layerMask)
+ {
+ float extraDistance = 0;
+ while (Physics.Raycast(
+ ray, out hitInfo, rayLength, layerMask,
+ QueryTriggerInteraction.Ignore))
+ {
+ if (m_IgnoreTag.Length == 0 || !hitInfo.collider.CompareTag(m_IgnoreTag))
+ {
+ hitInfo.distance += extraDistance;
+ return true;
+ }
+
+ // Ignore the hit. Pull ray origin forward in front of obstacle
+ Ray inverseRay = new Ray(ray.GetPoint(rayLength), -ray.direction);
+ if (!hitInfo.collider.Raycast(inverseRay, out hitInfo, rayLength))
+ break;
+ float deltaExtraDistance = rayLength - (hitInfo.distance - PrecisionSlush);
+ if (deltaExtraDistance < Epsilon)
+ break;
+ extraDistance += deltaExtraDistance;
+ rayLength = hitInfo.distance - PrecisionSlush;
+ if (rayLength < Epsilon)
+ break;
+ ray.origin = inverseRay.GetPoint(rayLength);
+ }
+ return false;
+ }
+
+ private Vector3 PushCameraBack(
+ Vector3 currentPos, Vector3 pushDir, RaycastHit obstacle,
+ Vector3 lookAtPos, Plane startPlane, float targetDistance, int iterations,
+ ref VcamExtraState extra)
+ {
+ // Take a step along the wall.
+ Vector3 pos = currentPos;
+ Vector3 dir = Vector3.zero;
+ if (!GetWalkingDirection(pos, pushDir, obstacle, ref dir))
+ return pos;
+
+ Ray ray = new Ray(pos, dir);
+ float distance = GetPushBackDistance(ray, startPlane, targetDistance, lookAtPos);
+ if (distance <= Epsilon)
+ return pos;
+
+ // Check only as far as the obstacle bounds
+ float clampedDistance = ClampRayToBounds(ray, distance, obstacle.collider.bounds);
+ distance = Mathf.Min(distance, clampedDistance + PrecisionSlush);
+
+ RaycastHit hitInfo;
+ if (RaycastIgnoreTag(ray, out hitInfo, distance,
+ m_CollideAgainst & ~m_TransparentLayers))
+ {
+ // We hit something. Stop there and take a step along that wall.
+ float adjustment = hitInfo.distance - PrecisionSlush;
+ pos = ray.GetPoint(adjustment);
+ extra.AddPointToDebugPath(pos);
+ if (iterations > 1)
+ pos = PushCameraBack(
+ pos, dir, hitInfo,
+ lookAtPos, startPlane,
+ targetDistance, iterations-1, ref extra);
+
+ return pos;
+ }
+
+ // Didn't hit anything. Can we push back all the way now?
+ pos = ray.GetPoint(distance);
+
+ // First check if we can still see the target. If not, abort
+ dir = pos - lookAtPos;
+ float d = dir.magnitude;
+ RaycastHit hitInfo2;
+ if (d < Epsilon || RaycastIgnoreTag(
+ new Ray(lookAtPos, dir), out hitInfo2, d - PrecisionSlush,
+ m_CollideAgainst & ~m_TransparentLayers))
+ return currentPos;
+
+ // All clear
+ ray = new Ray(pos, dir);
+ extra.AddPointToDebugPath(pos);
+ distance = GetPushBackDistance(ray, startPlane, targetDistance, lookAtPos);
+ if (distance > Epsilon)
+ {
+ if (!RaycastIgnoreTag(ray, out hitInfo, distance,
+ m_CollideAgainst & ~m_TransparentLayers))
+ {
+ pos = ray.GetPoint(distance); // no obstacles - all good
+ extra.AddPointToDebugPath(pos);
+ }
+ else
+ {
+ // We hit something. Stop there and maybe take a step along that wall
+ float adjustment = hitInfo.distance - PrecisionSlush;
+ pos = ray.GetPoint(adjustment);
+ extra.AddPointToDebugPath(pos);
+ if (iterations > 1)
+ pos = PushCameraBack(
+ pos, dir, hitInfo, lookAtPos, startPlane,
+ targetDistance, iterations-1, ref extra);
+ }
+ }
+ return pos;
+ }
+
+ private RaycastHit[] m_CornerBuffer = new RaycastHit[4];
+ private bool GetWalkingDirection(
+ Vector3 pos, Vector3 pushDir, RaycastHit obstacle, ref Vector3 outDir)
+ {
+ Vector3 normal2 = obstacle.normal;
+
+ // Check for nearby obstacles. Are we in a corner?
+ float nearbyDistance = PrecisionSlush * 5;
+ int numFound = Physics.SphereCastNonAlloc(
+ pos, nearbyDistance, pushDir.normalized, m_CornerBuffer, 0,
+ m_CollideAgainst & ~m_TransparentLayers, QueryTriggerInteraction.Ignore);
+ if (numFound > 1)
+ {
+ // Calculate the second normal
+ for (int i = 0; i < numFound; ++i)
+ {
+ if (m_CornerBuffer[i].collider == null)
+ continue;
+ if (m_IgnoreTag.Length > 0 && m_CornerBuffer[i].collider.CompareTag(m_IgnoreTag))
+ continue;
+ Type type = m_CornerBuffer[i].collider.GetType();
+ if (type == typeof(BoxCollider)
+ || type == typeof(SphereCollider)
+ || type == typeof(CapsuleCollider))
+ {
+ Vector3 p = m_CornerBuffer[i].collider.ClosestPoint(pos);
+ Vector3 d = p - pos;
+ if (d.magnitude > Vector3.kEpsilon)
+ {
+ if (m_CornerBuffer[i].collider.Raycast(
+ new Ray(pos, d), out m_CornerBuffer[i], nearbyDistance))
+ {
+ if (!(m_CornerBuffer[i].normal - obstacle.normal).AlmostZero())
+ normal2 = m_CornerBuffer[i].normal;
+ break;
+ }
+ }
+ }
+ }
+ }
+
+ // Walk along the wall. If we're in a corner, walk their intersecting line
+ Vector3 dir = Vector3.Cross(obstacle.normal, normal2);
+ if (dir.AlmostZero())
+ dir = Vector3.ProjectOnPlane(pushDir, obstacle.normal);
+ else
+ {
+ float dot = Vector3.Dot(dir, pushDir);
+ if (Mathf.Abs(dot) < Epsilon)
+ return false;
+ if (dot < 0)
+ dir = -dir;
+ }
+ if (dir.AlmostZero())
+ return false;
+
+ outDir = dir.normalized;
+ return true;
+ }
+
+ const float AngleThreshold = 0.1f;
+ float GetPushBackDistance(Ray ray, Plane startPlane, float targetDistance, Vector3 lookAtPos)
+ {
+ float maxDistance = targetDistance - (ray.origin - lookAtPos).magnitude;
+ if (maxDistance < Epsilon)
+ return 0;
+ if (m_Strategy == ResolutionStrategy.PreserveCameraDistance)
+ return maxDistance;
+
+ float distance;
+ if (!startPlane.Raycast(ray, out distance))
+ distance = 0;
+ distance = Mathf.Min(maxDistance, distance);
+ if (distance < Epsilon)
+ return 0;
+
+ // If we are close to parallel to the plane, we have to take special action
+ float angle = Mathf.Abs(UnityVectorExtensions.Angle(startPlane.normal, ray.direction) - 90);
+ if (angle < AngleThreshold)
+ distance = Mathf.Lerp(0, distance, angle / AngleThreshold);
+ return distance;
+ }
+
+ float ClampRayToBounds(Ray ray, float distance, Bounds bounds)
+ {
+ float d;
+ if (Vector3.Dot(ray.direction, Vector3.up) > 0)
+ {
+ if (new Plane(Vector3.down, bounds.max).Raycast(ray, out d) && d > Epsilon)
+ distance = Mathf.Min(distance, d);
+ }
+ else if (Vector3.Dot(ray.direction, Vector3.down) > 0)
+ {
+ if (new Plane(Vector3.up, bounds.min).Raycast(ray, out d) && d > Epsilon)
+ distance = Mathf.Min(distance, d);
+ }
+
+ if (Vector3.Dot(ray.direction, Vector3.right) > 0)
+ {
+ if (new Plane(Vector3.left, bounds.max).Raycast(ray, out d) && d > Epsilon)
+ distance = Mathf.Min(distance, d);
+ }
+ else if (Vector3.Dot(ray.direction, Vector3.left) > 0)
+ {
+ if (new Plane(Vector3.right, bounds.min).Raycast(ray, out d) && d > Epsilon)
+ distance = Mathf.Min(distance, d);
+ }
+
+ if (Vector3.Dot(ray.direction, Vector3.forward) > 0)
+ {
+ if (new Plane(Vector3.back, bounds.max).Raycast(ray, out d) && d > Epsilon)
+ distance = Mathf.Min(distance, d);
+ }
+ else if (Vector3.Dot(ray.direction, Vector3.back) > 0)
+ {
+ if (new Plane(Vector3.forward, bounds.min).Raycast(ray, out d) && d > Epsilon)
+ distance = Mathf.Min(distance, d);
+ }
+ return distance;
+ }
+
+ private Collider[] mColliderBuffer = new Collider[5];
+ private static SphereCollider mCameraCollider;
+ private static GameObject mCameraColliderGameObject;
+ private Vector3 RespectCameraRadius(Vector3 cameraPos, ref CameraState state)
+ {
+ Vector3 result = Vector3.zero;
+ if (m_CameraRadius < Epsilon || m_CollideAgainst == 0)
+ return result;
+
+ Vector3 dir = state.HasLookAt ? (cameraPos - state.ReferenceLookAt) : Vector3.zero;
+ Ray ray = new Ray();
+ float distance = dir.magnitude;
+ if (distance > Epsilon)
+ {
+ dir /= distance;
+ ray = new Ray(state.ReferenceLookAt, dir);
+ }
+ // Pull it out of any intersecting obstacles
+ RaycastHit hitInfo;
+ int numObstacles = Physics.OverlapSphereNonAlloc(
+ cameraPos, m_CameraRadius, mColliderBuffer,
+ m_CollideAgainst, QueryTriggerInteraction.Ignore);
+ if (numObstacles == 0 && m_TransparentLayers != 0
+ && distance > m_MinimumDistanceFromTarget + Epsilon)
+ {
+ // Make sure the camera position isn't completely inside an obstacle.
+ // OverlapSphereNonAlloc won't catch those.
+ float d = distance - m_MinimumDistanceFromTarget;
+ Vector3 targetPos = state.ReferenceLookAt + dir * m_MinimumDistanceFromTarget;
+ if (RaycastIgnoreTag(new Ray(targetPos, dir), out hitInfo, d, m_CollideAgainst))
+ {
+ // Only count it if there's an incoming collision but not an outgoing one
+ Collider c = hitInfo.collider;
+ if (!c.Raycast(new Ray(cameraPos, -dir), out hitInfo, d))
+ mColliderBuffer[numObstacles++] = c;
+ }
+ }
+ if (numObstacles > 0 && distance == 0 || distance > m_MinimumDistanceFromTarget)
+ {
+ if (mCameraColliderGameObject == null)
+ {
+ mCameraColliderGameObject = new GameObject("CinemachineCollider Collider");
+ mCameraColliderGameObject.hideFlags = HideFlags.HideAndDontSave;
+ mCameraColliderGameObject.transform.position = Vector3.zero;
+ mCameraColliderGameObject.SetActive(true);
+ mCameraCollider = mCameraColliderGameObject.AddComponent<SphereCollider>();
+ mCameraCollider.isTrigger = true;
+ var rb = mCameraColliderGameObject.AddComponent<Rigidbody>();
+ rb.detectCollisions = false;
+ rb.isKinematic = true;
+ }
+ mCameraCollider.radius = m_CameraRadius;
+ Vector3 offsetDir;
+ float offsetDistance;
+ Vector3 newCamPos = cameraPos;
+ for (int i = 0; i < numObstacles; ++i)
+ {
+ Collider c = mColliderBuffer[i];
+ if (m_IgnoreTag.Length > 0 && c.CompareTag(m_IgnoreTag))
+ continue;
+
+ // If we have a lookAt target, move the camera to the nearest edge of obstacle
+ if (distance > m_MinimumDistanceFromTarget)
+ {
+ dir = newCamPos - state.ReferenceLookAt;
+ float d = dir.magnitude;
+ if (d > Epsilon)
+ {
+ dir /= d;
+ ray = new Ray(state.ReferenceLookAt, dir);
+ if (c.Raycast(ray, out hitInfo, d + m_CameraRadius))
+ newCamPos = ray.GetPoint(hitInfo.distance) - (dir * PrecisionSlush);
+ }
+ }
+ if (Physics.ComputePenetration(
+ mCameraCollider, newCamPos, Quaternion.identity,
+ c, c.transform.position, c.transform.rotation,
+ out offsetDir, out offsetDistance))
+ {
+ newCamPos += offsetDir * offsetDistance;
+ }
+ }
+ result = newCamPos - cameraPos;
+ }
+
+ // Respect the minimum distance from target - push camera back if we have to
+ if (distance > Epsilon)
+ {
+ float minDistance = Mathf.Max(m_MinimumDistanceFromTarget, m_CameraRadius) + PrecisionSlush;
+ Vector3 newOffset = cameraPos + result - state.ReferenceLookAt;
+ if (newOffset.magnitude < minDistance)
+ result = state.ReferenceLookAt - cameraPos + dir * minDistance;
+ }
+
+ return result;
+ }
+
+ private bool CheckForTargetObstructions(CameraState state)
+ {
+ if (state.HasLookAt)
+ {
+ Vector3 lookAtPos = state.ReferenceLookAt;
+ Vector3 pos = state.CorrectedPosition;
+ Vector3 dir = lookAtPos - pos;
+ float distance = dir.magnitude;
+ if (distance < Mathf.Max(m_MinimumDistanceFromTarget, Epsilon))
+ return true;
+ Ray ray = new Ray(pos, dir.normalized);
+ RaycastHit hitInfo;
+ if (RaycastIgnoreTag(ray, out hitInfo,
+ distance - m_MinimumDistanceFromTarget,
+ m_CollideAgainst & ~m_TransparentLayers))
+ return true;
+ }
+ return false;
+ }
+
+ private bool IsTargetOffscreen(CameraState state)
+ {
+ if (state.HasLookAt)
+ {
+ Vector3 dir = state.ReferenceLookAt - state.CorrectedPosition;
+ dir = Quaternion.Inverse(state.CorrectedOrientation) * dir;
+ if (state.Lens.Orthographic)
+ {
+ if (Mathf.Abs(dir.y) > state.Lens.OrthographicSize)
+ return true;
+ if (Mathf.Abs(dir.x) > state.Lens.OrthographicSize * state.Lens.Aspect)
+ return true;
+ }
+ else
+ {
+ float fov = state.Lens.FieldOfView / 2;
+ float angle = UnityVectorExtensions.Angle(dir.ProjectOntoPlane(Vector3.right), Vector3.forward);
+ if (angle > fov)
+ return true;
+
+ fov = Mathf.Rad2Deg * Mathf.Atan(Mathf.Tan(fov * Mathf.Deg2Rad) * state.Lens.Aspect);
+ angle = UnityVectorExtensions.Angle(dir.ProjectOntoPlane(Vector3.up), Vector3.forward);
+ if (angle > fov)
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: e501d18bb52cf8c40b1853ca4904654f
+timeCreated: 1491854845
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS || CINEMACHINE_PHYSICS_2D
+
+using UnityEngine;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+using System;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// An add-on module for Cinemachine Virtual Camera that post-processes
+ /// the final position of the virtual camera. It will confine the virtual
+ /// camera's position to the volume specified in the Bounding Volume field.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Hide in menu
+ [SaveDuringPlay]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ public class CinemachineConfiner : CinemachineExtension
+ {
+#if CINEMACHINE_PHYSICS && CINEMACHINE_PHYSICS_2D
+ /// <summary>The confiner can operate using a 2D bounding shape or a 3D bounding volume</summary>
+ public enum Mode
+ {
+ /// <summary>Use a 2D bounding shape, suitable for an orthographic camera</summary>
+ Confine2D,
+ /// <summary>Use a 3D bounding shape, suitable for perspective cameras</summary>
+ Confine3D
+ };
+ /// <summary>The confiner can operate using a 2D bounding shape or a 3D bounding volume</summary>
+ [Tooltip("The confiner can operate using a 2D bounding shape or a 3D bounding volume")]
+ public Mode m_ConfineMode;
+#endif
+
+#if CINEMACHINE_PHYSICS
+ /// <summary>The volume within which the camera is to be contained.</summary>
+ [Tooltip("The volume within which the camera is to be contained")]
+ public Collider m_BoundingVolume;
+#endif
+
+#if CINEMACHINE_PHYSICS_2D
+ /// <summary>The 2D shape within which the camera is to be contained.</summary>
+ [Tooltip("The 2D shape within which the camera is to be contained")]
+ public Collider2D m_BoundingShape2D;
+#endif
+ /// <summary>If camera is orthographic, screen edges will be confined to the volume.</summary>
+ [Tooltip("If camera is orthographic, screen edges will be confined to the volume. "
+ + "If not checked, then only the camera center will be confined")]
+ public bool m_ConfineScreenEdges = true;
+
+ /// <summary>How gradually to return the camera to the bounding volume if it goes beyond the borders</summary>
+ [Tooltip("How gradually to return the camera to the bounding volume if it goes beyond the borders. "
+ + "Higher numbers are more gradual.")]
+ [Range(0, 10)]
+ public float m_Damping = 0;
+
+ /// <summary>See whether the virtual camera has been moved by the confiner</summary>
+ /// <param name="vcam">The virtual camera in question. This might be different from the
+ /// virtual camera that owns the confiner, in the event that the camera has children</param>
+ /// <returns>True if the virtual camera has been repositioned</returns>
+ public bool CameraWasDisplaced(CinemachineVirtualCameraBase vcam)
+ {
+ return GetExtraState<VcamExtraState>(vcam).confinerDisplacement > 0;
+ }
+
+ private void OnValidate()
+ {
+ m_Damping = Mathf.Max(0, m_Damping);
+ }
+
+ class VcamExtraState
+ {
+ public Vector3 m_previousDisplacement;
+ public float confinerDisplacement;
+ };
+
+ /// <summary>Check if the bounding volume is defined</summary>
+ public bool IsValid
+ {
+ get
+ {
+#if CINEMACHINE_PHYSICS && !CINEMACHINE_PHYSICS_2D
+ return m_BoundingVolume != null;
+#elif CINEMACHINE_PHYSICS_2D && !CINEMACHINE_PHYSICS
+ return m_BoundingShape2D != null;
+#else
+ return (m_ConfineMode == Mode.Confine3D && m_BoundingVolume != null)
+ || (m_ConfineMode == Mode.Confine2D && m_BoundingShape2D != null);
+#endif
+ }
+ }
+
+ /// <summary>Callback to to the camera confining</summary>
+ protected override void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
+ {
+ if (IsValid)
+ {
+ // Move the body before the Aim is calculated
+ if (stage == CinemachineCore.Stage.Body)
+ {
+ Vector3 displacement;
+ if (m_ConfineScreenEdges && state.Lens.Orthographic)
+ displacement = ConfineScreenEdges(vcam, ref state);
+ else
+ displacement = ConfinePoint(state.CorrectedPosition);
+
+ VcamExtraState extra = GetExtraState<VcamExtraState>(vcam);
+ if (m_Damping > 0 && deltaTime >= 0)
+ {
+ Vector3 delta = displacement - extra.m_previousDisplacement;
+ delta = Damper.Damp(delta, m_Damping, deltaTime);
+ displacement = extra.m_previousDisplacement + delta;
+ }
+ extra.m_previousDisplacement = displacement;
+ state.PositionCorrection += displacement;
+ extra.confinerDisplacement = displacement.magnitude;
+ }
+ }
+ }
+
+ private List<List<Vector2>> m_pathCache;
+ private int m_pathTotalPointCount;
+
+ /// <summary>Call this if the bounding shape's points change at runtime</summary>
+ public void InvalidatePathCache() { m_pathCache = null; }
+
+ bool ValidatePathCache()
+ {
+#if CINEMACHINE_PHYSICS_2D
+ Type colliderType = m_BoundingShape2D == null ? null: m_BoundingShape2D.GetType();
+ if (colliderType == typeof(PolygonCollider2D))
+ {
+ PolygonCollider2D poly = m_BoundingShape2D as PolygonCollider2D;
+ if (m_pathCache == null || m_pathCache.Count != poly.pathCount || m_pathTotalPointCount != poly.GetTotalPointCount())
+ {
+ m_pathCache = new List<List<Vector2>>();
+ for (int i = 0; i < poly.pathCount; ++i)
+ {
+ Vector2[] path = poly.GetPath(i);
+ List<Vector2> dst = new List<Vector2>();
+ for (int j = 0; j < path.Length; ++j)
+ dst.Add(path[j]);
+ m_pathCache.Add(dst);
+ }
+ m_pathTotalPointCount = poly.GetTotalPointCount();
+ }
+ return true;
+ }
+ else if (colliderType == typeof(CompositeCollider2D))
+ {
+ CompositeCollider2D poly = m_BoundingShape2D as CompositeCollider2D;
+ if (m_pathCache == null || m_pathCache.Count != poly.pathCount || m_pathTotalPointCount != poly.pointCount)
+ {
+ m_pathCache = new List<List<Vector2>>();
+ Vector2[] path = new Vector2[poly.pointCount];
+ for (int i = 0; i < poly.pathCount; ++i)
+ {
+ int numPoints = poly.GetPath(i, path);
+ List<Vector2> dst = new List<Vector2>();
+ for (int j = 0; j < numPoints; ++j)
+ dst.Add(path[j]);
+ m_pathCache.Add(dst);
+ }
+ m_pathTotalPointCount = poly.pointCount;
+ }
+ return true;
+ }
+#endif
+ InvalidatePathCache();
+ return false;
+ }
+
+ private Vector3 ConfinePoint(Vector3 camPos)
+ {
+#if CINEMACHINE_PHYSICS
+ // 3D version
+ #if CINEMACHINE_PHYSICS_2D
+ if (m_ConfineMode == Mode.Confine3D)
+ #endif
+ return m_BoundingVolume.ClosestPoint(camPos) - camPos;
+#endif
+
+#if CINEMACHINE_PHYSICS_2D
+ // 2D version
+ Vector2 p = camPos;
+ Vector2 closest = p;
+ if (m_BoundingShape2D.OverlapPoint(camPos))
+ return Vector3.zero;
+ // Find the nearest point on the shape's boundary
+ if (!ValidatePathCache())
+ return Vector3.zero;
+
+ float bestDistance = float.MaxValue;
+ for (int i = 0; i < m_pathCache.Count; ++i)
+ {
+ int numPoints = m_pathCache[i].Count;
+ if (numPoints > 0)
+ {
+ Vector2 v0 = m_BoundingShape2D.transform.TransformPoint(m_pathCache[i][numPoints-1]);
+ for (int j = 0; j < numPoints; ++j)
+ {
+ Vector2 v = m_BoundingShape2D.transform.TransformPoint(m_pathCache[i][j]);
+ Vector2 c = Vector2.Lerp(v0, v, p.ClosestPointOnSegment(v0, v));
+ float d = Vector2.SqrMagnitude(p - c);
+ if (d < bestDistance)
+ {
+ bestDistance = d;
+ closest = c;
+ }
+ v0 = v;
+ }
+ }
+ }
+ return closest - p;
+#endif
+ }
+
+ // Camera must be orthographic
+ private Vector3 ConfineScreenEdges(CinemachineVirtualCameraBase vcam, ref CameraState state)
+ {
+ Quaternion rot = Quaternion.Inverse(state.CorrectedOrientation);
+ float dy = state.Lens.OrthographicSize;
+ float dx = dy * state.Lens.Aspect;
+ Vector3 vx = (rot * Vector3.right) * dx;
+ Vector3 vy = (rot * Vector3.up) * dy;
+
+ Vector3 displacement = Vector3.zero;
+ Vector3 camPos = state.CorrectedPosition;
+ const int kMaxIter = 12;
+ for (int i = 0; i < kMaxIter; ++i)
+ {
+ Vector3 d = ConfinePoint((camPos - vy) - vx);
+ if (d.AlmostZero())
+ d = ConfinePoint((camPos - vy) + vx);
+ if (d.AlmostZero())
+ d = ConfinePoint((camPos + vy) - vx);
+ if (d.AlmostZero())
+ d = ConfinePoint((camPos + vy) + vx);
+ if (d.AlmostZero())
+ break;
+ displacement += d;
+ camPos += d;
+ }
+ return displacement;
+ }
+ }
+}
+
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: a2fba25a5cd15594e8f050a11e386c80
+timeCreated: 1503419997
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a very simple behaviour that constrains its transform to a CinemachinePath.
+ /// It can be used to animate any objects along a path, or as a Follow target for
+ /// Cinemachine Virtual Cameras.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ public class CinemachineDollyCart : MonoBehaviour
+ {
+ /// <summary>The path to follow</summary>
+ [Tooltip("The path to follow")]
+ public CinemachinePathBase m_Path;
+
+ /// <summary>This enum defines the options available for the update method.</summary>
+ public enum UpdateMethod
+ {
+ /// <summary>Updated in normal MonoBehaviour Update.</summary>
+ Update,
+ /// <summary>Updated in sync with the Physics module, in FixedUpdate</summary>
+ FixedUpdate,
+ /// <summary>Updated in normal MonoBehaviour LateUpdate</summary>
+ LateUpdate
+ };
+
+ /// <summary>When to move the cart, if Velocity is non-zero</summary>
+ [Tooltip("When to move the cart, if Velocity is non-zero")]
+ public UpdateMethod m_UpdateMethod = UpdateMethod.Update;
+
+ /// <summary>How to interpret the Path Position</summary>
+ [Tooltip("How to interpret the Path Position. If set to Path Units, values are as follows: 0 represents the first waypoint on the path, 1 is the second, and so on. Values in-between are points on the path in between the waypoints. If set to Distance, then Path Position represents distance along the path.")]
+ public CinemachinePathBase.PositionUnits m_PositionUnits = CinemachinePathBase.PositionUnits.Distance;
+
+ /// <summary>Move the cart with this speed</summary>
+ [Tooltip("Move the cart with this speed along the path. The value is interpreted according to the Position Units setting.")]
+ [FormerlySerializedAs("m_Velocity")]
+ public float m_Speed;
+
+ /// <summary>The cart's current position on the path, in distance units</summary>
+ [Tooltip("The position along the path at which the cart will be placed. This can be animated directly or, if the velocity is non-zero, will be updated automatically. The value is interpreted according to the Position Units setting.")]
+ [FormerlySerializedAs("m_CurrentDistance")]
+ public float m_Position;
+
+ void FixedUpdate()
+ {
+ if (m_UpdateMethod == UpdateMethod.FixedUpdate)
+ SetCartPosition(m_Position + m_Speed * Time.deltaTime);
+ }
+
+ void Update()
+ {
+ float speed = Application.isPlaying ? m_Speed : 0;
+ if (m_UpdateMethod == UpdateMethod.Update)
+ SetCartPosition(m_Position + speed * Time.deltaTime);
+ }
+
+ void LateUpdate()
+ {
+ if (!Application.isPlaying)
+ SetCartPosition(m_Position);
+ else if (m_UpdateMethod == UpdateMethod.LateUpdate)
+ SetCartPosition(m_Position + m_Speed * Time.deltaTime);
+ }
+
+ void SetCartPosition(float distanceAlongPath)
+ {
+ if (m_Path != null)
+ {
+ m_Position = m_Path.StandardizeUnit(distanceAlongPath, m_PositionUnits);
+ transform.position = m_Path.EvaluatePositionAtUnit(m_Position, m_PositionUnits);
+ transform.rotation = m_Path.EvaluateOrientationAtUnit(m_Position, m_PositionUnits);
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 99a9c787e5d1bbf48a389834c4a9641c
+timeCreated: 1502981597
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This component will expose a non-cinemachine camera to the cinemachine system,
+ /// allowing it to participate in blends.
+ /// Just add it as a component alongside an existing Unity Camera component.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [RequireComponent(typeof(Camera)), DisallowMultipleComponent]
+ [AddComponentMenu("Cinemachine/CinemachineExternalCamera")]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ public class CinemachineExternalCamera : CinemachineVirtualCameraBase
+ {
+ /// <summary>The object that the camera is looking at.</summary>
+ [Tooltip("The object that the camera is looking at. Setting this will improve the quality of the blends to and from this camera")]
+ [NoSaveDuringPlay]
+ public Transform m_LookAt = null;
+
+ private Camera m_Camera;
+ private CameraState m_State = CameraState.Default;
+
+ /// <summary>Get the CameraState, as we are able to construct one from the Unity Camera</summary>
+ public override CameraState State { get { return m_State; } }
+
+ /// <summary>The object that the camera is looking at</summary>
+ override public Transform LookAt
+ {
+ get { return m_LookAt; }
+ set { m_LookAt = value; }
+ }
+
+ /// <summary>This vcam defines no targets</summary>
+ override public Transform Follow { get; set; }
+
+ /// <summary>Hint for blending positions to and from this virtual camera</summary>
+ [Tooltip("Hint for blending positions to and from this virtual camera")]
+ [FormerlySerializedAs("m_PositionBlending")]
+ public BlendHint m_BlendHint = BlendHint.None;
+
+ /// <summary>Internal use only. Do not call this method</summary>
+ public override void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ // Get the state from the camera
+ if (m_Camera == null)
+ m_Camera = GetComponent<Camera>();
+
+ m_State = CameraState.Default;
+ m_State.RawPosition = transform.position;
+ m_State.RawOrientation = transform.rotation;
+ m_State.ReferenceUp = m_State.RawOrientation * Vector3.up;
+ if (m_Camera != null)
+ m_State.Lens = LensSettings.FromCamera(m_Camera);
+
+ if (m_LookAt != null)
+ {
+ m_State.ReferenceLookAt = m_LookAt.transform.position;
+ Vector3 dir = m_State.ReferenceLookAt - State.RawPosition;
+ if (!dir.AlmostZero())
+ m_State.ReferenceLookAt = m_State.RawPosition + Vector3.Project(
+ dir, State.RawOrientation * Vector3.forward);
+ }
+ ApplyPositionBlendMethod(ref m_State, m_BlendHint);
+ InvokePostPipelineStageCallback(this, CinemachineCore.Stage.Finalize, ref m_State, deltaTime);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 57744762d9079934292f57896d8193e0
+timeCreated: 1489441713
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// An add-on module for Cinemachine Virtual Camera that adjusts
+ /// the FOV of the lens to keep the target object at a constant size on the screen,
+ /// regardless of camera and target position.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Hide in menu
+ [SaveDuringPlay]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ public class CinemachineFollowZoom : CinemachineExtension
+ {
+ /// <summary>The shot width to maintain, in world units, at target distance.
+ /// FOV will be adusted as far as possible to maintain this width at the
+ /// target distance from the camera.</summary>
+ [Tooltip("The shot width to maintain, in world units, at target distance.")]
+ public float m_Width = 2f;
+
+ /// <summary>Increase this value to soften the aggressiveness of the follow-zoom.
+ /// Small numbers are more responsive, larger numbers give a more heavy slowly responding camera. </summary>
+ [Range(0f, 20f)]
+ [Tooltip("Increase this value to soften the aggressiveness of the follow-zoom. Small numbers are more responsive, larger numbers give a more heavy slowly responding camera.")]
+ public float m_Damping = 1f;
+
+ /// <summary>Will not generate an FOV smaller than this.</summary>
+ [Range(1f, 179f)]
+ [Tooltip("Lower limit for the FOV that this behaviour will generate.")]
+ public float m_MinFOV = 3f;
+
+ /// <summary>Will not generate an FOV larget than this.</summary>
+ [Range(1f, 179f)]
+ [Tooltip("Upper limit for the FOV that this behaviour will generate.")]
+ public float m_MaxFOV = 60f;
+
+ private void OnValidate()
+ {
+ m_Width = Mathf.Max(0, m_Width);
+ m_MaxFOV = Mathf.Clamp(m_MaxFOV, 1, 179);
+ m_MinFOV = Mathf.Clamp(m_MinFOV, 1, m_MaxFOV);
+ }
+
+ class VcamExtraState
+ {
+ public float m_previousFrameZoom = 0;
+ }
+
+ /// <summary>Callback to preform the zoom adjustment</summary>
+ protected override void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
+ {
+ VcamExtraState extra = GetExtraState<VcamExtraState>(vcam);
+ if (deltaTime < 0)
+ extra.m_previousFrameZoom = state.Lens.FieldOfView;
+
+ // Set the zoom after the body has been positioned, but before the aim,
+ // so that composer can compose using the updated fov.
+ if (stage == CinemachineCore.Stage.Body)
+ {
+ // Try to reproduce the target width
+ float targetWidth = Mathf.Max(m_Width, 0);
+ float fov = 179f;
+ float d = Vector3.Distance(state.CorrectedPosition, state.ReferenceLookAt);
+ if (d > UnityVectorExtensions.Epsilon)
+ {
+ // Clamp targetWidth to FOV min/max
+ float minW = d * 2f * Mathf.Tan(m_MinFOV * Mathf.Deg2Rad / 2f);
+ float maxW = d * 2f * Mathf.Tan(m_MaxFOV * Mathf.Deg2Rad / 2f);
+ targetWidth = Mathf.Clamp(targetWidth, minW, maxW);
+
+ // Apply damping
+ if (deltaTime >= 0 && m_Damping > 0)
+ {
+ float currentWidth = d * 2f * Mathf.Tan(extra.m_previousFrameZoom * Mathf.Deg2Rad / 2f);
+ float delta = targetWidth - currentWidth;
+ delta = Damper.Damp(delta, m_Damping, deltaTime);
+ targetWidth = currentWidth + delta;
+ }
+ fov = 2f * Mathf.Atan(targetWidth / (2 * d)) * Mathf.Rad2Deg;
+ }
+ LensSettings lens = state.Lens;
+ lens.FieldOfView = extra.m_previousFrameZoom = Mathf.Clamp(fov, m_MinFOV, m_MaxFOV);
+ state.Lens = lens;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 4700f9f03ad19f94baf0367cb7a9c988
+timeCreated: 1491854845
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using Cinemachine.Utility;
+using UnityEngine.Serialization;
+using System;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// A Cinemachine Camera geared towards a 3rd person camera experience.
+ /// The camera orbits around its subject with three separate camera rigs defining
+ /// rings around the target. Each rig has its own radius, height offset, composer,
+ /// and lens settings.
+ /// Depending on the camera's position along the spline connecting these three rigs,
+ /// these settings are interpolated to give the final camera position and state.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineFreeLook")]
+ public class CinemachineFreeLook : CinemachineVirtualCameraBase
+ {
+ /// <summary>Object for the camera children to look at (the aim target)</summary>
+ [Tooltip("Object for the camera children to look at (the aim target).")]
+ [NoSaveDuringPlay]
+ public Transform m_LookAt = null;
+
+ /// <summary>Object for the camera children wants to move with (the body target)</summary>
+ [Tooltip("Object for the camera children wants to move with (the body target).")]
+ [NoSaveDuringPlay]
+ public Transform m_Follow = null;
+
+ /// <summary>If enabled, this lens setting will apply to all three child rigs, otherwise the child rig lens settings will be used</summary>
+ [Tooltip("If enabled, this lens setting will apply to all three child rigs, otherwise the child rig lens settings will be used")]
+ [FormerlySerializedAs("m_UseCommonLensSetting")]
+ public bool m_CommonLens = true;
+
+ /// <summary>Specifies the lens properties of this Virtual Camera.
+ /// This generally mirrors the Unity Camera's lens settings, and will be used to drive
+ /// the Unity camera when the vcam is active</summary>
+ [FormerlySerializedAs("m_LensAttributes")]
+ [Tooltip("Specifies the lens properties of this Virtual Camera. This generally mirrors the Unity Camera's lens settings, and will be used to drive the Unity camera when the vcam is active")]
+ [LensSettingsProperty]
+ public LensSettings m_Lens = LensSettings.Default;
+
+ /// <summary> Collection of parameters that influence how this virtual camera transitions from
+ /// other virtual cameras </summary>
+ public TransitionParams m_Transitions;
+
+ /// <summary>Legacy support</summary>
+ [SerializeField] [HideInInspector]
+ [FormerlySerializedAs("m_BlendHint")]
+ [FormerlySerializedAs("m_PositionBlending")] private BlendHint m_LegacyBlendHint;
+
+ /// <summary>The Vertical axis. Value is 0..1. Chooses how to blend the child rigs</summary>
+ [Header("Axis Control")]
+ [Tooltip("The Vertical axis. Value is 0..1. Chooses how to blend the child rigs")]
+ [AxisStateProperty]
+ public AxisState m_YAxis = new AxisState(0, 1, false, true, 2f, 0.2f, 0.1f, "Mouse Y", false);
+
+ /// <summary>Controls how automatic recentering of the Y axis is accomplished</summary>
+ [Tooltip("Controls how automatic recentering of the Y axis is accomplished")]
+ public AxisState.Recentering m_YAxisRecentering = new AxisState.Recentering(false, 1, 2);
+
+ /// <summary>The Horizontal axis. Value is -180...180. This is passed on to the rigs' OrbitalTransposer component</summary>
+ [Tooltip("The Horizontal axis. Value is -180...180. This is passed on to the rigs' OrbitalTransposer component")]
+ [AxisStateProperty]
+ public AxisState m_XAxis = new AxisState(-180, 180, true, false, 300f, 0.1f, 0.1f, "Mouse X", true);
+
+ /// <summary>The definition of Forward. Camera will follow behind</summary>
+ [OrbitalTransposerHeadingProperty]
+ [Tooltip("The definition of Forward. Camera will follow behind.")]
+ public CinemachineOrbitalTransposer.Heading m_Heading
+ = new CinemachineOrbitalTransposer.Heading(
+ CinemachineOrbitalTransposer.Heading.HeadingDefinition.TargetForward, 4, 0);
+
+ /// <summary>Controls how automatic recentering of the X axis is accomplished</summary>
+ [Tooltip("Controls how automatic recentering of the X axis is accomplished")]
+ public AxisState.Recentering m_RecenterToTargetHeading = new AxisState.Recentering(false, 1, 2);
+
+ /// <summary>The coordinate space to use when interpreting the offset from the target</summary>
+ [Header("Orbits")]
+ [Tooltip("The coordinate space to use when interpreting the offset from the target. This is also used to set the camera's Up vector, which will be maintained when aiming the camera.")]
+ public CinemachineOrbitalTransposer.BindingMode m_BindingMode
+ = CinemachineOrbitalTransposer.BindingMode.SimpleFollowWithWorldUp;
+
+ /// <summary></summary>
+ [Tooltip("Controls how taut is the line that connects the rigs' orbits, which determines final placement on the Y axis")]
+ [Range(0f, 1f)]
+ [FormerlySerializedAs("m_SplineTension")]
+ public float m_SplineCurvature = 0.2f;
+
+ /// <summary>Defines the height and radius of the Rig orbit</summary>
+ [Serializable]
+ public struct Orbit
+ {
+ /// <summary>Height relative to target</summary>
+ public float m_Height;
+ /// <summary>Radius of orbit</summary>
+ public float m_Radius;
+ /// <summary>Constructor with specific values</summary>
+ public Orbit(float h, float r) { m_Height = h; m_Radius = r; }
+ }
+
+ /// <summary>The radius and height of the three orbiting rigs</summary>
+ [Tooltip("The radius and height of the three orbiting rigs.")]
+ public Orbit[] m_Orbits = new Orbit[3]
+ {
+ // These are the default orbits
+ new Orbit(4.5f, 1.75f),
+ new Orbit(2.5f, 3f),
+ new Orbit(0.4f, 1.3f)
+ };
+
+ // Legacy support
+ [SerializeField] [HideInInspector] [FormerlySerializedAs("m_HeadingBias")]
+ private float m_LegacyHeadingBias = float.MaxValue;
+ bool mUseLegacyRigDefinitions = false;
+
+ /// <summary>Enforce bounds for fields, when changed in inspector.</summary>
+ protected override void OnValidate()
+ {
+ base.OnValidate();
+
+ // Upgrade after a legacy deserialize
+ if (m_LegacyHeadingBias != float.MaxValue)
+ {
+ m_Heading.m_Bias= m_LegacyHeadingBias;
+ m_LegacyHeadingBias = float.MaxValue;
+ int heading = (int)m_Heading.m_Definition;
+ if (m_RecenterToTargetHeading.LegacyUpgrade(ref heading, ref m_Heading.m_VelocityFilterStrength))
+ m_Heading.m_Definition = (CinemachineOrbitalTransposer.Heading.HeadingDefinition)heading;
+ mUseLegacyRigDefinitions = true;
+ }
+ if (m_LegacyBlendHint != BlendHint.None)
+ {
+ m_Transitions.m_BlendHint = m_LegacyBlendHint;
+ m_LegacyBlendHint = BlendHint.None;
+ }
+ m_YAxis.Validate();
+ m_XAxis.Validate();
+ m_RecenterToTargetHeading.Validate();
+ m_YAxisRecentering.Validate();
+ m_Lens.Validate();
+
+ InvalidateRigCache();
+ }
+
+ /// <summary>Get a child rig</summary>
+ /// <param name="i">Rig index. Can be 0, 1, or 2</param>
+ /// <returns>The rig, or null if index is bad.</returns>
+ public CinemachineVirtualCamera GetRig(int i)
+ {
+ UpdateRigCache();
+ return (i < 0 || i > 2) ? null : m_Rigs[i];
+ }
+
+ /// <summary>Names of the 3 child rigs</summary>
+ public static string[] RigNames { get { return new string[] { "TopRig", "MiddleRig", "BottomRig" }; } }
+
+ bool mIsDestroyed = false;
+
+ /// <summary>Updates the child rig cache</summary>
+ protected override void OnEnable()
+ {
+ mIsDestroyed = false;
+ base.OnEnable();
+ InvalidateRigCache();
+ }
+
+ /// <summary>Makes sure that the child rigs get destroyed in an undo-firndly manner.
+ /// Invalidates the rig cache.</summary>
+ protected override void OnDestroy()
+ {
+ // Make the rigs visible instead of destroying - this is to keep Undo happy
+ if (m_Rigs != null)
+ foreach (var rig in m_Rigs)
+ if (rig != null && rig.gameObject != null)
+ rig.gameObject.hideFlags
+ &= ~(HideFlags.HideInHierarchy | HideFlags.HideInInspector);
+
+ mIsDestroyed = true;
+ base.OnDestroy();
+ }
+
+ /// <summary>Invalidates the rig cache</summary>
+ void OnTransformChildrenChanged()
+ {
+ InvalidateRigCache();
+ }
+
+ void Reset()
+ {
+ DestroyRigs();
+ }
+
+ /// <summary>The cacmera state, which will be a blend of the child rig states</summary>
+ override public CameraState State { get { return m_State; } }
+
+ /// <summary>Get the current LookAt target. Returns parent's LookAt if parent
+ /// is non-null and no specific LookAt defined for this camera</summary>
+ override public Transform LookAt
+ {
+ get { return ResolveLookAt(m_LookAt); }
+ set { m_LookAt = value; }
+ }
+
+ /// <summary>Get the current Follow target. Returns parent's Follow if parent
+ /// is non-null and no specific Follow defined for this camera</summary>
+ override public Transform Follow
+ {
+ get { return ResolveFollow(m_Follow); }
+ set { m_Follow = value; }
+ }
+
+ /// <summary>Check whether the vcam a live child of this camera.
+ /// Returns true if the child is currently contributing actively to the camera state.</summary>
+ /// <param name="vcam">The Virtual Camera to check</param>
+ /// <param name="dominantChildOnly">If truw, will only return true if this vcam is the dominat live child</param>
+ /// <returns>True if the vcam is currently actively influencing the state of this vcam</returns>
+ public override bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false)
+ {
+ // Do not update the rig cache here or there will be infinite loop at creation time
+ if (m_Rigs == null || m_Rigs.Length != 3)
+ return false;
+ var y = GetYAxisValue();
+ if (dominantChildOnly)
+ {
+ if (vcam == (ICinemachineCamera)m_Rigs[0])
+ return y > 0.666f;
+ if (vcam == (ICinemachineCamera)m_Rigs[2])
+ return y < 0.333;
+ if (vcam == (ICinemachineCamera)m_Rigs[1])
+ return y >= 0.333f && y <= 0.666f;
+ return false;
+ }
+ if (vcam == (ICinemachineCamera)m_Rigs[1])
+ return true;
+ if (y < 0.5f)
+ return vcam == (ICinemachineCamera)m_Rigs[2];
+ return vcam == (ICinemachineCamera)m_Rigs[0];
+ }
+
+ /// <summary>This is called to notify the vcam that a target got warped,
+ /// so that the vcam can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ UpdateRigCache();
+ if (m_Rigs != null)
+ foreach (var vcam in m_Rigs)
+ vcam.OnTargetObjectWarped(target, positionDelta);
+ base.OnTargetObjectWarped(target, positionDelta);
+ }
+
+ /// <summary>Internal use only. Called by CinemachineCore at designated update time
+ /// so the vcam can position itself and track its targets. All 3 child rigs are updated,
+ /// and a blend calculated, depending on the value of the Y axis.</summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ override public void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ if (!PreviousStateIsValid)
+ deltaTime = -1;
+
+ UpdateRigCache();
+
+ // Update the current state by invoking the component pipeline
+ m_State = CalculateNewState(worldUp, deltaTime);
+ ApplyPositionBlendMethod(ref m_State, m_Transitions.m_BlendHint);
+
+ // Push the raw position back to the game object's transform, so it
+ // moves along with the camera. Leave the orientation alone, because it
+ // screws up camera dragging when there is a LookAt behaviour.
+ if (Follow != null)
+ {
+ Vector3 delta = State.RawPosition - transform.position;
+ transform.position = State.RawPosition;
+ m_Rigs[0].transform.position -= delta;
+ m_Rigs[1].transform.position -= delta;
+ m_Rigs[2].transform.position -= delta;
+ }
+
+ InvokePostPipelineStageCallback(this, CinemachineCore.Stage.Finalize, ref m_State, deltaTime);
+ PreviousStateIsValid = true;
+
+ // Set up for next frame
+ bool activeCam = (deltaTime >= 0) && CinemachineCore.Instance.IsLive(this);
+ if (activeCam)
+ {
+ if (m_YAxis.Update(deltaTime))
+ m_YAxisRecentering.CancelRecentering();
+ }
+ PushSettingsToRigs();
+ if (m_BindingMode == CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp)
+ m_XAxis.Value = 0;
+ }
+
+ /// <summary>If we are transitioning from another FreeLook, grab the axis values from it.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ bool forceUpdate = false;
+ if (fromCam != null && m_Transitions.m_InheritPosition)
+ {
+ var cameraPos = fromCam.State.RawPosition;
+
+ // Special handling for FreeLook: get an undamped outgoing position
+ if (fromCam is CinemachineFreeLook)
+ {
+ var flFrom = (fromCam as CinemachineFreeLook);
+ var orbital = flFrom.mOrbitals != null ? flFrom.mOrbitals[1] : null;
+ if (orbital != null)
+ cameraPos = orbital.GetTargetCameraPosition(worldUp);
+ }
+ UpdateRigCache();
+ if (m_BindingMode != CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp)
+ m_XAxis.Value = mOrbitals[1].GetAxisClosestValue(cameraPos, worldUp);
+ m_YAxis.Value = GetYAxisClosestValue(cameraPos, worldUp);
+
+ transform.position = cameraPos;
+ m_State = PullStateFromVirtualCamera(worldUp, ref m_Lens);
+ PreviousStateIsValid = false;
+ PushSettingsToRigs();
+ forceUpdate = true;
+ }
+ if (forceUpdate)
+ InternalUpdateCameraState(worldUp, deltaTime);
+ else
+ UpdateCameraState(worldUp, deltaTime);
+ if (m_Transitions.m_OnCameraLive != null)
+ m_Transitions.m_OnCameraLive.Invoke(this, fromCam);
+ }
+
+ float GetYAxisClosestValue(Vector3 cameraPos, Vector3 up)
+ {
+ if (Follow != null)
+ {
+ // Rotate the camera pos to the back
+ Quaternion q = Quaternion.FromToRotation(up, Vector3.up);
+ Vector3 dir = q * (cameraPos - Follow.position);
+ Vector3 flatDir = dir; flatDir.y = 0;
+ if (!flatDir.AlmostZero())
+ {
+ float angle = Vector3.SignedAngle(flatDir, Vector3.back, Vector3.up);
+ dir = Quaternion.AngleAxis(angle, Vector3.up) * dir;
+ }
+ dir.x = 0;
+
+ // Sample the spline in a few places, find the 2 closest, and lerp
+ int i0 = 0, i1 = 0;
+ float a0 = 0, a1 = 0;
+ const int NumSamples = 13;
+ float step = 1f / (NumSamples-1);
+ for (int i = 0; i < NumSamples; ++i)
+ {
+ float a = Vector3.SignedAngle(
+ dir, GetLocalPositionForCameraFromInput(i * step), Vector3.right);
+ if (i == 0)
+ a0 = a1 = a;
+ else
+ {
+ if (Mathf.Abs(a) < Mathf.Abs(a0))
+ {
+ a1 = a0;
+ i1 = i0;
+ a0 = a;
+ i0 = i;
+ }
+ else if (Mathf.Abs(a) < Mathf.Abs(a1))
+ {
+ a1 = a;
+ i1 = i;
+ }
+ }
+ }
+ if (Mathf.Sign(a0) == Mathf.Sign(a1))
+ return i0 * step;
+ float t = Mathf.Abs(a0) / (Mathf.Abs(a0) + Mathf.Abs(a1));
+ return Mathf.Lerp(i0 * step, i1 * step, t);
+ }
+ return m_YAxis.Value; // stay conservative
+ }
+
+ CameraState m_State = CameraState.Default; // Current state this frame
+
+ /// Serialized in order to support copy/paste
+ [SerializeField][HideInInspector][NoSaveDuringPlay] private CinemachineVirtualCamera[] m_Rigs
+ = new CinemachineVirtualCamera[3];
+
+ void InvalidateRigCache() { mOrbitals = null; }
+ CinemachineOrbitalTransposer[] mOrbitals = null;
+ CinemachineBlend mBlendA;
+ CinemachineBlend mBlendB;
+
+ /// <summary>
+ /// Override component pipeline creation.
+ /// This needs to be done by the editor to support Undo.
+ /// The override must do exactly the same thing as the CreatePipeline method in this class.
+ /// </summary>
+ public static CreateRigDelegate CreateRigOverride;
+
+ /// <summary>
+ /// Override component pipeline creation.
+ /// This needs to be done by the editor to support Undo.
+ /// The override must do exactly the same thing as the CreatePipeline method in this class.
+ /// </summary>
+ public delegate CinemachineVirtualCamera CreateRigDelegate(
+ CinemachineFreeLook vcam, string name, CinemachineVirtualCamera copyFrom);
+
+ /// <summary>
+ /// Override component pipeline destruction.
+ /// This needs to be done by the editor to support Undo.
+ /// </summary>
+ public static DestroyRigDelegate DestroyRigOverride;
+
+ /// <summary>
+ /// Override component pipeline destruction.
+ /// This needs to be done by the editor to support Undo.
+ /// </summary>
+ public delegate void DestroyRigDelegate(GameObject rig);
+
+ private void DestroyRigs()
+ {
+ CinemachineVirtualCamera[] oldRigs = new CinemachineVirtualCamera[RigNames.Length];
+ for (int i = 0; i < RigNames.Length; ++i)
+ {
+ foreach (Transform child in transform)
+ if (child.gameObject.name == RigNames[i])
+ oldRigs[i] = child.GetComponent<CinemachineVirtualCamera>();
+ }
+ for (int i = 0; i < oldRigs.Length; ++i)
+ {
+ if (oldRigs[i] != null)
+ {
+ if (DestroyRigOverride != null)
+ DestroyRigOverride(oldRigs[i].gameObject);
+ else
+ Destroy(oldRigs[i].gameObject);
+ }
+ }
+ m_Rigs = null;
+ mOrbitals = null;
+ }
+
+ private CinemachineVirtualCamera[] CreateRigs(CinemachineVirtualCamera[] copyFrom)
+ {
+ // Invalidate the cache
+ mOrbitals = null;
+ float[] softCenterDefaultsV = new float[] { 0.5f, 0.55f, 0.6f };
+ CinemachineVirtualCamera[] newRigs = new CinemachineVirtualCamera[3];
+ for (int i = 0; i < RigNames.Length; ++i)
+ {
+ CinemachineVirtualCamera src = null;
+ if (copyFrom != null && copyFrom.Length > i)
+ src = copyFrom[i];
+
+ if (CreateRigOverride != null)
+ newRigs[i] = CreateRigOverride(this, RigNames[i], src);
+ else
+ {
+ // Create a new rig with default components
+ // Note: copyFrom only supported in Editor, not build
+ GameObject go = new GameObject(RigNames[i]);
+ go.transform.parent = transform;
+ newRigs[i] = go.AddComponent<CinemachineVirtualCamera>();
+ go = newRigs[i].GetComponentOwner().gameObject;
+ go.AddComponent<CinemachineOrbitalTransposer>();
+ go.AddComponent<CinemachineComposer>();
+ }
+
+ // Set up the defaults
+ newRigs[i].InvalidateComponentPipeline();
+ CinemachineOrbitalTransposer orbital = newRigs[i].GetCinemachineComponent<CinemachineOrbitalTransposer>();
+ if (orbital == null)
+ orbital = newRigs[i].AddCinemachineComponent<CinemachineOrbitalTransposer>(); // should not happen
+ if (src == null)
+ {
+ // Only set defaults if not copying
+ orbital.m_YawDamping = 0;
+ CinemachineComposer composer = newRigs[i].GetCinemachineComponent<CinemachineComposer>();
+ if (composer != null)
+ {
+ composer.m_HorizontalDamping = composer.m_VerticalDamping = 0;
+ composer.m_ScreenX = 0.5f;
+ composer.m_ScreenY = softCenterDefaultsV[i];
+ composer.m_DeadZoneWidth = composer.m_DeadZoneHeight = 0f;
+ composer.m_SoftZoneWidth = composer.m_SoftZoneHeight = 0.8f;
+ composer.m_BiasX = composer.m_BiasY = 0;
+ }
+ }
+ }
+ return newRigs;
+ }
+
+ private void UpdateRigCache()
+ {
+ if (mIsDestroyed)
+ return;
+
+ bool isPrefab = false;
+
+#if UNITY_EDITOR
+ // Special condition: Did we just get copy/pasted?
+ if (m_Rigs != null && m_Rigs.Length == 3
+ && m_Rigs[0] != null && m_Rigs[0].transform.parent != transform)
+ {
+ isPrefab = gameObject.scene.name == null; // causes a small GC alloc
+ if (!isPrefab) // can't paste to a prefab
+ {
+ var copyFrom = m_Rigs;
+ DestroyRigs();
+ m_Rigs = CreateRigs(copyFrom);
+ }
+ }
+ for (int i = 0; m_Rigs != null && i < 3; ++i)
+ if (m_Rigs[i] != null)
+ CinemachineVirtualCamera.SetFlagsForHiddenChild(m_Rigs[i].gameObject);
+#endif
+
+ // Early out if we're up to date
+ if (mOrbitals != null && mOrbitals.Length == 3)
+ return;
+
+ // Locate existing rigs, and recreate them if any are missing
+ isPrefab = gameObject.scene.name == null; // causes a small GC alloc
+ if (LocateExistingRigs(RigNames, false) != 3 && !isPrefab)
+ {
+ DestroyRigs();
+ m_Rigs = CreateRigs(null);
+ LocateExistingRigs(RigNames, true);
+ }
+
+ foreach (var rig in m_Rigs)
+ {
+ // Configure the UI
+ rig.m_ExcludedPropertiesInInspector = m_CommonLens
+ ? new string[] { "m_Script", "Header", "Extensions", "m_Priority", "m_Transitions", "m_Follow", "m_StandbyUpdate", "m_Lens" }
+ : new string[] { "m_Script", "Header", "Extensions", "m_Priority", "m_Transitions", "m_Follow", "m_StandbyUpdate" };
+ rig.m_LockStageInInspector = new CinemachineCore.Stage[] { CinemachineCore.Stage.Body };
+ }
+
+ // Create the blend objects
+ mBlendA = new CinemachineBlend(m_Rigs[1], m_Rigs[0], AnimationCurve.Linear(0, 0, 1, 1), 1, 0);
+ mBlendB = new CinemachineBlend(m_Rigs[2], m_Rigs[1], AnimationCurve.Linear(0, 0, 1, 1), 1, 0);
+ }
+
+ private int LocateExistingRigs(string[] rigNames, bool forceOrbital)
+ {
+ mOrbitals = new CinemachineOrbitalTransposer[rigNames.Length];
+ m_Rigs = new CinemachineVirtualCamera[rigNames.Length];
+ int rigsFound = 0;
+ foreach (Transform child in transform)
+ {
+ CinemachineVirtualCamera vcam = child.GetComponent<CinemachineVirtualCamera>();
+ if (vcam != null)
+ {
+ GameObject go = child.gameObject;
+ for (int i = 0; i < rigNames.Length; ++i)
+ {
+ if (mOrbitals[i] == null && go.name == rigNames[i])
+ {
+ // Must have an orbital transposer or it's no good
+ mOrbitals[i] = vcam.GetCinemachineComponent<CinemachineOrbitalTransposer>();
+ if (mOrbitals[i] == null && forceOrbital)
+ mOrbitals[i] = vcam.AddCinemachineComponent<CinemachineOrbitalTransposer>();
+ if (mOrbitals[i] != null)
+ {
+ mOrbitals[i].m_HeadingIsSlave = true;
+ if (i == 1)
+ mOrbitals[i].HeadingUpdater = UpdateXAxisHeading;
+ m_Rigs[i] = vcam;
+ m_Rigs[i].m_StandbyUpdate = m_StandbyUpdate;
+ ++rigsFound;
+ }
+ }
+ }
+ }
+ }
+ return rigsFound;
+ }
+
+ float UpdateXAxisHeading(CinemachineOrbitalTransposer orbital, float deltaTime, Vector3 up)
+ {
+ var oldValue = m_XAxis.Value;
+ float headng = orbital.UpdateHeading(deltaTime, up, ref m_XAxis);
+ // Allow externally-driven values to work in this mode
+ if (orbital.m_BindingMode == CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp)
+ m_XAxis.Value = oldValue;
+ return headng;
+ }
+
+ void PushSettingsToRigs()
+ {
+ UpdateRigCache();
+ for (int i = 0; i < m_Rigs.Length; ++i)
+ {
+ if (m_Rigs[i] == null)
+ continue;
+
+ if (m_CommonLens)
+ m_Rigs[i].m_Lens = m_Lens;
+
+ // If we just deserialized from a legacy version,
+ // pull the orbits and targets from the rigs
+ if (mUseLegacyRigDefinitions)
+ {
+ mUseLegacyRigDefinitions = false;
+ m_Orbits[i].m_Height = mOrbitals[i].m_FollowOffset.y;
+ m_Orbits[i].m_Radius = -mOrbitals[i].m_FollowOffset.z;
+ if (m_Rigs[i].Follow != null)
+ Follow = m_Rigs[i].Follow;
+ }
+ m_Rigs[i].Follow = null;
+ m_Rigs[i].m_StandbyUpdate = m_StandbyUpdate;
+ if (!PreviousStateIsValid)
+ {
+ m_Rigs[i].PreviousStateIsValid = false;
+ m_Rigs[i].transform.position = transform.position;
+ m_Rigs[i].transform.rotation = transform.rotation;
+ }
+ // Hide the rigs from prying eyes
+ CinemachineVirtualCamera.SetFlagsForHiddenChild(m_Rigs[i].gameObject);
+
+ mOrbitals[i].m_FollowOffset = GetLocalPositionForCameraFromInput(GetYAxisValue());
+ mOrbitals[i].m_BindingMode = m_BindingMode;
+ mOrbitals[i].m_Heading = m_Heading;
+ mOrbitals[i].m_XAxis = m_XAxis;
+ mOrbitals[i].m_RecenterToTargetHeading.m_enabled = (i == 1) ? m_RecenterToTargetHeading.m_enabled : false;
+ mOrbitals[i].m_RecenterToTargetHeading.m_WaitTime = m_RecenterToTargetHeading.m_WaitTime;
+ mOrbitals[i].m_RecenterToTargetHeading.m_RecenteringTime = m_RecenterToTargetHeading.m_RecenteringTime;
+ mOrbitals[i].m_RecenterToTargetHeading.CopyStateFrom(ref m_RecenterToTargetHeading);
+
+ // Hack to get SimpleFollow with heterogeneous dampings to work
+ if (m_BindingMode == CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp)
+ m_Rigs[i].SetStateRawPosition(State.RawPosition);
+ }
+ }
+
+ private float GetYAxisValue()
+ {
+ float range = m_YAxis.m_MaxValue - m_YAxis.m_MinValue;
+ return (range > UnityVectorExtensions.Epsilon) ? m_YAxis.Value / range : 0.5f;
+ }
+
+ private CameraState CalculateNewState(Vector3 worldUp, float deltaTime)
+ {
+ CameraState state = PullStateFromVirtualCamera(worldUp, ref m_Lens);
+
+ m_YAxisRecentering.DoRecentering(ref m_YAxis, deltaTime, 0.5f);
+
+ // Blend from the appropriate rigs
+ float t = GetYAxisValue();
+ if (t > 0.5f)
+ {
+ if (mBlendA != null)
+ {
+ mBlendA.TimeInBlend = (t - 0.5f) * 2f;
+ mBlendA.UpdateCameraState(worldUp, deltaTime);
+ state = mBlendA.State;
+ }
+ }
+ else
+ {
+ if (mBlendB != null)
+ {
+ mBlendB.TimeInBlend = t * 2f;
+ mBlendB.UpdateCameraState(worldUp, deltaTime);
+ state = mBlendB.State;
+ }
+ }
+ return state;
+ }
+
+ /// <summary>
+ /// Returns the local position of the camera along the spline used to connect the
+ /// three camera rigs. Does not take into account the current heading of the
+ /// camera (or its target)
+ /// </summary>
+ /// <param name="t">The t-value for the camera on its spline. Internally clamped to
+ /// the value [0,1]</param>
+ /// <returns>The local offset (back + up) of the camera WRT its target based on the
+ /// supplied t-value</returns>
+ public Vector3 GetLocalPositionForCameraFromInput(float t)
+ {
+ if (mOrbitals == null)
+ return Vector3.zero;
+ UpdateCachedSpline();
+ int n = 1;
+ if (t > 0.5f)
+ {
+ t -= 0.5f;
+ n = 2;
+ }
+ return SplineHelpers.Bezier3(
+ t * 2f, m_CachedKnots[n], m_CachedCtrl1[n], m_CachedCtrl2[n], m_CachedKnots[n+1]);
+ }
+
+ Orbit[] m_CachedOrbits;
+ float m_CachedTension;
+ Vector4[] m_CachedKnots;
+ Vector4[] m_CachedCtrl1;
+ Vector4[] m_CachedCtrl2;
+ void UpdateCachedSpline()
+ {
+ bool cacheIsValid = (m_CachedOrbits != null && m_CachedTension == m_SplineCurvature);
+ for (int i = 0; i < 3 && cacheIsValid; ++i)
+ cacheIsValid = (m_CachedOrbits[i].m_Height == m_Orbits[i].m_Height
+ && m_CachedOrbits[i].m_Radius == m_Orbits[i].m_Radius);
+ if (!cacheIsValid)
+ {
+ float t = m_SplineCurvature;
+ m_CachedKnots = new Vector4[5];
+ m_CachedCtrl1 = new Vector4[5];
+ m_CachedCtrl2 = new Vector4[5];
+ m_CachedKnots[1] = new Vector4(0, m_Orbits[2].m_Height, -m_Orbits[2].m_Radius, 0);
+ m_CachedKnots[2] = new Vector4(0, m_Orbits[1].m_Height, -m_Orbits[1].m_Radius, 0);
+ m_CachedKnots[3] = new Vector4(0, m_Orbits[0].m_Height, -m_Orbits[0].m_Radius, 0);
+ m_CachedKnots[0] = Vector4.Lerp(m_CachedKnots[1], Vector4.zero, t);
+ m_CachedKnots[4] = Vector4.Lerp(m_CachedKnots[3], Vector4.zero, t);
+ SplineHelpers.ComputeSmoothControlPoints(
+ ref m_CachedKnots, ref m_CachedCtrl1, ref m_CachedCtrl2);
+ m_CachedOrbits = new Orbit[3];
+ for (int i = 0; i < 3; ++i)
+ m_CachedOrbits[i] = m_Orbits[i];
+ m_CachedTension = m_SplineCurvature;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 319d2fe34a804e245819465c9505ea59
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using Cinemachine.Utility;
+using System.Collections.Generic;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// CinemachineMixingCamera is a "manager camera" that takes on the state of
+ /// the weighted average of the states of its child virtual cameras.
+ ///
+ /// A fixed number of slots are made available for cameras, rather than a dynamic array.
+ /// We do it this way in order to support weight animation from the Timeline.
+ /// Timeline cannot animate array elements.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineMixingCamera")]
+ public class CinemachineMixingCamera : CinemachineVirtualCameraBase
+ {
+ /// <summary>The maximum number of tracked cameras. If you want to add
+ /// more cameras, do it here in the source code, and be sure to add the
+ /// extra member variables and to make the appropriate changes in
+ /// GetWeight() and SetWeight().
+ /// The inspector will figure itself out based on this value.</summary>
+ public const int MaxCameras = 8;
+
+ /// <summary>Weight of the first tracked camera</summary>
+ [Tooltip("The weight of the first tracked camera")]
+ public float m_Weight0 = 0.5f;
+ /// <summary>Weight of the second tracked camera</summary>
+ [Tooltip("The weight of the second tracked camera")]
+ public float m_Weight1 = 0.5f;
+ /// <summary>Weight of the third tracked camera</summary>
+ [Tooltip("The weight of the third tracked camera")]
+ public float m_Weight2 = 0.5f;
+ /// <summary>Weight of the fourth tracked camera</summary>
+ [Tooltip("The weight of the fourth tracked camera")]
+ public float m_Weight3 = 0.5f;
+ /// <summary>Weight of the fifth tracked camera</summary>
+ [Tooltip("The weight of the fifth tracked camera")]
+ public float m_Weight4 = 0.5f;
+ /// <summary>Weight of the sixth tracked camera</summary>
+ [Tooltip("The weight of the sixth tracked camera")]
+ public float m_Weight5 = 0.5f;
+ /// <summary>Weight of the seventh tracked camera</summary>
+ [Tooltip("The weight of the seventh tracked camera")]
+ public float m_Weight6 = 0.5f;
+ /// <summary>Weight of the eighth tracked camera</summary>
+ [Tooltip("The weight of the eighth tracked camera")]
+ public float m_Weight7 = 0.5f;
+
+ /// <summary>Get the weight of the child at an index.</summary>
+ /// <param name="index">The child index. Only immediate CinemachineVirtualCameraBase
+ /// children are counted.</param>
+ /// <returns>The weight of the camera. Valid only if camera is active and enabled.</returns>
+ public float GetWeight(int index)
+ {
+ switch (index)
+ {
+ case 0: return m_Weight0;
+ case 1: return m_Weight1;
+ case 2: return m_Weight2;
+ case 3: return m_Weight3;
+ case 4: return m_Weight4;
+ case 5: return m_Weight5;
+ case 6: return m_Weight6;
+ case 7: return m_Weight7;
+ }
+ Debug.LogError("CinemachineMixingCamera: Invalid index: " + index);
+ return 0;
+ }
+
+ /// <summary>Set the weight of the child at an index.</summary>
+ /// <param name="index">The child index. Only immediate CinemachineVirtualCameraBase
+ /// children are counted.</param>
+ /// <param name="w">The weight to set. Can be any non-negative number.</param>
+ public void SetWeight(int index, float w)
+ {
+ switch (index)
+ {
+ case 0: m_Weight0 = w; return;
+ case 1: m_Weight1 = w; return;
+ case 2: m_Weight2 = w; return;
+ case 3: m_Weight3 = w; return;
+ case 4: m_Weight4 = w; return;
+ case 5: m_Weight5 = w; return;
+ case 6: m_Weight6 = w; return;
+ case 7: m_Weight7 = w; return;
+ }
+ Debug.LogError("CinemachineMixingCamera: Invalid index: " + index);
+ }
+
+ /// <summary>Get the weight of the child CinemachineVirtualCameraBase.</summary>
+ /// <param name="vcam">The child camera.</param>
+ /// <returns>The weight of the camera. Valid only if camera is active and enabled.</returns>
+ public float GetWeight(CinemachineVirtualCameraBase vcam)
+ {
+ int index;
+ if (m_indexMap.TryGetValue(vcam, out index))
+ return GetWeight(index);
+ Debug.LogError("CinemachineMixingCamera: Invalid child: "
+ + ((vcam != null) ? vcam.Name : "(null)"));
+ return 0;
+ }
+
+ /// <summary>Set the weight of the child CinemachineVirtualCameraBase.</summary>
+ /// <param name="vcam">The child camera.</param>
+ /// <param name="w">The weight to set. Can be any non-negative number.</param>
+ public void SetWeight(CinemachineVirtualCameraBase vcam, float w)
+ {
+ int index;
+ if (m_indexMap.TryGetValue(vcam, out index))
+ SetWeight(index, w);
+ else
+ Debug.LogError("CinemachineMixingCamera: Invalid child: "
+ + ((vcam != null) ? vcam.Name : "(null)"));
+ }
+
+ /// <summary>Blended camera state</summary>
+ private CameraState m_State = CameraState.Default;
+
+ /// <summary>Get the current "best" child virtual camera, which is nominally
+ /// the one with the greatest weight.</summary>
+ private ICinemachineCamera LiveChild { set; get; }
+
+ /// <summary>The blended CameraState</summary>
+ public override CameraState State { get { return m_State; } }
+
+ /// <summary>Not used</summary>
+ override public Transform LookAt { get; set; }
+
+ /// <summary>Not used</summary>
+ override public Transform Follow { get; set; }
+
+ /// <summary>This is called to notify the vcam that a target got warped,
+ /// so that the vcam can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ ValidateListOfChildren();
+ foreach (var vcam in m_ChildCameras)
+ vcam.OnTargetObjectWarped(target, positionDelta);
+ base.OnTargetObjectWarped(target, positionDelta);
+ }
+
+ /// <summary>Makes sure the internal child cache is up to date</summary>
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ InvalidateListOfChildren();
+ }
+
+ /// <summary>Makes sure the internal child cache is up to date</summary>
+ public void OnTransformChildrenChanged()
+ {
+ InvalidateListOfChildren();
+ }
+
+ /// <summary>Makes sure the weights are non-negative</summary>
+ protected override void OnValidate()
+ {
+ base.OnValidate();
+ for (int i = 0; i < MaxCameras; ++i)
+ SetWeight(i, Mathf.Max(0, GetWeight(i)));
+ }
+
+ /// <summary>Check whether the vcam a live child of this camera.</summary>
+ /// <param name="vcam">The Virtual Camera to check</param>
+ /// <param name="dominantChildOnly">If truw, will only return true if this vcam is the dominat live child</param>
+ /// <returns>True if the vcam is currently actively influencing the state of this vcam</returns>
+ public override bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false)
+ {
+ CinemachineVirtualCameraBase[] children = ChildCameras;
+ for (int i = 0; i < MaxCameras && i < children.Length; ++i)
+ if ((ICinemachineCamera)children[i] == vcam)
+ return GetWeight(i) > UnityVectorExtensions.Epsilon && children[i].isActiveAndEnabled;
+ return false;
+ }
+
+ private CinemachineVirtualCameraBase[] m_ChildCameras;
+ private Dictionary<CinemachineVirtualCameraBase, int> m_indexMap;
+
+ /// <summary>Get the cached list of child cameras.
+ /// These are just the immediate children in the hierarchy.
+ /// Note: only the first entries of this list participate in the
+ /// final blend, up to MaxCameras</summary>
+ public CinemachineVirtualCameraBase[] ChildCameras
+ {
+ get { ValidateListOfChildren(); return m_ChildCameras; }
+ }
+
+ /// <summary>Invalidate the cached list of child cameras.</summary>
+ protected void InvalidateListOfChildren()
+ {
+ m_ChildCameras = null;
+ m_indexMap = null;
+ LiveChild = null;
+ }
+
+ /// <summary>Rebuild the cached list of child cameras.</summary>
+ protected void ValidateListOfChildren()
+ {
+ if (m_ChildCameras != null)
+ return;
+
+ m_indexMap = new Dictionary<CinemachineVirtualCameraBase, int>();
+ List<CinemachineVirtualCameraBase> list = new List<CinemachineVirtualCameraBase>();
+ CinemachineVirtualCameraBase[] kids
+ = GetComponentsInChildren<CinemachineVirtualCameraBase>(true);
+ foreach (CinemachineVirtualCameraBase k in kids)
+ {
+ if (k.transform.parent == transform)
+ {
+ int index = list.Count;
+ list.Add(k);
+ if (index < MaxCameras)
+ m_indexMap.Add(k, index);
+ }
+ }
+ m_ChildCameras = list.ToArray();
+ }
+
+ /// <summary>Notification that this virtual camera is going live.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ CinemachineVirtualCameraBase[] children = ChildCameras;
+ for (int i = 0; i < MaxCameras && i < children.Length; ++i)
+ {
+ CinemachineVirtualCameraBase vcam = children[i];
+ if (vcam.isActiveAndEnabled && GetWeight(i) > UnityVectorExtensions.Epsilon)
+ vcam.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ }
+ InternalUpdateCameraState(worldUp, deltaTime);
+ }
+
+ /// <summary>Internal use only. Do not call this methid.
+ /// Called by CinemachineCore at designated update time
+ /// so the vcam can position itself and track its targets. This implementation
+ /// computes and caches the weighted blend of the tracked cameras.</summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ public override void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ CinemachineVirtualCameraBase[] children = ChildCameras;
+ LiveChild = null;
+ float highestWeight = 0;
+ float totalWeight = 0;
+ for (int i = 0; i < MaxCameras && i < children.Length; ++i)
+ {
+ CinemachineVirtualCameraBase vcam = children[i];
+ if (vcam.isActiveAndEnabled)
+ {
+ float weight = Mathf.Max(0, GetWeight(i));
+ if (weight > UnityVectorExtensions.Epsilon)
+ {
+ totalWeight += weight;
+ if (totalWeight == weight)
+ m_State = vcam.State;
+ else
+ m_State = CameraState.Lerp(m_State, vcam.State, weight / totalWeight);
+
+ if (weight > highestWeight)
+ {
+ highestWeight = weight;
+ LiveChild = vcam;
+ }
+ }
+ }
+ }
+ InvokePostPipelineStageCallback(
+ this, CinemachineCore.Stage.Finalize, ref m_State, deltaTime);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 6c26251a3e1f5ac41afa5ffb404c5f71
+timeCreated: 1502201564
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ /// <summary>Defines a world-space path, consisting of an array of waypoints,
+ /// each of which has position, tangent, and roll settings. Bezier interpolation
+ /// is performed between the waypoints, to get a smooth and continuous path.</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("Cinemachine/CinemachinePath")]
+ [SaveDuringPlay]
+ public class CinemachinePath : CinemachinePathBase
+ {
+ /// <summary>A waypoint along the path</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable] public struct Waypoint
+ {
+ /// <summary>Position in path-local space</summary>
+ [Tooltip("Position in path-local space")]
+ public Vector3 position;
+
+ /// <summary>Offset from the position, which defines the tangent of the curve at the waypoint.
+ /// The length of the tangent encodes the strength of the bezier handle.
+ /// The same handle is used symmetrically on both sides of the waypoint, to ensure smoothness.</summary>
+ [Tooltip("Offset from the position, which defines the tangent of the curve at the waypoint. The length of the tangent encodes the strength of the bezier handle. The same handle is used symmetrically on both sides of the waypoint, to ensure smoothness.")]
+ public Vector3 tangent;
+
+ /// <summary>Defines the roll of the path at this waypoint.
+ /// The other orientation axes are inferred from the tangent and world up.</summary>
+ [Tooltip("Defines the roll of the path at this waypoint. The other orientation axes are inferred from the tangent and world up.")]
+ public float roll;
+ }
+
+ /// <summary>If checked, then the path ends are joined to form a continuous loop</summary>
+ [Tooltip("If checked, then the path ends are joined to form a continuous loop.")]
+ public bool m_Looped;
+
+ /// <summary>The waypoints that define the path.
+ /// They will be interpolated using a bezier curve</summary>
+ [Tooltip("The waypoints that define the path. They will be interpolated using a bezier curve.")]
+ public Waypoint[] m_Waypoints = new Waypoint[0];
+
+ /// <summary>The minimum value for the path position</summary>
+ public override float MinPos { get { return 0; } }
+
+ /// <summary>The maximum value for the path position</summary>
+ public override float MaxPos
+ {
+ get
+ {
+ int count = m_Waypoints.Length - 1;
+ if (count < 1)
+ return 0;
+ return m_Looped ? count + 1 : count;
+ }
+ }
+ /// <summary>True if the path ends are joined to form a continuous loop</summary>
+ public override bool Looped { get { return m_Looped; } }
+
+ /// <summary>When calculating the distance cache, sample the path this many
+ /// times between points</summary>
+ public override int DistanceCacheSampleStepsPerSegment { get { return m_Resolution; } }
+
+ /// <summary>Returns normalized position</summary>
+ float GetBoundingIndices(float pos, out int indexA, out int indexB)
+ {
+ pos = StandardizePos(pos);
+ int rounded = Mathf.RoundToInt(pos);
+ if (Mathf.Abs(pos - rounded) < UnityVectorExtensions.Epsilon)
+ indexA = indexB = (rounded == m_Waypoints.Length) ? 0 : rounded;
+ else
+ {
+ indexA = Mathf.FloorToInt(pos);
+ if (indexA >= m_Waypoints.Length)
+ {
+ pos -= MaxPos;
+ indexA = 0;
+ }
+ indexB = Mathf.CeilToInt(pos);
+ if (indexB >= m_Waypoints.Length)
+ indexB = 0;
+ }
+ return pos;
+ }
+
+ /// <summary>Get a worldspace position of a point along the path</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <returns>World-space position of the point along at path at pos</returns>
+ public override Vector3 EvaluatePosition(float pos)
+ {
+ Vector3 result = new Vector3();
+ if (m_Waypoints.Length == 0)
+ result = transform.position;
+ else
+ {
+ int indexA, indexB;
+ pos = GetBoundingIndices(pos, out indexA, out indexB);
+ if (indexA == indexB)
+ result = m_Waypoints[indexA].position;
+ else
+ {
+ // interpolate
+ Waypoint wpA = m_Waypoints[indexA];
+ Waypoint wpB = m_Waypoints[indexB];
+ result = SplineHelpers.Bezier3(pos - indexA,
+ m_Waypoints[indexA].position, wpA.position + wpA.tangent,
+ wpB.position - wpB.tangent, wpB.position);
+ }
+ }
+ return transform.TransformPoint(result);
+ }
+
+ /// <summary>Get the tangent of the curve at a point along the path.</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <returns>World-space direction of the path tangent.
+ /// Length of the vector represents the tangent strength</returns>
+ public override Vector3 EvaluateTangent(float pos)
+ {
+ Vector3 result = new Vector3();
+ if (m_Waypoints.Length == 0)
+ result = transform.rotation * Vector3.forward;
+ else
+ {
+ int indexA, indexB;
+ pos = GetBoundingIndices(pos, out indexA, out indexB);
+ if (indexA == indexB)
+ result = m_Waypoints[indexA].tangent;
+ else
+ {
+ Waypoint wpA = m_Waypoints[indexA];
+ Waypoint wpB = m_Waypoints[indexB];
+ result = SplineHelpers.BezierTangent3(pos - indexA,
+ m_Waypoints[indexA].position, wpA.position + wpA.tangent,
+ wpB.position - wpB.tangent, wpB.position);
+ }
+ }
+ return transform.TransformDirection(result);
+ }
+
+ /// <summary>Get the orientation the curve at a point along the path.</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <returns>World-space orientation of the path, as defined by tangent, up, and roll.</returns>
+ public override Quaternion EvaluateOrientation(float pos)
+ {
+ Quaternion result = transform.rotation;
+ if (m_Waypoints.Length > 0)
+ {
+ float roll = 0;
+ int indexA, indexB;
+ pos = GetBoundingIndices(pos, out indexA, out indexB);
+ if (indexA == indexB)
+ roll = m_Waypoints[indexA].roll;
+ else
+ {
+ float rollA = m_Waypoints[indexA].roll;
+ float rollB = m_Waypoints[indexB].roll;
+ if (indexB == 0)
+ {
+ // Special handling at the wraparound - cancel the spins
+ rollA = rollA % 360;
+ rollB = rollB % 360;
+ }
+ roll = Mathf.Lerp(rollA, rollB, pos - indexA);
+ }
+
+ Vector3 fwd = EvaluateTangent(pos);
+ if (!fwd.AlmostZero())
+ {
+ Vector3 up = transform.rotation * Vector3.up;
+ Quaternion q = Quaternion.LookRotation(fwd, up);
+ result = q * Quaternion.AngleAxis(roll, Vector3.forward);
+ }
+ }
+ return result;
+ }
+
+ private void OnValidate() { InvalidateDistanceCache(); }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 2d37e5385efd7064cb1d54c94960acae
+timeCreated: 1496785107
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Internal container for CinemachineComponentBase. Does nothing but contain.
+ /// </summary>
+ [AddComponentMenu("")] // Don't display in add component menu
+ public sealed class CinemachinePipeline : MonoBehaviour
+ {
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: ac0b09e7857660247b1477e93731de29
+timeCreated: 1489088253
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ /// <summary>Defines a world-space path, consisting of an array of waypoints,
+ /// each of which has position and roll settings. Bezier interpolation
+ /// is performed between the waypoints, to get a smooth and continuous path.
+ /// The path will pass through all waypoints, and (unlike CinemachinePath) first
+ /// and second order continuity is guaranteed</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("Cinemachine/CinemachineSmoothPath")]
+ [SaveDuringPlay]
+ public class CinemachineSmoothPath : CinemachinePathBase
+ {
+ /// <summary>If checked, then the path ends are joined to form a continuous loop</summary>
+ [Tooltip("If checked, then the path ends are joined to form a continuous loop.")]
+ public bool m_Looped;
+
+ /// <summary>A waypoint along the path</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable] public struct Waypoint
+ {
+ /// <summary>Position in path-local space</summary>
+ [Tooltip("Position in path-local space")]
+ public Vector3 position;
+
+ /// <summary>Defines the roll of the path at this waypoint.
+ /// The other orientation axes are inferred from the tangent and world up.</summary>
+ [Tooltip("Defines the roll of the path at this waypoint. The other orientation axes are inferred from the tangent and world up.")]
+ public float roll;
+
+ /// <summary>Representation as Vector4</summary>
+ internal Vector4 AsVector4
+ {
+ get { return new Vector4(position.x, position.y, position.z, roll); }
+ }
+
+ internal static Waypoint FromVector4(Vector4 v)
+ {
+ Waypoint wp = new Waypoint();
+ wp.position = new Vector3(v[0], v[1], v[2]);
+ wp.roll = v[3];
+ return wp;
+ }
+ }
+
+ /// <summary>The waypoints that define the path.
+ /// They will be interpolated using a bezier curve</summary>
+ [Tooltip("The waypoints that define the path. They will be interpolated using a bezier curve.")]
+ public Waypoint[] m_Waypoints = new Waypoint[0];
+
+ /// <summary>The minimum value for the path position</summary>
+ public override float MinPos { get { return 0; } }
+
+ /// <summary>The maximum value for the path position</summary>
+ public override float MaxPos
+ {
+ get
+ {
+ int count = m_Waypoints.Length - 1;
+ if (count < 1)
+ return 0;
+ return m_Looped ? count + 1 : count;
+ }
+ }
+ /// <summary>True if the path ends are joined to form a continuous loop</summary>
+ public override bool Looped { get { return m_Looped; } }
+
+ /// <summary>When calculating the distance cache, sample the path this many
+ /// times between points</summary>
+ public override int DistanceCacheSampleStepsPerSegment { get { return m_Resolution; } }
+
+ private void OnValidate() { InvalidateDistanceCache(); }
+
+ /// <summary>Call this if the path changes in such a way as to affect distances
+ /// or other cached path elements</summary>
+ public override void InvalidateDistanceCache()
+ {
+ base.InvalidateDistanceCache();
+ m_ControlPoints1 = null;
+ m_ControlPoints2 = null;
+ }
+
+ Waypoint[] m_ControlPoints1;
+ Waypoint[] m_ControlPoints2;
+ bool m_IsLoopedCache;
+
+ void UpdateControlPoints()
+ {
+ int numPoints = (m_Waypoints == null) ? 0 : m_Waypoints.Length;
+ if (numPoints > 1
+ && (Looped != m_IsLoopedCache
+ || m_ControlPoints1 == null || m_ControlPoints1.Length != numPoints
+ || m_ControlPoints2 == null || m_ControlPoints2.Length != numPoints))
+ {
+ Vector4[] p1 = new Vector4[numPoints];
+ Vector4[] p2 = new Vector4[numPoints];
+ Vector4[] K = new Vector4[numPoints];
+ for (int i = 0; i < numPoints; ++i)
+ K[i] = m_Waypoints[i].AsVector4;
+ if (Looped)
+ SplineHelpers.ComputeSmoothControlPointsLooped(ref K, ref p1, ref p2);
+ else
+ SplineHelpers.ComputeSmoothControlPoints(ref K, ref p1, ref p2);
+
+ m_ControlPoints1 = new Waypoint[numPoints];
+ m_ControlPoints2 = new Waypoint[numPoints];
+ for (int i = 0; i < numPoints; ++i)
+ {
+ m_ControlPoints1[i] = Waypoint.FromVector4(p1[i]);
+ m_ControlPoints2[i] = Waypoint.FromVector4(p2[i]);
+ }
+ m_IsLoopedCache = Looped;
+ }
+ }
+
+ /// <summary>Returns standardized position</summary>
+ float GetBoundingIndices(float pos, out int indexA, out int indexB)
+ {
+ pos = StandardizePos(pos);
+ int numWaypoints = m_Waypoints.Length;
+ if (numWaypoints < 2)
+ indexA = indexB = 0;
+ else
+ {
+ indexA = Mathf.FloorToInt(pos);
+ if (indexA >= numWaypoints)
+ {
+ // Only true if looped
+ pos -= MaxPos;
+ indexA = 0;
+ }
+ indexB = indexA + 1;
+ if (indexB == numWaypoints)
+ {
+ if (Looped)
+ indexB = 0;
+ else
+ {
+ --indexB;
+ --indexA;
+ }
+ }
+ }
+ return pos;
+ }
+
+ /// <summary>Get a worldspace position of a point along the path</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <returns>World-space position of the point along at path at pos</returns>
+ public override Vector3 EvaluatePosition(float pos)
+ {
+ Vector3 result = Vector3.zero;
+ if (m_Waypoints.Length > 0)
+ {
+ UpdateControlPoints();
+ int indexA, indexB;
+ pos = GetBoundingIndices(pos, out indexA, out indexB);
+ if (indexA == indexB)
+ result = m_Waypoints[indexA].position;
+ else
+ result = SplineHelpers.Bezier3(pos - indexA,
+ m_Waypoints[indexA].position, m_ControlPoints1[indexA].position,
+ m_ControlPoints2[indexA].position, m_Waypoints[indexB].position);
+ }
+ return transform.TransformPoint(result);
+ }
+
+ /// <summary>Get the tangent of the curve at a point along the path.</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <returns>World-space direction of the path tangent.
+ /// Length of the vector represents the tangent strength</returns>
+ public override Vector3 EvaluateTangent(float pos)
+ {
+ Vector3 result = transform.rotation * Vector3.forward;
+ if (m_Waypoints.Length > 1)
+ {
+ UpdateControlPoints();
+ int indexA, indexB;
+ pos = GetBoundingIndices(pos, out indexA, out indexB);
+ if (!Looped && indexA == m_Waypoints.Length - 1)
+ --indexA;
+ result = SplineHelpers.BezierTangent3(pos - indexA,
+ m_Waypoints[indexA].position, m_ControlPoints1[indexA].position,
+ m_ControlPoints2[indexA].position, m_Waypoints[indexB].position);
+ }
+ return transform.TransformDirection(result);
+ }
+
+ /// <summary>Get the orientation the curve at a point along the path.</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <returns>World-space orientation of the path, as defined by tangent, up, and roll.</returns>
+ public override Quaternion EvaluateOrientation(float pos)
+ {
+ Quaternion result = transform.rotation;
+ if (m_Waypoints.Length > 0)
+ {
+ float roll = 0;
+ int indexA, indexB;
+ pos = GetBoundingIndices(pos, out indexA, out indexB);
+ if (indexA == indexB)
+ roll = m_Waypoints[indexA].roll;
+ else
+ {
+ UpdateControlPoints();
+ roll = SplineHelpers.Bezier1(pos - indexA,
+ m_Waypoints[indexA].roll, m_ControlPoints1[indexA].roll,
+ m_ControlPoints2[indexA].roll, m_Waypoints[indexB].roll);
+ }
+
+ Vector3 fwd = EvaluateTangent(pos);
+ if (!fwd.AlmostZero())
+ {
+ Vector3 up = transform.rotation * Vector3.up;
+ Quaternion q = Quaternion.LookRotation(fwd, up);
+ result = q * Quaternion.AngleAxis(roll, Vector3.forward);
+ }
+ }
+ return result;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: a200b19ca1a9685429ed7e043c28e904
+timeCreated: 1505831686
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a virtual camera "manager" that owns and manages a collection
+ /// of child Virtual Cameras. These child vcams are mapped to individual states in
+ /// an animation state machine, allowing you to associate specific vcams to specific
+ /// animation states. When that state is active in the state machine, then the
+ /// associated camera will be activated.
+ ///
+ /// You can define custom blends and transitions between child cameras.
+ ///
+ /// In order to use this behaviour, you must have an animated target (i.e. an object
+ /// animated with a state machine) to drive the behaviour.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineStateDrivenCamera")]
+ public class CinemachineStateDrivenCamera : CinemachineVirtualCameraBase
+ {
+ /// <summary>Default object for the camera children to look at (the aim target), if not specified in a child rig. May be empty</summary>
+ [Tooltip("Default object for the camera children to look at (the aim target), if not specified in a child camera. May be empty if all of the children define targets of their own.")]
+ [NoSaveDuringPlay]
+ public Transform m_LookAt = null;
+
+ /// <summary>Default object for the camera children wants to move with (the body target), if not specified in a child rig. May be empty</summary>
+ [Tooltip("Default object for the camera children wants to move with (the body target), if not specified in a child camera. May be empty if all of the children define targets of their own.")]
+ [NoSaveDuringPlay]
+ public Transform m_Follow = null;
+
+ /// <summary>The state machine whose state changes will drive this camera's choice of active child</summary>
+ [Space]
+ [Tooltip("The state machine whose state changes will drive this camera's choice of active child")]
+ [NoSaveDuringPlay]
+ public Animator m_AnimatedTarget;
+
+ /// <summary>Which layer in the target FSM to observe</summary>
+ [Tooltip("Which layer in the target state machine to observe")]
+ [NoSaveDuringPlay]
+ public int m_LayerIndex;
+
+ /// <summary>When enabled, the current camera and blend will be indicated in the game window, for debugging</summary>
+ [Tooltip("When enabled, the current child camera and blend will be indicated in the game window, for debugging")]
+ public bool m_ShowDebugText = false;
+
+ /// <summary>Internal API for the editor. Do not use this field</summary>
+ [SerializeField][HideInInspector][NoSaveDuringPlay]
+ internal CinemachineVirtualCameraBase[] m_ChildCameras = null;
+
+ /// <summary>This represents a single instrunction to the StateDrivenCamera. It associates
+ /// an state from the state machine with a child Virtual Camera, and also holds
+ /// activation tuning parameters.</summary>
+ [Serializable]
+ public struct Instruction
+ {
+ /// <summary>The full hash of the animation state</summary>
+ [Tooltip("The full hash of the animation state")]
+ public int m_FullHash;
+ /// <summary>The virtual camera to activate whrn the animation state becomes active</summary>
+ [Tooltip("The virtual camera to activate whrn the animation state becomes active")]
+ public CinemachineVirtualCameraBase m_VirtualCamera;
+ /// <summary>How long to wait (in seconds) before activating the virtual camera.
+ /// This filters out very short state durations</summary>
+ [Tooltip("How long to wait (in seconds) before activating the virtual camera. This filters out very short state durations")]
+ public float m_ActivateAfter;
+ /// <summary>The minimum length of time (in seconds) to keep a virtual camera active</summary>
+ [Tooltip("The minimum length of time (in seconds) to keep a virtual camera active")]
+ public float m_MinDuration;
+ };
+
+ /// <summary>The set of instructions associating virtual cameras with states.
+ /// These instructions are used to choose the live child at any given moment</summary>
+ [Tooltip("The set of instructions associating virtual cameras with states. These instructions are used to choose the live child at any given moment")]
+ public Instruction[] m_Instructions;
+
+ /// <summary>
+ /// The blend which is used if you don't explicitly define a blend between two Virtual Camera children.
+ /// </summary>
+ [CinemachineBlendDefinitionProperty]
+ [Tooltip("The blend which is used if you don't explicitly define a blend between two Virtual Camera children")]
+ public CinemachineBlendDefinition m_DefaultBlend
+ = new CinemachineBlendDefinition(CinemachineBlendDefinition.Style.EaseInOut, 0.5f);
+
+ /// <summary>
+ /// This is the asset which contains custom settings for specific child blends.
+ /// </summary>
+ [Tooltip("This is the asset which contains custom settings for specific child blends")]
+ public CinemachineBlenderSettings m_CustomBlends = null;
+
+ /// <summary>Internal API for the Inspector editor. This implements nested states.</summary>
+ [Serializable]
+ [DocumentationSorting(DocumentationSortingAttribute.Level.Undoc)]
+ internal struct ParentHash
+ {
+ /// <summary>Internal API for the Inspector editor</summary>
+ public int m_Hash;
+ /// <summary>Internal API for the Inspector editor</summary>
+ public int m_ParentHash;
+ /// <summary>Internal API for the Inspector editor</summary>
+ public ParentHash(int h, int p) { m_Hash = h; m_ParentHash = p; }
+ }
+ /// <summary>Internal API for the Inspector editor</summary>
+ [HideInInspector][SerializeField] internal ParentHash[] m_ParentHash = null;
+
+ /// <summary>Gets a brief debug description of this virtual camera, for use when displayiong debug info</summary>
+ public override string Description
+ {
+ get
+ {
+ // Show the active camera and blend
+ if (mActiveBlend != null)
+ return mActiveBlend.Description;
+
+ ICinemachineCamera vcam = LiveChild;
+ if (vcam == null)
+ return "(none)";
+ var sb = CinemachineDebug.SBFromPool();
+ sb.Append("["); sb.Append(vcam.Name); sb.Append("]");
+ string text = sb.ToString();
+ CinemachineDebug.ReturnToPool(sb);
+ return text;
+ }
+ }
+
+ /// <summary>Get the current "best" child virtual camera, that would be chosen
+ /// if the State Driven Camera were active.</summary>
+ public ICinemachineCamera LiveChild { set; get; }
+
+ /// <summary>Check whether the vcam a live child of this camera.</summary>
+ /// <param name="vcam">The Virtual Camera to check</param>
+ /// <param name="dominantChildOnly">If truw, will only return true if this vcam is the dominat live child</param>
+ /// <returns>True if the vcam is currently actively influencing the state of this vcam</returns>
+ public override bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false)
+ {
+ return vcam == LiveChild || (mActiveBlend != null && mActiveBlend.Uses(vcam));
+ }
+
+ /// <summary>The State of the current live child</summary>
+ public override CameraState State { get { return m_State; } }
+
+ /// <summary>Get the current LookAt target. Returns parent's LookAt if parent
+ /// is non-null and no specific LookAt defined for this camera</summary>
+ override public Transform LookAt
+ {
+ get { return ResolveLookAt(m_LookAt); }
+ set { m_LookAt = value; }
+ }
+
+ /// <summary>Get the current Follow target. Returns parent's Follow if parent
+ /// is non-null and no specific Follow defined for this camera</summary>
+ override public Transform Follow
+ {
+ get { return ResolveFollow(m_Follow); }
+ set { m_Follow = value; }
+ }
+
+ /// <summary>This is called to notify the vcam that a target got warped,
+ /// so that the vcam can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ UpdateListOfChildren();
+ foreach (var vcam in m_ChildCameras)
+ vcam.OnTargetObjectWarped(target, positionDelta);
+ base.OnTargetObjectWarped(target, positionDelta);
+ }
+
+ /// <summary>Notification that this virtual camera is going live.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ TransitioningFrom = fromCam;
+ InternalUpdateCameraState(worldUp, deltaTime);
+ }
+
+ ICinemachineCamera TransitioningFrom { get; set; }
+
+ /// <summary>Internal use only. Do not call this method.
+ /// Called by CinemachineCore at designated update time
+ /// so the vcam can position itself and track its targets. This implementation
+ /// updates all the children, chooses the best one, and implements any required blending.</summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ if (!PreviousStateIsValid)
+ deltaTime = -1;
+
+ UpdateListOfChildren();
+ CinemachineVirtualCameraBase best = ChooseCurrentCamera(deltaTime);
+ if (best != null && !best.gameObject.activeInHierarchy)
+ {
+ best.gameObject.SetActive(true);
+ best.UpdateCameraState(worldUp, deltaTime);
+ }
+
+ ICinemachineCamera previousCam = LiveChild;
+ LiveChild = best;
+
+ // Are we transitioning cameras?
+ if (previousCam != LiveChild && LiveChild != null)
+ {
+ // Notify incoming camera of transition
+ LiveChild.OnTransitionFromCamera(previousCam, worldUp, deltaTime);
+
+ // Generate Camera Activation event in the brain if live
+ CinemachineCore.Instance.GenerateCameraActivationEvent(LiveChild, previousCam);
+
+ if (previousCam != null)
+ {
+ // Create a blend (will be null if a cut)
+ mActiveBlend = CreateBlend(
+ previousCam, LiveChild,
+ LookupBlend(previousCam, LiveChild), mActiveBlend);
+
+ // If cutting, generate a camera cut event if live
+ if (mActiveBlend == null || !mActiveBlend.Uses(previousCam))
+ CinemachineCore.Instance.GenerateCameraCutEvent(LiveChild);
+ }
+ }
+
+ // Advance the current blend (if any)
+ if (mActiveBlend != null)
+ {
+ mActiveBlend.TimeInBlend += (deltaTime >= 0)
+ ? deltaTime : mActiveBlend.Duration;
+ if (mActiveBlend.IsComplete)
+ mActiveBlend = null;
+ }
+
+ if (mActiveBlend != null)
+ {
+ mActiveBlend.UpdateCameraState(worldUp, deltaTime);
+ m_State = mActiveBlend.State;
+ }
+ else if (LiveChild != null)
+ {
+ if (TransitioningFrom != null)
+ LiveChild.OnTransitionFromCamera(TransitioningFrom, worldUp, deltaTime);
+ m_State = LiveChild.State;
+ }
+ TransitioningFrom = null;
+ InvokePostPipelineStageCallback(this, CinemachineCore.Stage.Finalize, ref m_State, deltaTime);
+ PreviousStateIsValid = true;
+ }
+
+ /// <summary>Makes sure the internal child cache is up to date</summary>
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ InvalidateListOfChildren();
+ mActiveBlend = null;
+ CinemachineDebug.OnGUIHandlers -= OnGuiHandler;
+ CinemachineDebug.OnGUIHandlers += OnGuiHandler;
+ }
+
+ protected override void OnDisable()
+ {
+ base.OnDisable();
+ CinemachineDebug.OnGUIHandlers -= OnGuiHandler;
+ }
+
+ /// <summary>Makes sure the internal child cache is up to date</summary>
+ public void OnTransformChildrenChanged()
+ {
+ InvalidateListOfChildren();
+ }
+
+ /// Will only be called if Unity Editor - never in build
+ private void OnGuiHandler()
+ {
+ if (!m_ShowDebugText)
+ CinemachineDebug.ReleaseScreenPos(this);
+ else
+ {
+ var sb = CinemachineDebug.SBFromPool();
+ sb.Append(Name); sb.Append(": "); sb.Append(Description);
+ string text = sb.ToString();
+ Rect r = CinemachineDebug.GetScreenPos(this, text, GUI.skin.box);
+ GUI.Label(r, text, GUI.skin.box);
+ CinemachineDebug.ReturnToPool(sb);
+ }
+ }
+
+ CameraState m_State = CameraState.Default;
+
+ /// <summary>The list of child cameras. These are just the immediate children in the hierarchy.</summary>
+ public CinemachineVirtualCameraBase[] ChildCameras { get { UpdateListOfChildren(); return m_ChildCameras; }}
+
+ /// <summary>Is there a blend in progress?</summary>
+ public bool IsBlending { get { return mActiveBlend != null; } }
+
+ /// <summary>API for the inspector editor. Animation module does not have hashes
+ /// for state parents, so we have to invent them in order to implement nested state
+ /// handling</summary>
+ public static int CreateFakeHash(int parentHash, AnimationClip clip)
+ {
+ return Animator.StringToHash(parentHash.ToString() + "_" + clip.name);
+ }
+
+ // Avoid garbage string manipulations at runtime
+ struct HashPair { public int parentHash; public int hash; }
+ Dictionary<AnimationClip, List<HashPair>> mHashCache;
+ int LookupFakeHash(int parentHash, AnimationClip clip)
+ {
+ if (mHashCache == null)
+ mHashCache = new Dictionary<AnimationClip, List<HashPair>>();
+ List<HashPair> list = null;
+ if (!mHashCache.TryGetValue(clip, out list))
+ {
+ list = new List<HashPair>();
+ mHashCache[clip] = list;
+ }
+ for (int i = 0; i < list.Count; ++i)
+ if (list[i].parentHash == parentHash)
+ return list[i].hash;
+ int newHash = CreateFakeHash(parentHash, clip);
+ list.Add(new HashPair() { parentHash = parentHash, hash = newHash });
+ return newHash;
+ }
+
+
+ float mActivationTime = 0;
+ Instruction mActiveInstruction;
+ float mPendingActivationTime = 0;
+ Instruction mPendingInstruction;
+ private CinemachineBlend mActiveBlend = null;
+
+ void InvalidateListOfChildren() { m_ChildCameras = null; LiveChild = null; }
+
+ void UpdateListOfChildren()
+ {
+ if (m_ChildCameras != null && mInstructionDictionary != null && mStateParentLookup != null)
+ return;
+ List<CinemachineVirtualCameraBase> list = new List<CinemachineVirtualCameraBase>();
+ CinemachineVirtualCameraBase[] kids = GetComponentsInChildren<CinemachineVirtualCameraBase>(true);
+ foreach (CinemachineVirtualCameraBase k in kids)
+ if (k.transform.parent == transform)
+ list.Add(k);
+ m_ChildCameras = list.ToArray();
+ ValidateInstructions();
+ }
+
+ private Dictionary<int, int> mInstructionDictionary;
+ private Dictionary<int, int> mStateParentLookup;
+ /// <summary>Internal API for the inspector editor.</summary>
+ internal void ValidateInstructions()
+ {
+ if (m_Instructions == null)
+ m_Instructions = new Instruction[0];
+ mInstructionDictionary = new Dictionary<int, int>();
+ for (int i = 0; i < m_Instructions.Length; ++i)
+ {
+ if (m_Instructions[i].m_VirtualCamera != null
+ && m_Instructions[i].m_VirtualCamera.transform.parent != transform)
+ {
+ m_Instructions[i].m_VirtualCamera = null;
+ }
+ mInstructionDictionary[m_Instructions[i].m_FullHash] = i;
+ }
+
+ // Create the parent lookup
+ mStateParentLookup = new Dictionary<int, int>();
+ if (m_ParentHash != null)
+ foreach (var i in m_ParentHash)
+ mStateParentLookup[i.m_Hash] = i.m_ParentHash;
+
+ // Zap the cached current instructions
+ mActivationTime = mPendingActivationTime = 0;
+ mActiveBlend = null;
+ }
+
+ List<AnimatorClipInfo> m_clipInfoList = new List<AnimatorClipInfo>();
+ private CinemachineVirtualCameraBase ChooseCurrentCamera(float deltaTime)
+ {
+ if (m_ChildCameras == null || m_ChildCameras.Length == 0)
+ {
+ mActivationTime = 0;
+ return null;
+ }
+ CinemachineVirtualCameraBase defaultCam = m_ChildCameras[0];
+ if (m_AnimatedTarget == null || !m_AnimatedTarget.gameObject.activeSelf
+ || m_AnimatedTarget.runtimeAnimatorController == null
+ || m_LayerIndex < 0 || !m_AnimatedTarget.hasBoundPlayables
+ || m_LayerIndex >= m_AnimatedTarget.layerCount)
+ {
+ mActivationTime = 0;
+ return defaultCam;
+ }
+
+ // Get the current state
+ int hash;
+ if (m_AnimatedTarget.IsInTransition(m_LayerIndex))
+ {
+ // Force "current" state to be the state we're transitionaing to
+ AnimatorStateInfo info = m_AnimatedTarget.GetNextAnimatorStateInfo(m_LayerIndex);
+ hash = info.fullPathHash;
+ if (m_AnimatedTarget.GetNextAnimatorClipInfoCount(m_LayerIndex) > 1)
+ {
+ m_AnimatedTarget.GetNextAnimatorClipInfo(m_LayerIndex, m_clipInfoList);
+ hash = GetClipHash(info.fullPathHash, m_clipInfoList);
+ }
+ }
+ else
+ {
+ AnimatorStateInfo info = m_AnimatedTarget.GetCurrentAnimatorStateInfo(m_LayerIndex);
+ hash = info.fullPathHash;
+ if (m_AnimatedTarget.GetCurrentAnimatorClipInfoCount(m_LayerIndex) > 1)
+ {
+ m_AnimatedTarget.GetCurrentAnimatorClipInfo(m_LayerIndex, m_clipInfoList);
+ hash = GetClipHash(info.fullPathHash, m_clipInfoList);
+ }
+ }
+
+ // If we don't have an instruction for this state, find a suitable default
+ while (hash != 0 && !mInstructionDictionary.ContainsKey(hash))
+ hash = mStateParentLookup.ContainsKey(hash) ? mStateParentLookup[hash] : 0;
+
+ float now = Time.time;
+ if (mActivationTime != 0)
+ {
+ // Is it active now?
+ if (mActiveInstruction.m_FullHash == hash)
+ {
+ // Yes, cancel any pending
+ mPendingActivationTime = 0;
+ return mActiveInstruction.m_VirtualCamera;
+ }
+
+ // Is it pending?
+ if (deltaTime >= 0)
+ {
+ if (mPendingActivationTime != 0 && mPendingInstruction.m_FullHash == hash)
+ {
+ // Has it been pending long enough, and are we allowed to switch away
+ // from the active action?
+ if ((now - mPendingActivationTime) > mPendingInstruction.m_ActivateAfter
+ && ((now - mActivationTime) > mActiveInstruction.m_MinDuration
+ || mPendingInstruction.m_VirtualCamera.Priority
+ > mActiveInstruction.m_VirtualCamera.Priority))
+ {
+ // Yes, activate it now
+ mActiveInstruction = mPendingInstruction;
+ mActivationTime = now;
+ mPendingActivationTime = 0;
+ }
+ return mActiveInstruction.m_VirtualCamera;
+ }
+ }
+ }
+ // Neither active nor pending.
+ mPendingActivationTime = 0; // cancel the pending, if any
+
+ if (!mInstructionDictionary.ContainsKey(hash))
+ {
+ // No defaults set, we just ignore this state
+ if (mActivationTime != 0)
+ return mActiveInstruction.m_VirtualCamera;
+ return defaultCam;
+ }
+
+ // Can we activate it now?
+ Instruction newInstr = m_Instructions[mInstructionDictionary[hash]];
+ if (newInstr.m_VirtualCamera == null)
+ newInstr.m_VirtualCamera = defaultCam;
+ if (deltaTime >= 0 && mActivationTime > 0)
+ {
+ if (newInstr.m_ActivateAfter > 0
+ || ((now - mActivationTime) < mActiveInstruction.m_MinDuration
+ && newInstr.m_VirtualCamera.Priority
+ <= mActiveInstruction.m_VirtualCamera.Priority))
+ {
+ // Too early - make it pending
+ mPendingInstruction = newInstr;
+ mPendingActivationTime = now;
+ if (mActivationTime != 0)
+ return mActiveInstruction.m_VirtualCamera;
+ return defaultCam;
+ }
+ }
+ // Activate now
+ mActiveInstruction = newInstr;
+ mActivationTime = now;
+ return mActiveInstruction.m_VirtualCamera;
+ }
+
+ int GetClipHash(int hash, List<AnimatorClipInfo> clips)
+ {
+ // Is there an animation clip substate?
+ if (clips.Count > 1)
+ {
+ // Find the strongest-weighted one
+ int bestClip = -1;
+ for (int i = 0; i < clips.Count; ++i)
+ if (bestClip < 0 || clips[i].weight > clips[bestClip].weight)
+ bestClip = i;
+
+ // Use its hash
+ if (bestClip >= 0 && clips[bestClip].weight > 0)
+ hash = LookupFakeHash(hash, clips[bestClip].clip);
+ }
+ return hash;
+ }
+
+ private CinemachineBlendDefinition LookupBlend(
+ ICinemachineCamera fromKey, ICinemachineCamera toKey)
+ {
+ // Get the blend curve that's most appropriate for these cameras
+ CinemachineBlendDefinition blend = m_DefaultBlend;
+ if (m_CustomBlends != null)
+ {
+ string fromCameraName = (fromKey != null) ? fromKey.Name : string.Empty;
+ string toCameraName = (toKey != null) ? toKey.Name : string.Empty;
+ blend = m_CustomBlends.GetBlendForVirtualCameras(
+ fromCameraName, toCameraName, blend);
+ }
+ if (CinemachineCore.GetBlendOverride != null)
+ blend = CinemachineCore.GetBlendOverride(fromKey, toKey, blend, this);
+ return blend;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 325a6a3050a061e4b8aa51386c30e8e1
+timeCreated: 1489088095
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_UGUI
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// An add-on module for Cinemachine Virtual Camera that places an image in screen space
+ /// over the camera's output.
+ /// </summary>
+ [SaveDuringPlay]
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Hide in menu
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ public class CinemachineStoryboard : CinemachineExtension
+ {
+ [Tooltip("If checked, the specified image will be displayed as an overlay over the virtual camera's output")]
+ public bool m_ShowImage = true;
+
+ [Tooltip("The image to display")]
+ public Texture m_Image;
+
+ /// <summary>How to fit the image in the frame, in the event that the aspect ratios don't match</summary>
+ public enum FillStrategy
+ {
+ /// <summary>Image will be as large as possible on the screen, without being cropped</summary>
+ BestFit,
+ /// <summary>Image will be cropped if necessary so that the screen is entirely filled</summary>
+ CropImageToFit,
+ /// <summary>Image will be stretched to cover any aspect mismatch with the screen</summary>
+ StretchToFit
+ };
+ [Tooltip("How to handle differences between image aspect and screen aspect")]
+ public FillStrategy m_Aspect = FillStrategy.BestFit;
+
+ [Tooltip("The opacity of the image. 0 is transparent, 1 is opaque")]
+ [Range(0, 1)]
+ public float m_Alpha = 1;
+
+ [Tooltip("The screen-space position at which to display the image. Zero is center")]
+ public Vector2 m_Center = Vector2.zero;
+
+ [Tooltip("The screen-space rotation to apply to the image")]
+ public Vector3 m_Rotation = Vector3.zero;
+
+ [Tooltip("The screen-space scaling to apply to the image")]
+ public Vector2 m_Scale = Vector3.one;
+
+ [Tooltip("If checked, X and Y scale are synchronized")]
+ public bool m_SyncScale = true;
+
+ [Tooltip("If checked, Camera transform will not be controlled by this virtual camera")]
+ public bool m_MuteCamera;
+
+ [Range(-1, 1)]
+ [Tooltip("Wipe the image on and off horizontally")]
+ public float m_SplitView = 0f;
+
+ class CanvasInfo
+ {
+ public GameObject mCanvas;
+ public CinemachineBrain mCanvasParent;
+ public RectTransform mViewport; // for mViewport clipping
+ public UnityEngine.UI.RawImage mRawImage;
+ }
+ List<CanvasInfo> mCanvasInfo = new List<CanvasInfo>();
+
+ /// <summary>Standard CinemachineExtension callback</summary>
+ protected override void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float wipeAmountTime)
+ {
+ // Apply to this vcam only, not the children
+ if (vcam != VirtualCamera || stage != CinemachineCore.Stage.Finalize)
+ return;
+
+ if (m_ShowImage)
+ state.AddCustomBlendable(new CameraState.CustomBlendable(this, 1));
+ if (m_MuteCamera)
+ state.BlendHint |= CameraState.BlendHintValue.NoTransform | CameraState.BlendHintValue.NoLens;
+ }
+
+ protected override void ConnectToVcam(bool connect)
+ {
+ base.ConnectToVcam(connect);
+ CinemachineCore.CameraUpdatedEvent.RemoveListener(CameraUpdatedCallback);
+ if (connect)
+ CinemachineCore.CameraUpdatedEvent.AddListener(CameraUpdatedCallback);
+ else
+ DestroyCanvas();
+ }
+
+ string CanvasName { get { return "_CM_canvas" + gameObject.GetInstanceID().ToString(); } }
+
+ void CameraUpdatedCallback(CinemachineBrain brain)
+ {
+ bool showIt = enabled && m_ShowImage && CinemachineCore.Instance.IsLive(VirtualCamera);
+ int layer = 1 << gameObject.layer;
+ if (brain.OutputCamera == null || (brain.OutputCamera.cullingMask & layer) == 0)
+ showIt = false;
+ CanvasInfo ci = LocateMyCanvas(brain, showIt);
+ if (ci != null && ci.mCanvas != null)
+ ci.mCanvas.SetActive(showIt);
+ }
+
+ CanvasInfo LocateMyCanvas(CinemachineBrain parent, bool createIfNotFound)
+ {
+ CanvasInfo ci = null;
+ for (int i = 0; ci == null && i < mCanvasInfo.Count; ++i)
+ if (mCanvasInfo[i].mCanvasParent == parent)
+ ci = mCanvasInfo[i];
+ if (createIfNotFound)
+ {
+ if (ci == null)
+ {
+ ci = new CanvasInfo() { mCanvasParent = parent };
+ int numChildren = parent.transform.childCount;
+ for (int i = 0; ci.mCanvas == null && i < numChildren; ++i)
+ {
+ RectTransform child = parent.transform.GetChild(i) as RectTransform;
+ if (child != null && child.name == CanvasName)
+ {
+ ci.mCanvas = child.gameObject;
+ ci.mViewport = ci.mCanvas.GetComponentInChildren<RectTransform>();
+ ci.mRawImage = ci.mCanvas.GetComponentInChildren<UnityEngine.UI.RawImage>();
+ }
+ }
+ mCanvasInfo.Add(ci);
+ }
+ if (ci.mCanvas == null || ci.mViewport == null || ci.mRawImage == null)
+ CreateCanvas(ci);
+ }
+ return ci;
+ }
+
+ void CreateCanvas(CanvasInfo ci)
+ {
+ ci.mCanvas = new GameObject(CanvasName, typeof(RectTransform));
+ ci.mCanvas.layer = gameObject.layer;
+ ci.mCanvas.hideFlags = HideFlags.HideAndDontSave;
+ ci.mCanvas.transform.SetParent(ci.mCanvasParent.transform);
+#if UNITY_EDITOR
+ // Workaround for Unity bug case Case 1004117
+ CanvasesAndTheirOwners.AddCanvas(ci.mCanvas, this);
+#endif
+
+ var c = ci.mCanvas.AddComponent<Canvas>();
+ c.renderMode = RenderMode.ScreenSpaceOverlay;
+
+ var go = new GameObject("Viewport", typeof(RectTransform));
+ go.transform.SetParent(ci.mCanvas.transform);
+ ci.mViewport = (RectTransform)go.transform;
+ go.AddComponent<UnityEngine.UI.RectMask2D>();
+
+ go = new GameObject("RawImage", typeof(RectTransform));
+ go.transform.SetParent(ci.mViewport.transform);
+ ci.mRawImage = go.AddComponent<UnityEngine.UI.RawImage>();
+ }
+
+ void DestroyCanvas()
+ {
+ int numBrains = CinemachineCore.Instance.BrainCount;
+ for (int i = 0; i < numBrains; ++i)
+ {
+ var parent = CinemachineCore.Instance.GetActiveBrain(i);
+ int numChildren = parent.transform.childCount;
+ for (int j = 0; j < numChildren; ++j)
+ {
+ RectTransform child = parent.transform.GetChild(j) as RectTransform;
+ if (child != null && child.name == CanvasName)
+ {
+ var canvas = child.gameObject;
+ RuntimeUtility.DestroyObject(canvas);
+#if UNITY_EDITOR
+ // Workaround for Unity bug case Case 1004117
+ CanvasesAndTheirOwners.RemoveCanvas(canvas);
+#endif
+ }
+ }
+ }
+ mCanvasInfo.Clear();
+ }
+
+ void PlaceImage(CanvasInfo ci, float alpha)
+ {
+ if (ci.mRawImage != null && ci.mViewport != null)
+ {
+ Rect screen = new Rect(0, 0, Screen.width, Screen.height);
+ if (ci.mCanvasParent.OutputCamera != null)
+ screen = ci.mCanvasParent.OutputCamera.pixelRect;
+ screen.x -= (float)Screen.width/2;
+ screen.y -= (float)Screen.height/2;
+
+ // Apply Split View
+ float wipeAmount = -Mathf.Clamp(m_SplitView, -1, 1) * screen.width;
+
+ Vector3 pos = screen.center;
+ pos.x -= wipeAmount/2;
+ ci.mViewport.localPosition = pos;
+ ci.mViewport.localRotation = Quaternion.identity;
+ ci.mViewport.localScale = Vector3.one;
+ ci.mViewport.ForceUpdateRectTransforms();
+ ci.mViewport.sizeDelta = new Vector2(screen.width - Mathf.Abs(wipeAmount), screen.height);
+
+ Vector2 scale = Vector2.one;
+ if (m_Image != null
+ && m_Image.width > 0 && m_Image.width > 0
+ && screen.width > 0 && screen.height > 0)
+ {
+ float f = (screen.height * m_Image.width) / (screen.width * m_Image.height);
+ switch (m_Aspect)
+ {
+ case FillStrategy.BestFit:
+ if (f >= 1)
+ scale.y /= f;
+ else
+ scale.x *= f;
+ break;
+ case FillStrategy.CropImageToFit:
+ if (f >= 1)
+ scale.x *= f;
+ else
+ scale.y /= f;
+ break;
+ case FillStrategy.StretchToFit:
+ break;
+ }
+ }
+ scale.x *= m_Scale.x;
+ scale.y *= m_SyncScale ? m_Scale.x : m_Scale.y;
+
+ ci.mRawImage.texture = m_Image;
+ Color tintColor = Color.white;
+ tintColor.a = m_Alpha * alpha;
+ ci.mRawImage.color = tintColor;
+
+ pos = new Vector2(screen.width * m_Center.x, screen.height * m_Center.y);
+ pos.x += wipeAmount/2;
+ ci.mRawImage.rectTransform.localPosition = pos;
+ ci.mRawImage.rectTransform.localRotation = Quaternion.Euler(m_Rotation);
+ ci.mRawImage.rectTransform.localScale = scale;
+ ci.mRawImage.rectTransform.ForceUpdateRectTransforms();
+ ci.mRawImage.rectTransform.sizeDelta = screen.size;
+ }
+ }
+
+ static void StaticBlendingHandler(CinemachineBrain brain)
+ {
+ CameraState state = brain.CurrentCameraState;
+ int numBlendables = state.NumCustomBlendables;
+ for (int i = 0; i < numBlendables; ++i)
+ {
+ var b = state.GetCustomBlendable(i);
+ CinemachineStoryboard src = b.m_Custom as CinemachineStoryboard;
+ if (!(src == null)) // in case it was deleted
+ {
+ bool showIt = true;
+ int layer = 1 << src.gameObject.layer;
+ if (brain.OutputCamera == null || (brain.OutputCamera.cullingMask & layer) == 0)
+ showIt = false;
+ CanvasInfo ci = src.LocateMyCanvas(brain, showIt);
+ if (ci != null)
+ src.PlaceImage(ci, b.m_Weight);
+ }
+ }
+ }
+
+#if UNITY_EDITOR
+ [UnityEditor.InitializeOnLoad]
+ class EditorInitialize { static EditorInitialize() { InitializeModule(); } }
+#endif
+ [RuntimeInitializeOnLoadMethod]
+ static void InitializeModule()
+ {
+ CinemachineCore.CameraUpdatedEvent.RemoveListener(StaticBlendingHandler);
+ CinemachineCore.CameraUpdatedEvent.AddListener(StaticBlendingHandler);
+ }
+
+
+#if UNITY_EDITOR
+ // Workaround for the Unity bug where OnDestroy doesn't get called if Undo
+ // bug case Case 1004117
+ [UnityEditor.InitializeOnLoad]
+ class CanvasesAndTheirOwners
+ {
+ static Dictionary<UnityEngine.Object, UnityEngine.Object> sCanvasesAndTheirOwners;
+ static CanvasesAndTheirOwners()
+ {
+ UnityEditor.Undo.undoRedoPerformed -= OnUndoRedoPerformed;
+ UnityEditor.Undo.undoRedoPerformed += OnUndoRedoPerformed;
+ }
+ static void OnUndoRedoPerformed()
+ {
+ if (sCanvasesAndTheirOwners != null)
+ {
+ List<UnityEngine.Object> toDestroy = null;
+ foreach (var v in sCanvasesAndTheirOwners)
+ {
+ if (v.Value == null)
+ {
+ if (toDestroy == null)
+ toDestroy = new List<UnityEngine.Object>();
+ toDestroy.Add(v.Key);
+ }
+ }
+ if (toDestroy != null)
+ {
+ foreach (var o in toDestroy)
+ {
+ RemoveCanvas(o);
+ RuntimeUtility.DestroyObject(o);
+ }
+ }
+ }
+ }
+ public static void RemoveCanvas(UnityEngine.Object canvas)
+ {
+ if (sCanvasesAndTheirOwners != null && sCanvasesAndTheirOwners.ContainsKey(canvas))
+ sCanvasesAndTheirOwners.Remove(canvas);
+ }
+ public static void AddCanvas(UnityEngine.Object canvas, UnityEngine.Object owner)
+ {
+ if (sCanvasesAndTheirOwners == null)
+ sCanvasesAndTheirOwners = new Dictionary<UnityEngine.Object, UnityEngine.Object>();
+ sCanvasesAndTheirOwners.Add(canvas, owner);
+ }
+ }
+#endif
+ }
+}
+#endif
+
--- /dev/null
+fileFormatVersion: 2
+guid: 82e62c82b3be64042ac529dee964cc2f
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ /// <summary>Defines a group of target objects, each with a radius and a weight.
+ /// The weight is used when calculating the average position of the target group.
+ /// Higher-weighted members of the group will count more.
+ /// The bounding box is calculated by taking the member positions, weight,
+ /// and radii into account.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("Cinemachine/CinemachineTargetGroup")]
+ [SaveDuringPlay]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ public class CinemachineTargetGroup : MonoBehaviour
+ {
+ /// <summary>Holds the information that represents a member of the group</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable] public struct Target
+ {
+ /// <summary>The target objects. This object's position and orientation will contribute to the
+ /// group's average position and orientation, in accordance with its weight</summary>
+ [Tooltip("The target objects. This object's position and orientation will contribute to the group's average position and orientation, in accordance with its weight")]
+ public Transform target;
+ /// <summary>How much weight to give the target when averaging. Cannot be negative</summary>
+ [Tooltip("How much weight to give the target when averaging. Cannot be negative")]
+ public float weight;
+ /// <summary>The radius of the target, used for calculating the bounding box. Cannot be negative</summary>
+ [Tooltip("The radius of the target, used for calculating the bounding box. Cannot be negative")]
+ public float radius;
+ }
+
+ /// <summary>How the group's position is calculated</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum PositionMode
+ {
+ ///<summary>Group position will be the center of the group's axis-aligned bounding box</summary>
+ GroupCenter,
+ /// <summary>Group position will be the weighted average of the positions of the members</summary>
+ GroupAverage
+ }
+
+ /// <summary>How the group's position is calculated</summary>
+ [Tooltip("How the group's position is calculated. Select GroupCenter for the center of the bounding box, and GroupAverage for a weighted average of the positions of the members.")]
+ public PositionMode m_PositionMode = PositionMode.GroupCenter;
+
+ /// <summary>How the group's orientation is calculated</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum RotationMode
+ {
+ /// <summary>Manually set in the group's transform</summary>
+ Manual,
+ /// <summary>Weighted average of the orientation of its members.</summary>
+ GroupAverage
+ }
+
+ /// <summary>How the group's orientation is calculated</summary>
+ [Tooltip("How the group's rotation is calculated. Select Manual to use the value in the group's transform, and GroupAverage for a weighted average of the orientations of the members.")]
+ public RotationMode m_RotationMode = RotationMode.Manual;
+
+ /// <summary>This enum defines the options available for the update method.</summary>
+ public enum UpdateMethod
+ {
+ /// <summary>Updated in normal MonoBehaviour Update.</summary>
+ Update,
+ /// <summary>Updated in sync with the Physics module, in FixedUpdate</summary>
+ FixedUpdate,
+ /// <summary>Updated in MonoBehaviour LateUpdate.</summary>
+ LateUpdate
+ };
+
+ /// <summary>When to update the group's transform based on the position of the group members</summary>
+ [Tooltip("When to update the group's transform based on the position of the group members")]
+ public UpdateMethod m_UpdateMethod = UpdateMethod.LateUpdate;
+
+ /// <summary>The target objects, together with their weights and radii, that will
+ /// contribute to the group's average position, orientation, and size</summary>
+ [NoSaveDuringPlay]
+ [Tooltip("The target objects, together with their weights and radii, that will contribute to the group's average position, orientation, and size.")]
+ public Target[] m_Targets = new Target[0];
+
+ /// <summary>The axis-aligned bounding box of the group, computed using the
+ /// targets positions and radii</summary>
+ public Bounds BoundingBox { get; private set; }
+
+ /// <summary>The bounding sphere of the group, computed using the
+ /// targets positions and radii</summary>
+ public BoundingSphere Sphere
+ {
+ get
+ {
+ Bounds b = BoundingBox;
+ return new BoundingSphere(b.center, ((b.max - b.min) / 2).magnitude);
+ }
+ }
+
+ /// <summary>Return true if there are no members with weight > 0</summary>
+ public bool IsEmpty
+ {
+ get
+ {
+ for (int i = 0; i < m_Targets.Length; ++i)
+ if (m_Targets[i].target != null && m_Targets[i].weight > UnityVectorExtensions.Epsilon)
+ return false;
+ return true;
+ }
+ }
+
+ /// <summary>Add a member to the group</summary>
+ public void AddMember(Transform t, float weight, float radius)
+ {
+ int index = 0;
+ if (m_Targets == null)
+ m_Targets = new Target[1];
+ else
+ {
+ index = m_Targets.Length;
+ var oldTargets = m_Targets;
+ m_Targets = new Target[index + 1];
+ Array.Copy(oldTargets, m_Targets, index);
+ }
+ m_Targets[index].target = t;
+ m_Targets[index].weight = weight;
+ m_Targets[index].radius = radius;
+ }
+
+ /// <summary>Remove a member from the group</summary>
+ public void RemoveMember(Transform t)
+ {
+ int index = FindMember(t);
+ if (index >= 0)
+ {
+ var oldTargets = m_Targets;
+ m_Targets = new Target[m_Targets.Length - 1];
+ if (index > 0)
+ Array.Copy(oldTargets, m_Targets, index);
+ if (index < oldTargets.Length - 1)
+ Array.Copy(oldTargets, index + 1, m_Targets, index, oldTargets.Length - index - 1);
+ }
+ }
+
+ /// <summary>Locate a member's index in the group. Returns -1 if not a member</summary>
+ public int FindMember(Transform t)
+ {
+ if (m_Targets != null)
+ {
+ for (int i = m_Targets.Length-1; i >= 0; --i)
+ if (m_Targets[i].target == t)
+ return i;
+ }
+ return -1;
+ }
+
+ /// <summary>
+ /// Get the bounding sphere of a group memebr, with the weight taken into account.
+ /// As the member's weight goes to 0, the position lerps to the group average position.
+ /// </summary>
+ /// <param name="index">Member index</param>
+ /// <returns></returns>
+ public BoundingSphere GetWeightedBoundsForMember(int index)
+ {
+ if (index < 0 || index >= m_Targets.Length)
+ return Sphere;
+ return WeightedMemberBounds(m_Targets[index], mAveragePos, mMaxWeight);
+ }
+
+ /// <summary>The axis-aligned bounding box of the group, in a specific reference frame</summary>
+ /// <param name="observer">The frame of reference in which to compute the bounding box</param>
+ /// <returns>The axis-aligned bounding box of the group, in the desired frame of reference</returns>
+ public Bounds GetViewSpaceBoundingBox(Matrix4x4 observer)
+ {
+ Matrix4x4 inverseView = observer.inverse;
+ Bounds b = new Bounds(inverseView.MultiplyPoint3x4(mAveragePos), Vector3.zero);
+ for (int i = 0; i < m_Targets.Length; ++i)
+ {
+ BoundingSphere s = GetWeightedBoundsForMember(i);
+ s.position = inverseView.MultiplyPoint3x4(s.position);
+ b.Encapsulate(new Bounds(s.position, s.radius * 2 * Vector3.one));
+ }
+ return b;
+ }
+
+ private static BoundingSphere WeightedMemberBounds(Target t, Vector3 avgPos, float maxWeight)
+ {
+ float w = 0;
+ Vector3 pos = avgPos;
+ if (t.target != null)
+ {
+ pos = t.target.position;
+ w = Mathf.Max(0, t.weight);
+ if (maxWeight > UnityVectorExtensions.Epsilon && w < maxWeight)
+ w /= maxWeight;
+ else
+ w = 1;
+ }
+ return new BoundingSphere(Vector3.Lerp(avgPos, pos, w), t.radius * w);
+ }
+
+ private float mMaxWeight;
+ private Vector3 mAveragePos;
+
+ void DoUpdate()
+ {
+ if (IsEmpty)
+ return;
+
+ mAveragePos = CalculateAveragePosition(out mMaxWeight);
+ BoundingBox = CalculateBoundingBox(mAveragePos, mMaxWeight);
+
+ switch (m_PositionMode)
+ {
+ case PositionMode.GroupCenter:
+ transform.position = BoundingBox.center;
+ break;
+ case PositionMode.GroupAverage:
+ transform.position = mAveragePos;
+ break;
+ }
+
+ switch (m_RotationMode)
+ {
+ case RotationMode.Manual:
+ break;
+ case RotationMode.GroupAverage:
+ transform.rotation = CalculateAverageOrientation();
+ break;
+ }
+ }
+
+ Vector3 CalculateAveragePosition(out float maxWeight)
+ {
+ Vector3 pos = Vector3.zero;
+ float weight = 0;
+ maxWeight = 0;
+ for (int i = 0; i < m_Targets.Length; ++i)
+ {
+ if (m_Targets[i].target != null)
+ {
+ weight += m_Targets[i].weight;
+ pos += m_Targets[i].target.position * m_Targets[i].weight;
+ maxWeight = Mathf.Max(maxWeight, m_Targets[i].weight);
+ }
+ }
+ if (weight > UnityVectorExtensions.Epsilon)
+ pos /= weight;
+ else
+ pos = transform.position;
+ return pos;
+ }
+
+ Quaternion CalculateAverageOrientation()
+ {
+ Quaternion r = Quaternion.identity;
+ for (int i = 0; i < m_Targets.Length; ++i)
+ {
+ if (m_Targets[i].target != null)
+ {
+ float w = m_Targets[i].weight;
+ Quaternion q = m_Targets[i].target.rotation;
+ // This is probably bogus
+ r = new Quaternion(r.x + q.x * w, r.y + q.y * w, r.z + q.z * w, r.w + q.w * w);
+ }
+ }
+ return r.Normalized();
+ }
+
+ Bounds CalculateBoundingBox(Vector3 avgPos, float maxWeight)
+ {
+ Bounds b = new Bounds(avgPos, Vector3.zero);
+ if (maxWeight > UnityVectorExtensions.Epsilon)
+ {
+ for (int i = 0; i < m_Targets.Length; ++i)
+ {
+ if (m_Targets[i].target != null)
+ {
+ BoundingSphere s = WeightedMemberBounds(m_Targets[i], mAveragePos, maxWeight);
+ b.Encapsulate(new Bounds(s.position, s.radius * 2 * Vector3.one));
+ }
+ }
+ }
+ return b;
+ }
+
+ private void OnValidate()
+ {
+ for (int i = 0; i < m_Targets.Length; ++i)
+ {
+ m_Targets[i].weight = Mathf.Max(0, m_Targets[i].weight);
+ m_Targets[i].radius = Mathf.Max(0, m_Targets[i].radius);
+ }
+ }
+
+ void FixedUpdate()
+ {
+ if (m_UpdateMethod == UpdateMethod.FixedUpdate)
+ DoUpdate();
+ }
+
+ void Update()
+ {
+ if (!Application.isPlaying || m_UpdateMethod == UpdateMethod.Update)
+ DoUpdate();
+ }
+
+ void LateUpdate()
+ {
+ if (m_UpdateMethod == UpdateMethod.LateUpdate)
+ DoUpdate();
+ }
+
+ /// <summary>
+ /// Get the local-space angular bounds of the group, from a spoecific point of view.
+ /// Also returns the z depth range of the members.
+ /// </summary>
+ /// <param name="observer">Point of view from which to calculate, and in whose
+ /// space the return values are</param>
+ /// <param name="minAngles">The lower bound of the screen angles of the members (degrees)</param>
+ /// <param name="maxAngles">The upper bound of the screen angles of the members (degrees)</param>
+ /// <param name="zRange">The min and max depth values of the members, relative to the observer</param>
+ public void GetViewSpaceAngularBounds(
+ Matrix4x4 observer, out Vector2 minAngles, out Vector2 maxAngles, out Vector2 zRange)
+ {
+ Matrix4x4 inverseView = observer.inverse;
+ minAngles = Vector2.zero;
+ maxAngles = Vector2.zero;
+ zRange = Vector3.zero;
+ for (int i = 0; i < m_Targets.Length; ++i)
+ {
+ BoundingSphere s = GetWeightedBoundsForMember(i);
+ Vector3 p = inverseView.MultiplyPoint3x4(s.position);
+
+ // Add the radius
+ float r = p.magnitude;
+ Vector2 extraA = Vector2.zero;
+ if (r > UnityVectorExtensions.Epsilon && s.radius > UnityVectorExtensions.Epsilon)
+ extraA = Mathf.Atan2(s.radius, r) * Mathf.Rad2Deg * Vector2.one;
+ Vector2 a = Quaternion.identity.GetCameraRotationToTarget(p, Vector3.up);
+ if (i == 0)
+ {
+ minAngles = a - extraA;
+ maxAngles = a + extraA;
+ zRange = new Vector2(p.z - s.radius, p.z + s.radius);
+ }
+ else
+ {
+ minAngles = Vector3.Min(minAngles, a - extraA);
+ maxAngles = Vector3.Max(maxAngles, a + extraA);
+ zRange.x = Mathf.Min(zRange.x, p.z - s.radius);
+ zRange.y = Mathf.Max(zRange.y, p.z + s.radius);
+ }
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: e5eb80d8e62d9d145bb50fb783c0f731
+timeCreated: 1496785096
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This behaviour is intended to be attached to an empty Transform GameObject,
+ /// and it represents a Virtual Camera within the Unity scene.
+ ///
+ /// The Virtual Camera will animate its Transform according to the rules contained
+ /// in its CinemachineComponent pipeline (Aim, Body, and Noise). When the virtual
+ /// camera is Live, the Unity camera will assume the position and orientation
+ /// of the virtual camera.
+ ///
+ /// A virtual camera is not a camera. Instead, it can be thought of as a camera controller,
+ /// not unlike a cameraman. It can drive the Unity Camera and control its position,
+ /// orientation, lens settings, and PostProcessing effects. Each Virtual Camera owns
+ /// its own Cinemachine Component Pipeline, through which you provide the instructions
+ /// for dynamically tracking specific game objects.
+ ///
+ /// A virtual camera is very lightweight, and does no rendering of its own. It merely
+ /// tracks interesting GameObjects, and positions itself accordingly. A typical game
+ /// can have dozens of virtual cameras, each set up to follow a particular character
+ /// or capture a particular event.
+ ///
+ /// A Virtual Camera can be in any of three states:
+ ///
+ /// * **Live**: The virtual camera is actively controlling the Unity Camera. The
+ /// virtual camera is tracking its targets and being updated every frame.
+ /// * **Standby**: The virtual camera is tracking its targets and being updated
+ /// every frame, but no Unity Camera is actively being controlled by it. This is
+ /// the state of a virtual camera that is enabled in the scene but perhaps at a
+ /// lower priority than the Live virtual camera.
+ /// * **Disabled**: The virtual camera is present but disabled in the scene. It is
+ /// not actively tracking its targets and so consumes no processing power. However,
+ /// the virtual camera can be made live from the Timeline.
+ ///
+ /// The Unity Camera can be driven by any virtual camera in the scene. The game
+ /// logic can choose the virtual camera to make live by manipulating the virtual
+ /// cameras' enabled flags and their priorities, based on game logic.
+ ///
+ /// In order to be driven by a virtual camera, the Unity Camera must have a CinemachineBrain
+ /// behaviour, which will select the most eligible virtual camera based on its priority
+ /// or on other criteria, and will manage blending.
+ /// </summary>
+ /// <seealso cref="CinemachineVirtualCameraBase"/>
+ /// <seealso cref="LensSettings"/>
+ /// <seealso cref="CinemachineComposer"/>
+ /// <seealso cref="CinemachineTransposer"/>
+ /// <seealso cref="CinemachineBasicMultiChannelPerlin"/>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineVirtualCamera")]
+ public class CinemachineVirtualCamera : CinemachineVirtualCameraBase
+ {
+ /// <summary>The object that the camera wants to look at (the Aim target).
+ /// The Aim component of the CinemachineComponent pipeline
+ /// will refer to this target and orient the vcam in accordance with rules and
+ /// settings that are provided to it.
+ /// If this is null, then the vcam's Transform orientation will be used.</summary>
+ [Tooltip("The object that the camera wants to look at (the Aim target). If this is null, then the vcam's Transform orientation will define the camera's orientation.")]
+ [NoSaveDuringPlay]
+ public Transform m_LookAt = null;
+
+ /// <summary>The object that the camera wants to move with (the Body target).
+ /// The Body component of the CinemachineComponent pipeline
+ /// will refer to this target and position the vcam in accordance with rules and
+ /// settings that are provided to it.
+ /// If this is null, then the vcam's Transform position will be used.</summary>
+ [Tooltip("The object that the camera wants to move with (the Body target). If this is null, then the vcam's Transform position will define the camera's position.")]
+ [NoSaveDuringPlay]
+ public Transform m_Follow = null;
+
+ /// <summary>Specifies the LensSettings of this Virtual Camera.
+ /// These settings will be transferred to the Unity camera when the vcam is live.</summary>
+ [FormerlySerializedAs("m_LensAttributes")]
+ [Tooltip("Specifies the lens properties of this Virtual Camera. This generally mirrors the Unity Camera's lens settings, and will be used to drive the Unity camera when the vcam is active.")]
+ [LensSettingsProperty]
+ public LensSettings m_Lens = LensSettings.Default;
+
+ /// <summary> Collection of parameters that influence how this virtual camera transitions from
+ /// other virtual cameras </summary>
+ public TransitionParams m_Transitions;
+
+ /// <summary>Legacy support</summary>
+ [SerializeField] [HideInInspector]
+ [FormerlySerializedAs("m_BlendHint")]
+ [FormerlySerializedAs("m_PositionBlending")] private BlendHint m_LegacyBlendHint;
+
+ /// <summary>This is the name of the hidden GameObject that will be created as a child object
+ /// of the virtual camera. This hidden game object acts as a container for the polymorphic
+ /// CinemachineComponent pipeline. The Inspector UI for the Virtual Camera
+ /// provides access to this pipleline, as do the CinemachineComponent-family of
+ /// public methods in this class.
+ /// The lifecycle of the pipeline GameObject is managed automatically.</summary>
+ public const string PipelineName = "cm";
+
+ /// <summary>The CameraState object holds all of the information
+ /// necessary to position the Unity camera. It is the output of this class.</summary>
+ override public CameraState State { get { return m_State; } }
+
+ /// <summary>Get the LookAt target for the Aim component in the Cinemachine pipeline.
+ /// If this vcam is a part of a meta-camera collection, then the owner's target
+ /// will be used if the local target is null.</summary>
+ override public Transform LookAt
+ {
+ get { return ResolveLookAt(m_LookAt); }
+ set { m_LookAt = value; }
+ }
+
+ /// <summary>Get the Follow target for the Body component in the Cinemachine pipeline.
+ /// If this vcam is a part of a meta-camera collection, then the owner's target
+ /// will be used if the local target is null.</summary>
+ override public Transform Follow
+ {
+ get { return ResolveFollow(m_Follow); }
+ set { m_Follow = value; }
+ }
+
+ /// <summary>Internal use only. Do not call this method.
+ /// Called by CinemachineCore at the appropriate Update time
+ /// so the vcam can position itself and track its targets. This class will
+ /// invoke its pipeline and generate a CameraState for this frame.</summary>
+ override public void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ if (!PreviousStateIsValid)
+ deltaTime = -1;
+
+ // Update the state by invoking the component pipeline
+ m_State = CalculateNewState(worldUp, deltaTime);
+ ApplyPositionBlendMethod(ref m_State, m_Transitions.m_BlendHint);
+
+ // Push the raw position back to the game object's transform, so it
+ // moves along with the camera.
+ if (!UserIsDragging)
+ {
+ if (Follow != null)
+ transform.position = State.RawPosition;
+ if (LookAt != null)
+ transform.rotation = State.RawOrientation;
+ }
+ PreviousStateIsValid = true;
+ }
+
+ /// <summary>Make sure that the pipeline cache is up-to-date.</summary>
+ override protected void OnEnable()
+ {
+ base.OnEnable();
+ m_State = PullStateFromVirtualCamera(Vector3.up, ref m_Lens);
+ InvalidateComponentPipeline();
+
+ // Can't add components during OnValidate
+ if (ValidatingStreamVersion < 20170927)
+ {
+ if (Follow != null && GetCinemachineComponent(CinemachineCore.Stage.Body) == null)
+ AddCinemachineComponent<CinemachineHardLockToTarget>();
+ if (LookAt != null && GetCinemachineComponent(CinemachineCore.Stage.Aim) == null)
+ AddCinemachineComponent<CinemachineHardLookAt>();
+ }
+ }
+
+ /// <summary>Calls the DestroyPipelineDelegate for destroying the hidden
+ /// child object, to support undo.</summary>
+ protected override void OnDestroy()
+ {
+ // Make the pipeline visible instead of destroying - this is to keep Undo happy
+ foreach (Transform child in transform)
+ if (child.GetComponent<CinemachinePipeline>() != null)
+ child.gameObject.hideFlags
+ &= ~(HideFlags.HideInHierarchy | HideFlags.HideInInspector);
+
+ base.OnDestroy();
+ }
+
+ /// <summary>Enforce bounds for fields, when changed in inspector.</summary>
+ protected override void OnValidate()
+ {
+ base.OnValidate();
+ m_Lens.Validate();
+ if (m_LegacyBlendHint != BlendHint.None)
+ {
+ m_Transitions.m_BlendHint = m_LegacyBlendHint;
+ m_LegacyBlendHint = BlendHint.None;
+ }
+ }
+
+ void OnTransformChildrenChanged()
+ {
+ InvalidateComponentPipeline();
+ }
+
+ void Reset()
+ {
+ DestroyPipeline();
+ }
+
+ /// <summary>
+ /// Override component pipeline creation.
+ /// This needs to be done by the editor to support Undo.
+ /// The override must do exactly the same thing as the CreatePipeline method in this class.
+ /// </summary>
+ public static CreatePipelineDelegate CreatePipelineOverride;
+
+ /// <summary>
+ /// Override component pipeline creation.
+ /// This needs to be done by the editor to support Undo.
+ /// The override must do exactly the same thing as the CreatePipeline method in
+ /// the CinemachineVirtualCamera class.
+ /// </summary>
+ public delegate Transform CreatePipelineDelegate(
+ CinemachineVirtualCamera vcam, string name, CinemachineComponentBase[] copyFrom);
+
+ /// <summary>
+ /// Override component pipeline destruction.
+ /// This needs to be done by the editor to support Undo.
+ /// </summary>
+ public static DestroyPipelineDelegate DestroyPipelineOverride;
+
+ /// <summary>
+ /// Override component pipeline destruction.
+ /// This needs to be done by the editor to support Undo.
+ /// </summary>
+ public delegate void DestroyPipelineDelegate(GameObject pipeline);
+
+ /// <summary>Destroy any existing pipeline container.</summary>
+ private void DestroyPipeline()
+ {
+ List<Transform> oldPipeline = new List<Transform>();
+ foreach (Transform child in transform)
+ if (child.GetComponent<CinemachinePipeline>() != null)
+ oldPipeline.Add(child);
+
+ foreach (Transform child in oldPipeline)
+ {
+ if (DestroyPipelineOverride != null)
+ DestroyPipelineOverride(child.gameObject);
+ else
+ Destroy(child.gameObject);
+ }
+ m_ComponentOwner = null;
+ PreviousStateIsValid = false;
+ }
+
+ /// <summary>Create a default pipeline container.
+ /// Note: copyFrom only supported in Editor, not build</summary>
+ private Transform CreatePipeline(CinemachineVirtualCamera copyFrom)
+ {
+ CinemachineComponentBase[] components = null;
+ if (copyFrom != null)
+ {
+ copyFrom.InvalidateComponentPipeline(); // make sure it's up to date
+ components = copyFrom.GetComponentPipeline();
+ }
+
+ Transform newPipeline = null;
+ if (CreatePipelineOverride != null)
+ newPipeline = CreatePipelineOverride(this, PipelineName, components);
+ else
+ {
+ GameObject go = new GameObject(PipelineName);
+ go.transform.parent = transform;
+ go.AddComponent<CinemachinePipeline>();
+ newPipeline = go.transform;
+ }
+ PreviousStateIsValid = false;
+ return newPipeline;
+ }
+
+ /// <summary>
+ /// Editor API: Call this when changing the pipeline from the editor.
+ /// Will force a rebuild of the pipeline cache.
+ /// </summary>
+ public void InvalidateComponentPipeline() { m_ComponentPipeline = null; }
+
+ /// <summary>Get the hidden CinemachinePipeline child object.</summary>
+ public Transform GetComponentOwner() { UpdateComponentPipeline(); return m_ComponentOwner; }
+
+ /// <summary>Get the component pipeline owned by the hidden child pipline container.
+ /// For most purposes, it is preferable to use the GetCinemachineComponent method.</summary>
+ public CinemachineComponentBase[] GetComponentPipeline() { UpdateComponentPipeline(); return m_ComponentPipeline; }
+
+ /// <summary>Get the component set for a specific stage.</summary>
+ /// <param name="stage">The stage for which we want the component</param>
+ /// <returns>The Cinemachine component for that stage, or null if not defined</returns>
+ public CinemachineComponentBase GetCinemachineComponent(CinemachineCore.Stage stage)
+ {
+ CinemachineComponentBase[] components = GetComponentPipeline();
+ if (components != null)
+ foreach (var c in components)
+ if (c.Stage == stage)
+ return c;
+ return null;
+ }
+
+ /// <summary>Get an existing component of a specific type from the cinemachine pipeline.</summary>
+ public T GetCinemachineComponent<T>() where T : CinemachineComponentBase
+ {
+ CinemachineComponentBase[] components = GetComponentPipeline();
+ if (components != null)
+ foreach (var c in components)
+ if (c is T)
+ return c as T;
+ return null;
+ }
+
+ /// <summary>Add a component to the cinemachine pipeline.</summary>
+ public T AddCinemachineComponent<T>() where T : CinemachineComponentBase
+ {
+ // Get the existing components
+ Transform owner = GetComponentOwner();
+ CinemachineComponentBase[] components = owner.GetComponents<CinemachineComponentBase>();
+
+ T component = owner.gameObject.AddComponent<T>();
+ if (component != null && components != null)
+ {
+ // Remove the existing components at that stage
+ CinemachineCore.Stage stage = component.Stage;
+ for (int i = components.Length - 1; i >= 0; --i)
+ {
+ if (components[i].Stage == stage)
+ {
+ components[i].enabled = false;
+ RuntimeUtility.DestroyObject(components[i]);
+ }
+ }
+ }
+ InvalidateComponentPipeline();
+ return component;
+ }
+
+ /// <summary>Remove a component from the cinemachine pipeline.</summary>
+ public void DestroyCinemachineComponent<T>() where T : CinemachineComponentBase
+ {
+ CinemachineComponentBase[] components = GetComponentPipeline();
+ if (components != null)
+ {
+ foreach (var c in components)
+ {
+ if (c is T)
+ {
+ c.enabled = false;
+ RuntimeUtility.DestroyObject(c);
+ InvalidateComponentPipeline();
+ }
+ }
+ }
+ }
+
+ /// <summary>API for the editor, to make the dragging of position handles behave better.</summary>
+ public bool UserIsDragging { get; set; }
+
+ CameraState m_State = CameraState.Default; // Current state this frame
+
+ CinemachineComponentBase[] m_ComponentPipeline = null;
+ [SerializeField][HideInInspector] private Transform m_ComponentOwner = null; // serialized to handle copy/paste
+ void UpdateComponentPipeline()
+ {
+ bool isPrefab = false;
+#if UNITY_EDITOR
+ // Did we just get copy/pasted?
+ if (m_ComponentOwner != null && m_ComponentOwner.parent != transform)
+ {
+ isPrefab = gameObject.scene.name == null; // causes a small GC alloc
+ if (!isPrefab) // can't paste to a prefab
+ {
+ CinemachineVirtualCamera copyFrom = (m_ComponentOwner.parent != null)
+ ? m_ComponentOwner.parent.gameObject.GetComponent<CinemachineVirtualCamera>() : null;
+ DestroyPipeline();
+ m_ComponentOwner = CreatePipeline(copyFrom);
+ }
+ }
+ if (m_ComponentOwner != null)
+ SetFlagsForHiddenChild(m_ComponentOwner.gameObject);
+#endif
+ // Early out if we're up-to-date
+ if (m_ComponentOwner != null && m_ComponentPipeline != null)
+ return;
+
+ m_ComponentOwner = null;
+ List<CinemachineComponentBase> list = new List<CinemachineComponentBase>();
+ foreach (Transform child in transform)
+ {
+ if (child.GetComponent<CinemachinePipeline>() != null)
+ {
+ m_ComponentOwner = child;
+ CinemachineComponentBase[] components = child.GetComponents<CinemachineComponentBase>();
+ foreach (CinemachineComponentBase c in components)
+ if (c.enabled)
+ list.Add(c);
+ }
+ }
+
+ // Make sure we have a pipeline owner
+ isPrefab = gameObject.scene.name == null; // causes a small GC alloc
+ if (m_ComponentOwner == null && !isPrefab)
+ m_ComponentOwner = CreatePipeline(null);
+
+ // Make sure the pipeline stays hidden, even through prefab
+ if (m_ComponentOwner != null)
+ SetFlagsForHiddenChild(m_ComponentOwner.gameObject);
+ if (m_ComponentOwner != null && m_ComponentOwner.gameObject != null)
+ {
+ // Sort the pipeline
+ list.Sort((c1, c2) => (int)c1.Stage - (int)c2.Stage);
+ m_ComponentPipeline = list.ToArray();
+ }
+ }
+
+ static internal void SetFlagsForHiddenChild(GameObject child)
+ {
+ if (child != null)
+ {
+ if (CinemachineCore.sShowHiddenObjects)
+ child.hideFlags &= ~(HideFlags.HideInHierarchy | HideFlags.HideInInspector);
+ else
+ child.hideFlags |= (HideFlags.HideInHierarchy | HideFlags.HideInInspector);
+ }
+ }
+
+ private Transform mCachedLookAtTarget;
+ private CinemachineVirtualCameraBase mCachedLookAtTargetVcam;
+ private CameraState CalculateNewState(Vector3 worldUp, float deltaTime)
+ {
+ // Initialize the camera state, in case the game object got moved in the editor
+ CameraState state = PullStateFromVirtualCamera(worldUp, ref m_Lens);
+
+ Transform lookAtTarget = LookAt;
+ if (lookAtTarget != mCachedLookAtTarget)
+ {
+ mCachedLookAtTarget = lookAtTarget;
+ mCachedLookAtTargetVcam = null;
+ if (lookAtTarget != null)
+ mCachedLookAtTargetVcam = lookAtTarget.GetComponent<CinemachineVirtualCameraBase>();
+ }
+ if (lookAtTarget != null)
+ {
+ if (mCachedLookAtTargetVcam != null)
+ state.ReferenceLookAt = mCachedLookAtTargetVcam.State.FinalPosition;
+ else
+ state.ReferenceLookAt = lookAtTarget.position;
+ }
+
+ // Update the state by invoking the component pipeline
+ CinemachineCore.Stage curStage = CinemachineCore.Stage.Body;
+ UpdateComponentPipeline(); // avoid GetComponentPipeline() here because of GC
+ bool hasAim = false;
+ if (m_ComponentPipeline != null)
+ {
+ for (int i = 0; i < m_ComponentPipeline.Length; ++i)
+ {
+ m_ComponentPipeline[i].PrePipelineMutateCameraState(ref state, deltaTime);
+ if (m_ComponentPipeline[i].Stage == CinemachineCore.Stage.Aim)
+ hasAim = true;
+ }
+ for (int i = 0; i < m_ComponentPipeline.Length; ++i)
+ {
+ curStage = AdvancePipelineStage(
+ ref state, deltaTime, curStage,
+ (int)m_ComponentPipeline[i].Stage, hasAim);
+ m_ComponentPipeline[i].MutateCameraState(ref state, deltaTime);
+ }
+ }
+ AdvancePipelineStage(
+ ref state, deltaTime, curStage,
+ (int)CinemachineCore.Stage.Finalize + 1, hasAim);
+ return state;
+ }
+
+ private CinemachineCore.Stage AdvancePipelineStage(
+ ref CameraState state, float deltaTime,
+ CinemachineCore.Stage curStage, int maxStage, bool hasAim)
+ {
+ while ((int)curStage < maxStage)
+ {
+ if (!hasAim && curStage == CinemachineCore.Stage.Aim)
+ state.BlendHint |= CameraState.BlendHintValue.IgnoreLookAtTarget;
+ InvokePostPipelineStageCallback(this, curStage, ref state, deltaTime);
+ ++curStage;
+ }
+ return curStage;
+ }
+
+ // This is a hack for FreeLook rigs - to be removed
+ internal void SetStateRawPosition(Vector3 pos) { m_State.RawPosition = pos; }
+
+ /// <summary>This is called to notify the vcam that a target got warped,
+ /// so that the vcam can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ if (target == Follow)
+ {
+ transform.position += positionDelta;
+ m_State.RawPosition += positionDelta;
+ }
+ UpdateComponentPipeline(); // avoid GetComponentPipeline() here because of GC
+ if (m_ComponentPipeline != null)
+ {
+ for (int i = 0; i < m_ComponentPipeline.Length; ++i)
+ m_ComponentPipeline[i].OnTargetObjectWarped(target, positionDelta);
+ }
+ base.OnTargetObjectWarped(target, positionDelta);
+ }
+
+ /// <summary>If we are transitioning from another vcam, grab the position from it.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ bool forceUpdate = false;
+
+ if (m_Transitions.m_InheritPosition && fromCam != null)
+ {
+ transform.position = fromCam.State.RawPosition;
+ //transform.rotation = fromCam.State.RawOrientation;
+ PreviousStateIsValid = false;
+ forceUpdate = true;
+ }
+ UpdateComponentPipeline(); // avoid GetComponentPipeline() here because of GC
+ if (m_ComponentPipeline != null)
+ {
+ for (int i = 0; i < m_ComponentPipeline.Length; ++i)
+ if (m_ComponentPipeline[i].OnTransitionFromCamera(
+ fromCam, worldUp, deltaTime, ref m_Transitions))
+ forceUpdate = true;
+ }
+ if (forceUpdate)
+ InternalUpdateCameraState(worldUp, deltaTime);
+ else
+ UpdateCameraState(worldUp, deltaTime);
+ if (m_Transitions.m_OnCameraLive != null)
+ m_Transitions.m_OnCameraLive.Invoke(this, fromCam);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 45e653bab7fb20e499bda25e1b646fea
+timeCreated: 1496775476
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 0fafdc3d4f989ff48803e7d870539b41
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// As a part of the Cinemachine Pipeline implementing the Noise stage, this
+ /// component adds Perlin Noise to the Camera state, in the Correction
+ /// channel of the CameraState.
+ ///
+ /// The noise is created by using a predefined noise profile asset. This defines the
+ /// shape of the noise over time. You can scale this in amplitude or in time, to produce
+ /// a large family of different noises using the same profile.
+ /// </summary>
+ /// <seealso cref="NoiseSettings"/>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineBasicMultiChannelPerlin : CinemachineComponentBase
+ {
+ /// <summary>
+ /// Serialized property for referencing a NoiseSettings asset
+ /// </summary>
+ [Tooltip("The asset containing the Noise Profile. Define the frequencies and amplitudes there to make a characteristic noise profile. Make your own or just use one of the many presets.")]
+ [FormerlySerializedAs("m_Definition")]
+ [NoiseSettingsProperty]
+ public NoiseSettings m_NoiseProfile;
+
+ /// <summary>
+ /// Gain to apply to the amplitudes defined in the settings asset.
+ /// </summary>
+ [Tooltip("Gain to apply to the amplitudes defined in the NoiseSettings asset. 1 is normal. Setting this to 0 completely mutes the noise.")]
+ public float m_AmplitudeGain = 1f;
+
+ /// <summary>
+ /// Scale factor to apply to the frequencies defined in the settings asset.
+ /// </summary>
+ [Tooltip("Scale factor to apply to the frequencies defined in the NoiseSettings asset. 1 is normal. Larger magnitudes will make the noise shake more rapidly.")]
+ public float m_FrequencyGain = 1f;
+
+ /// <summary>True if the component is valid, i.e. it has a noise definition and is enabled.</summary>
+ public override bool IsValid { get { return enabled && m_NoiseProfile != null; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Noise stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Noise; } }
+
+ /// <summary>Applies noise to the Correction channel of the CameraState if the
+ /// delta time is greater than 0. Otherwise, does nothing.</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">How much to advance the perlin noise generator.
+ /// Noise is only applied if this value is greater than or equal to 0</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ if (!IsValid || deltaTime < 0)
+ return;
+
+ if (!mInitialized)
+ Initialize();
+
+ mNoiseTime += deltaTime * m_FrequencyGain;
+ curState.PositionCorrection += curState.CorrectedOrientation * NoiseSettings.GetCombinedFilterResults(
+ m_NoiseProfile.PositionNoise, mNoiseTime, mNoiseOffsets) * m_AmplitudeGain;
+ Quaternion rotNoise = Quaternion.Euler(NoiseSettings.GetCombinedFilterResults(
+ m_NoiseProfile.OrientationNoise, mNoiseTime, mNoiseOffsets) * m_AmplitudeGain);
+ curState.OrientationCorrection = curState.OrientationCorrection * rotNoise;
+ }
+
+ private bool mInitialized = false;
+ private float mNoiseTime = 0;
+
+ [SerializeField][HideInInspector]
+ private Vector3 mNoiseOffsets = Vector3.zero;
+
+ /// <summary>Generate a new random seed</summary>
+ public void ReSeed()
+ {
+ mNoiseOffsets = new Vector3(
+ Random.Range(-1000f, 1000f),
+ Random.Range(-1000f, 1000f),
+ Random.Range(-1000f, 1000f));
+ }
+
+ void Initialize()
+ {
+ mInitialized = true;
+ mNoiseTime = 0;
+ if (mNoiseOffsets == Vector3.zero)
+ ReSeed();
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 68bb026fafb42b14791938953eaace77
+timeCreated: 1484001117
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using Cinemachine.Utility;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a CinemachineComponent in the Aim section of the component pipeline.
+ /// Its job is to aim the camera at the vcam's LookAt target object, with
+ /// configurable offsets, damping, and composition rules.
+ ///
+ /// The composer does not change the camera's position. It will only pan and tilt the
+ /// camera where it is, in order to get the desired framing. To move the camera, you have
+ /// to use the virtual camera's Body section.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineComposer : CinemachineComponentBase
+ {
+ /// <summary>Target offset from the object's center in LOCAL space which
+ /// the Composer tracks. Use this to fine-tune the tracking target position
+ /// when the desired area is not in the tracked object's center</summary>
+ [Tooltip("Target offset from the target object's center in target-local space. Use this to fine-tune the tracking target position when the desired area is not the tracked object's center.")]
+ public Vector3 m_TrackedObjectOffset = Vector3.zero;
+
+ /// <summary>This setting will instruct the composer to adjust its target offset based
+ /// on the motion of the target. The composer will look at a point where it estimates
+ /// the target will be this many seconds into the future. Note that this setting is sensitive
+ /// to noisy animation, and can amplify the noise, resulting in undesirable camera jitter.
+ /// If the camera jitters unacceptably when the target is in motion, turn down this setting,
+ /// or animate the target more smoothly.</summary>
+ [Space]
+ [Tooltip("This setting will instruct the composer to adjust its target offset based on the motion of the target. The composer will look at a point where it estimates the target will be this many seconds into the future. Note that this setting is sensitive to noisy animation, and can amplify the noise, resulting in undesirable camera jitter. If the camera jitters unacceptably when the target is in motion, turn down this setting, or animate the target more smoothly.")]
+ [Range(0f, 1f)]
+ public float m_LookaheadTime = 0;
+
+ /// <summary>Controls the smoothness of the lookahead algorithm. Larger values smooth out
+ /// jittery predictions and also increase prediction lag</summary>
+ [Tooltip("Controls the smoothness of the lookahead algorithm. Larger values smooth out jittery predictions and also increase prediction lag")]
+ [Range(3, 30)]
+ public float m_LookaheadSmoothing = 10;
+
+ /// <summary>If checked, movement along the Y axis will be ignored for lookahead calculations</summary>
+ [Tooltip("If checked, movement along the Y axis will be ignored for lookahead calculations")]
+ public bool m_LookaheadIgnoreY;
+
+ /// <summary>How aggressively the camera tries to follow the target in the screen-horizontal direction.
+ /// Small numbers are more responsive, rapidly orienting the camera to keep the target in
+ /// the dead zone. Larger numbers give a more heavy slowly responding camera.
+ /// Using different vertical and horizontal settings can yield a wide range of camera behaviors.</summary>
+ [Space]
+ [Range(0f, 20)]
+ [Tooltip("How aggressively the camera tries to follow the target in the screen-horizontal direction. Small numbers are more responsive, rapidly orienting the camera to keep the target in the dead zone. Larger numbers give a more heavy slowly responding camera. Using different vertical and horizontal settings can yield a wide range of camera behaviors.")]
+ public float m_HorizontalDamping = 0.5f;
+
+ /// <summary>How aggressively the camera tries to follow the target in the screen-vertical direction.
+ /// Small numbers are more responsive, rapidly orienting the camera to keep the target in
+ /// the dead zone. Larger numbers give a more heavy slowly responding camera. Using different vertical
+ /// and horizontal settings can yield a wide range of camera behaviors.</summary>
+ [Range(0f, 20)]
+ [Tooltip("How aggressively the camera tries to follow the target in the screen-vertical direction. Small numbers are more responsive, rapidly orienting the camera to keep the target in the dead zone. Larger numbers give a more heavy slowly responding camera. Using different vertical and horizontal settings can yield a wide range of camera behaviors.")]
+ public float m_VerticalDamping = 0.5f;
+
+ /// <summary>Horizontal screen position for target. The camera will rotate to the position the tracked object here</summary>
+ [Space]
+ [Range(0f, 1f)]
+ [Tooltip("Horizontal screen position for target. The camera will rotate to position the tracked object here.")]
+ public float m_ScreenX = 0.5f;
+
+ /// <summary>Vertical screen position for target, The camera will rotate to to position the tracked object here</summary>
+ [Range(0f, 1f)]
+ [Tooltip("Vertical screen position for target, The camera will rotate to position the tracked object here.")]
+ public float m_ScreenY = 0.5f;
+
+ /// <summary>Camera will not rotate horizontally if the target is within this range of the position</summary>
+ [Range(0f, 1f)]
+ [Tooltip("Camera will not rotate horizontally if the target is within this range of the position.")]
+ public float m_DeadZoneWidth = 0f;
+
+ /// <summary>Camera will not rotate vertically if the target is within this range of the position</summary>
+ [Range(0f, 1f)]
+ [Tooltip("Camera will not rotate vertically if the target is within this range of the position.")]
+ public float m_DeadZoneHeight = 0f;
+
+ /// <summary>When target is within this region, camera will gradually move to re-align
+ /// towards the desired position, depending onm the damping speed</summary>
+ [Range(0f, 2f)]
+ [Tooltip("When target is within this region, camera will gradually rotate horizontally to re-align towards the desired position, depending on the damping speed.")]
+ public float m_SoftZoneWidth = 0.8f;
+
+ /// <summary>When target is within this region, camera will gradually move to re-align
+ /// towards the desired position, depending onm the damping speed</summary>
+ [Range(0f, 2f)]
+ [Tooltip("When target is within this region, camera will gradually rotate vertically to re-align towards the desired position, depending on the damping speed.")]
+ public float m_SoftZoneHeight = 0.8f;
+
+ /// <summary>A non-zero bias will move the targt position away from the center of the soft zone</summary>
+ [Range(-0.5f, 0.5f)]
+ [Tooltip("A non-zero bias will move the target position horizontally away from the center of the soft zone.")]
+ public float m_BiasX = 0f;
+
+ /// <summary>A non-zero bias will move the targt position away from the center of the soft zone</summary>
+ [Range(-0.5f, 0.5f)]
+ [Tooltip("A non-zero bias will move the target position vertically away from the center of the soft zone.")]
+ public float m_BiasY = 0f;
+
+ /// <summary>Force target to center of screen when this camera activates. If false, will clamp target to the edges of the dead zone</summary>
+ [Tooltip("Force target to center of screen when this camera activates. If false, will clamp target to the edges of the dead zone")]
+ public bool m_CenterOnActivate = true;
+
+ /// <summary>True if component is enabled and has a LookAt defined</summary>
+ public override bool IsValid { get { return enabled && LookAtTarget != null; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Aim stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Aim; } }
+
+ /// <summary>Internal API for inspector</summary>
+ public Vector3 TrackedPoint { get; private set; }
+
+ /// <summary>Apply the target offsets to the target location.
+ /// Also set the TrackedPoint property, taking lookahead into account.</summary>
+ /// <param name="lookAt">The unoffset LookAt point</param>
+ /// <returns>The LookAt point with the offset applied</returns>
+ protected virtual Vector3 GetLookAtPointAndSetTrackedPoint(
+ Vector3 lookAt, Vector3 up, float deltaTime)
+ {
+ Vector3 pos = lookAt;
+ if (LookAtTarget != null)
+ pos += LookAtTargetRotation * m_TrackedObjectOffset;
+
+ if (m_LookaheadTime < Epsilon)
+ TrackedPoint = pos;
+ else
+ {
+ m_Predictor.Smoothing = m_LookaheadSmoothing;
+ m_Predictor.AddPosition(pos, deltaTime, m_LookaheadTime);
+ var delta = m_Predictor.PredictPositionDelta(m_LookaheadTime);
+ if (m_LookaheadIgnoreY)
+ delta = delta.ProjectOntoPlane(up);
+ TrackedPoint = pos + delta;
+ }
+ return pos;
+ }
+
+ /// <summary>State information for damping</summary>
+ Vector3 m_CameraPosPrevFrame = Vector3.zero;
+ Vector3 m_LookAtPrevFrame = Vector3.zero;
+ Vector2 m_ScreenOffsetPrevFrame = Vector2.zero;
+ Quaternion m_CameraOrientationPrevFrame = Quaternion.identity;
+ internal PositionPredictor m_Predictor = new PositionPredictor();
+
+ /// <summary>This is called to notify the us that a target got warped,
+ /// so that we can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ base.OnTargetObjectWarped(target, positionDelta);
+ if (target == LookAtTarget)
+ {
+ m_CameraPosPrevFrame += positionDelta;
+ m_LookAtPrevFrame += positionDelta;
+ m_Predictor.ApplyTransformDelta(positionDelta);
+ }
+ }
+
+ public override void PrePipelineMutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ if (IsValid && curState.HasLookAt)
+ curState.ReferenceLookAt = GetLookAtPointAndSetTrackedPoint(
+ curState.ReferenceLookAt, curState.ReferenceUp, deltaTime);
+ }
+
+ /// <summary>Applies the composer rules and orients the camera accordingly</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for calculating damping. If less than
+ /// zero, then target will snap to the center of the dead zone.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ if (!IsValid || !curState.HasLookAt)
+ return;
+
+ // Correct the tracked point in the event that it's behind the camera
+ // while the real target is in front
+ if (!(TrackedPoint - curState.ReferenceLookAt).AlmostZero())
+ {
+ Vector3 mid = Vector3.Lerp(curState.CorrectedPosition, curState.ReferenceLookAt, 0.5f);
+ Vector3 toLookAt = curState.ReferenceLookAt - mid;
+ Vector3 toTracked = TrackedPoint - mid;
+ if (Vector3.Dot(toLookAt, toTracked) < 0)
+ {
+ float t = Vector3.Distance(curState.ReferenceLookAt, mid)
+ / Vector3.Distance(curState.ReferenceLookAt, TrackedPoint);
+ TrackedPoint = Vector3.Lerp(curState.ReferenceLookAt, TrackedPoint, t);
+ }
+ }
+
+ float targetDistance = (TrackedPoint - curState.CorrectedPosition).magnitude;
+ if (targetDistance < Epsilon)
+ {
+ if (deltaTime >= 0)
+ curState.RawOrientation = m_CameraOrientationPrevFrame;
+ return; // navel-gazing, get outa here
+ }
+
+ // Expensive FOV calculations
+ mCache.UpdateCache(curState.Lens, SoftGuideRect, HardGuideRect, targetDistance);
+
+ Quaternion rigOrientation = curState.RawOrientation;
+ if (deltaTime < 0)
+ {
+ // No damping, just snap to central bounds, skipping the soft zone
+ Rect rect = mCache.mFovSoftGuideRect;
+ if (m_CenterOnActivate)
+ rect = new Rect(rect.center, Vector2.zero); // Force to center
+ RotateToScreenBounds(
+ ref curState, rect, curState.ReferenceLookAt,
+ ref rigOrientation, mCache.mFov, mCache.mFovH, -1);
+ }
+ else
+ {
+ // Start with previous frame's orientation (but with current up)
+ Vector3 dir = m_LookAtPrevFrame - (m_CameraPosPrevFrame + curState.PositionDampingBypass);
+ if (dir.AlmostZero())
+ rigOrientation = Quaternion.LookRotation(
+ m_CameraOrientationPrevFrame * Vector3.forward, curState.ReferenceUp);
+ else
+ {
+ rigOrientation = Quaternion.LookRotation(dir, curState.ReferenceUp);
+ rigOrientation = rigOrientation.ApplyCameraRotation(
+ -m_ScreenOffsetPrevFrame, curState.ReferenceUp);
+ }
+
+ // First force the previous rotation into the hard bounds, no damping,
+ // then Now move it through the soft zone, with damping
+ RotateToScreenBounds(
+ ref curState, mCache.mFovHardGuideRect, TrackedPoint,
+ ref rigOrientation, mCache.mFov, mCache.mFovH, -1);
+ RotateToScreenBounds(
+ ref curState, mCache.mFovSoftGuideRect, TrackedPoint,
+ ref rigOrientation, mCache.mFov, mCache.mFovH, deltaTime);
+ }
+
+ // If we have lookahead, make sure the real target is still in the frame
+ if (!(TrackedPoint - curState.ReferenceLookAt).AlmostZero())
+ {
+ RotateToScreenBounds(
+ ref curState, mCache.mFovHardGuideRect, curState.ReferenceLookAt,
+ ref rigOrientation, mCache.mFov, mCache.mFovH, -1);
+ }
+
+ m_CameraPosPrevFrame = curState.CorrectedPosition;
+ m_LookAtPrevFrame = TrackedPoint;
+ m_CameraOrientationPrevFrame = UnityQuaternionExtensions.Normalized(rigOrientation);
+ m_ScreenOffsetPrevFrame = m_CameraOrientationPrevFrame.GetCameraRotationToTarget(
+ m_LookAtPrevFrame - curState.CorrectedPosition, curState.ReferenceUp);
+
+ curState.RawOrientation = m_CameraOrientationPrevFrame;
+ }
+
+ /// <summary>Internal API for the inspector editor</summary>
+ internal Rect SoftGuideRect
+ {
+ get
+ {
+ return new Rect(
+ m_ScreenX - m_DeadZoneWidth / 2, m_ScreenY - m_DeadZoneHeight / 2,
+ m_DeadZoneWidth, m_DeadZoneHeight);
+ }
+ set
+ {
+ m_DeadZoneWidth = Mathf.Clamp01(value.width);
+ m_DeadZoneHeight = Mathf.Clamp01(value.height);
+ m_ScreenX = Mathf.Clamp01(value.x + m_DeadZoneWidth / 2);
+ m_ScreenY = Mathf.Clamp01(value.y + m_DeadZoneHeight / 2);
+ m_SoftZoneWidth = Mathf.Max(m_SoftZoneWidth, m_DeadZoneWidth);
+ m_SoftZoneHeight = Mathf.Max(m_SoftZoneHeight, m_DeadZoneHeight);
+ }
+ }
+
+ /// <summary>Internal API for the inspector editor</summary>
+ internal Rect HardGuideRect
+ {
+ get
+ {
+ Rect r = new Rect(
+ m_ScreenX - m_SoftZoneWidth / 2, m_ScreenY - m_SoftZoneHeight / 2,
+ m_SoftZoneWidth, m_SoftZoneHeight);
+ r.position += new Vector2(
+ m_BiasX * (m_SoftZoneWidth - m_DeadZoneWidth),
+ m_BiasY * (m_SoftZoneHeight - m_DeadZoneHeight));
+ return r;
+ }
+ set
+ {
+ m_SoftZoneWidth = Mathf.Clamp(value.width, 0, 2f);
+ m_SoftZoneHeight = Mathf.Clamp(value.height, 0, 2f);
+ m_DeadZoneWidth = Mathf.Min(m_DeadZoneWidth, m_SoftZoneWidth);
+ m_DeadZoneHeight = Mathf.Min(m_DeadZoneHeight, m_SoftZoneHeight);
+
+ Vector2 center = value.center;
+ Vector2 bias = center - new Vector2(m_ScreenX, m_ScreenY);
+ float biasWidth = Mathf.Max(0, m_SoftZoneWidth - m_DeadZoneWidth);
+ float biasHeight = Mathf.Max(0, m_SoftZoneHeight - m_DeadZoneHeight);
+ m_BiasX = biasWidth < Epsilon ? 0 : Mathf.Clamp(bias.x / biasWidth, -0.5f, 0.5f);
+ m_BiasY = biasHeight < Epsilon ? 0 : Mathf.Clamp(bias.y / biasHeight, -0.5f, 0.5f);
+ }
+ }
+
+ // Cache for some expensive calculations
+ struct FovCache
+ {
+ public Rect mFovSoftGuideRect;
+ public Rect mFovHardGuideRect;
+ public float mFovH;
+ public float mFov;
+
+ float mOrthoSizeOverDistance;
+ float mAspect;
+ Rect mSoftGuideRect;
+ Rect mHardGuideRect;
+
+ public void UpdateCache(
+ LensSettings lens, Rect softGuide, Rect hardGuide, float targetDistance)
+ {
+ bool recalculate = mAspect != lens.Aspect
+ || softGuide != mSoftGuideRect || hardGuide != mHardGuideRect;
+ if (lens.Orthographic)
+ {
+ float orthoOverDistance = Mathf.Abs(lens.OrthographicSize / targetDistance);
+ if (mOrthoSizeOverDistance == 0
+ || Mathf.Abs(orthoOverDistance - mOrthoSizeOverDistance) / mOrthoSizeOverDistance
+ > mOrthoSizeOverDistance * 0.01f)
+ recalculate = true;
+ if (recalculate)
+ {
+ // Calculate effective fov - fake it for ortho based on target distance
+ mFov = Mathf.Rad2Deg * 2 * Mathf.Atan(orthoOverDistance);
+ mFovH = Mathf.Rad2Deg * 2 * Mathf.Atan(lens.Aspect * orthoOverDistance);
+ mOrthoSizeOverDistance = orthoOverDistance;
+ }
+ }
+ else
+ {
+ if (mFov != lens.FieldOfView)
+ recalculate = true;
+ if (recalculate)
+ {
+ mFov = lens.FieldOfView;
+ double radHFOV = 2 * Math.Atan(Math.Tan(mFov * Mathf.Deg2Rad / 2) * lens.Aspect);
+ mFovH = (float)(Mathf.Rad2Deg * radHFOV);
+ mOrthoSizeOverDistance = 0;
+ }
+ }
+ if (recalculate)
+ {
+ mFovSoftGuideRect = ScreenToFOV(softGuide, mFov, mFovH, lens.Aspect);
+ mSoftGuideRect = softGuide;
+ mFovHardGuideRect = ScreenToFOV(hardGuide, mFov, mFovH, lens.Aspect);
+ mHardGuideRect = hardGuide;
+ mAspect = lens.Aspect;
+ }
+ }
+
+ // Convert from screen coords to normalized FOV angular coords
+ private Rect ScreenToFOV(Rect rScreen, float fov, float fovH, float aspect)
+ {
+ Rect r = new Rect(rScreen);
+ Matrix4x4 persp = Matrix4x4.Perspective(fov, aspect, 0.0001f, 2f).inverse;
+
+ Vector3 p = persp.MultiplyPoint(new Vector3(0, (r.yMin * 2f) - 1f, 0.5f)); p.z = -p.z;
+ float angle = UnityVectorExtensions.SignedAngle(Vector3.forward, p, Vector3.left);
+ r.yMin = ((fov / 2) + angle) / fov;
+
+ p = persp.MultiplyPoint(new Vector3(0, (r.yMax * 2f) - 1f, 0.5f)); p.z = -p.z;
+ angle = UnityVectorExtensions.SignedAngle(Vector3.forward, p, Vector3.left);
+ r.yMax = ((fov / 2) + angle) / fov;
+
+ p = persp.MultiplyPoint(new Vector3((r.xMin * 2f) - 1f, 0, 0.5f)); p.z = -p.z;
+ angle = UnityVectorExtensions.SignedAngle(Vector3.forward, p, Vector3.up);
+ r.xMin = ((fovH / 2) + angle) / fovH;
+
+ p = persp.MultiplyPoint(new Vector3((r.xMax * 2f) - 1f, 0, 0.5f)); p.z = -p.z;
+ angle = UnityVectorExtensions.SignedAngle(Vector3.forward, p, Vector3.up);
+ r.xMax = ((fovH / 2) + angle) / fovH;
+ return r;
+ }
+ }
+ FovCache mCache;
+
+
+ /// <summary>
+ /// Adjust the rigOrientation to put the camera within the screen bounds.
+ /// If deltaTime >= 0 then damping will be applied.
+ /// Assumes that currentOrientation fwd is such that input rigOrientation's
+ /// local up is NEVER NEVER NEVER pointing downwards, relative to
+ /// state.ReferenceUp. If this condition is violated
+ /// then you will see crazy spinning. That's the symptom.
+ /// </summary>
+ private void RotateToScreenBounds(
+ ref CameraState state, Rect screenRect, Vector3 trackedPoint,
+ ref Quaternion rigOrientation, float fov, float fovH, float deltaTime)
+ {
+ Vector3 targetDir = trackedPoint - state.CorrectedPosition;
+ Vector2 rotToRect = rigOrientation.GetCameraRotationToTarget(targetDir, state.ReferenceUp);
+
+ // Bring it to the edge of screenRect, if outside. Leave it alone if inside.
+ ClampVerticalBounds(ref screenRect, targetDir, state.ReferenceUp, fov);
+ float min = (screenRect.yMin - 0.5f) * fov;
+ float max = (screenRect.yMax - 0.5f) * fov;
+ if (rotToRect.x < min)
+ rotToRect.x -= min;
+ else if (rotToRect.x > max)
+ rotToRect.x -= max;
+ else
+ rotToRect.x = 0;
+
+ min = (screenRect.xMin - 0.5f) * fovH;
+ max = (screenRect.xMax - 0.5f) * fovH;
+ if (rotToRect.y < min)
+ rotToRect.y -= min;
+ else if (rotToRect.y > max)
+ rotToRect.y -= max;
+ else
+ rotToRect.y = 0;
+
+ // Apply damping
+ if (deltaTime >= 0)
+ {
+ rotToRect.x = Damper.Damp(rotToRect.x, m_VerticalDamping, deltaTime);
+ rotToRect.y = Damper.Damp(rotToRect.y, m_HorizontalDamping, deltaTime);
+ }
+
+ // Rotate
+ rigOrientation = rigOrientation.ApplyCameraRotation(rotToRect, state.ReferenceUp);
+ }
+
+ /// <summary>
+ /// Prevent upside-down camera situation. This can happen if we have a high
+ /// camera pitch combined with composer settings that cause the camera to tilt
+ /// beyond the vertical in order to produce the desired framing. We prevent this by
+ /// clamping the composer's vertical settings so that this situation can't happen.
+ /// </summary>
+ private bool ClampVerticalBounds(ref Rect r, Vector3 dir, Vector3 up, float fov)
+ {
+ float angle = UnityVectorExtensions.Angle(dir, up);
+ float halfFov = (fov / 2f) + 1; // give it a little extra to accommodate precision errors
+ if (angle < halfFov)
+ {
+ // looking up
+ float maxY = 1f - (halfFov - angle) / fov;
+ if (r.yMax > maxY)
+ {
+ r.yMin = Mathf.Min(r.yMin, maxY);
+ r.yMax = Mathf.Min(r.yMax, maxY);
+ return true;
+ }
+ }
+ if (angle > (180 - halfFov))
+ {
+ // looking down
+ float minY = (angle - (180 - halfFov)) / fov;
+ if (minY > r.yMin)
+ {
+ r.yMin = Mathf.Max(r.yMin, minY);
+ r.yMax = Mathf.Max(r.yMax, minY);
+ return true;
+ }
+ }
+ return false;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: f4044717213e31446939f7bd49c896ea
+timeCreated: 1488314898
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a Cinemachine Component in the Body section of the component pipeline.
+ /// Its job is to position the camera in a fixed screen-space relationship to
+ /// the vcam's Follow target object, with offsets and damping.
+ ///
+ /// The camera will be first moved along the camera Z axis until the Follow target
+ /// is at the desired distance from the camera's X-Y plane. The camera will then
+ /// be moved in its XY plane until the Follow target is at the desired point on
+ /// the camera's screen.
+ ///
+ /// The FramingTansposer will only change the camera's position in space. It will not
+ /// re-orient or otherwise aim the camera.
+ ///
+ /// For this component to work properly, the vcam's LookAt target must be null.
+ /// The Follow target will define what the camera is looking at.
+ ///
+ /// If the Follow target is a CinemachineTargetGroup, then additional controls will
+ /// be available to dynamically adjust the camera's view in order to frame the entire group.
+ ///
+ /// Although this component was designed for orthographic cameras, it works equally
+ /// well with persective cameras and can be used in 3D environments.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineFramingTransposer : CinemachineComponentBase
+ {
+ /// <summary>This setting will instruct the composer to adjust its target offset based
+ /// on the motion of the target. The composer will look at a point where it estimates
+ /// the target will be this many seconds into the future. Note that this setting is sensitive
+ /// to noisy animation, and can amplify the noise, resulting in undesirable camera jitter.
+ /// If the camera jitters unacceptably when the target is in motion, turn down this setting,
+ /// or animate the target more smoothly.</summary>
+ [Tooltip("This setting will instruct the composer to adjust its target offset based on the motion of the target. The composer will look at a point where it estimates the target will be this many seconds into the future. Note that this setting is sensitive to noisy animation, and can amplify the noise, resulting in undesirable camera jitter. If the camera jitters unacceptably when the target is in motion, turn down this setting, or animate the target more smoothly.")]
+ [Range(0f, 1f)]
+ public float m_LookaheadTime = 0;
+
+ /// <summary>Controls the smoothness of the lookahead algorithm. Larger values smooth out
+ /// jittery predictions and also increase prediction lag</summary>
+ [Tooltip("Controls the smoothness of the lookahead algorithm. Larger values smooth out jittery predictions and also increase prediction lag")]
+ [Range(3, 30)]
+ public float m_LookaheadSmoothing = 10;
+
+ /// <summary>If checked, movement along the Y axis will be ignored for lookahead calculations</summary>
+ [Tooltip("If checked, movement along the Y axis will be ignored for lookahead calculations")]
+ public bool m_LookaheadIgnoreY;
+
+ /// <summary>How aggressively the camera tries to maintain the offset in the X-axis.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the target's
+ /// x-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Space]
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain the offset in the X-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's x-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_XDamping = 1f;
+
+ /// <summary>How aggressively the camera tries to maintain the offset in the Y-axis.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the target's
+ /// y-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain the offset in the Y-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's y-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_YDamping = 1f;
+
+ /// <summary>How aggressively the camera tries to maintain the offset in the Z-axis.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the
+ /// target's z-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain the offset in the Z-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's z-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_ZDamping = 1f;
+
+ /// <summary>Horizontal screen position for target. The camera will move to position the tracked object here</summary>
+ [Space]
+ [Range(0f, 1f)]
+ [Tooltip("Horizontal screen position for target. The camera will move to position the tracked object here.")]
+ public float m_ScreenX = 0.5f;
+
+ /// <summary>Vertical screen position for target, The camera will move to to position the tracked object here</summary>
+ [Range(0f, 1f)]
+ [Tooltip("Vertical screen position for target, The camera will move to position the tracked object here.")]
+ public float m_ScreenY = 0.5f;
+
+ /// <summary>The distance along the camera axis that will be maintained from the Follow target</summary>
+ [Tooltip("The distance along the camera axis that will be maintained from the Follow target")]
+ public float m_CameraDistance = 10f;
+
+ /// <summary>Camera will not move horizontally if the target is within this range of the position</summary>
+ [Space]
+ [Range(0f, 1f)]
+ [Tooltip("Camera will not move horizontally if the target is within this range of the position.")]
+ public float m_DeadZoneWidth = 0f;
+
+ /// <summary>Camera will not move vertically if the target is within this range of the position</summary>
+ [Range(0f, 1f)]
+ [Tooltip("Camera will not move vertically if the target is within this range of the position.")]
+ public float m_DeadZoneHeight = 0f;
+
+ /// <summary>The camera will not move along its z-axis if the Follow target is within this distance of the specified camera distance</summary>
+ [Tooltip("The camera will not move along its z-axis if the Follow target is within this distance of the specified camera distance")]
+ [FormerlySerializedAs("m_DistanceDeadZoneSize")]
+ public float m_DeadZoneDepth = 0;
+
+ /// <summary>If checked, then then soft zone will be unlimited in size</summary>
+ [Space]
+ [Tooltip("If checked, then then soft zone will be unlimited in size.")]
+ public bool m_UnlimitedSoftZone = false;
+
+ /// <summary>When target is within this region, camera will gradually move to re-align
+ /// towards the desired position, depending onm the damping speed</summary>
+ [Range(0f, 2f)]
+ [Tooltip("When target is within this region, camera will gradually move horizontally to re-align towards the desired position, depending on the damping speed.")]
+ public float m_SoftZoneWidth = 0.8f;
+
+ /// <summary>When target is within this region, camera will gradually move to re-align
+ /// towards the desired position, depending onm the damping speed</summary>
+ [Range(0f, 2f)]
+ [Tooltip("When target is within this region, camera will gradually move vertically to re-align towards the desired position, depending on the damping speed.")]
+ public float m_SoftZoneHeight = 0.8f;
+
+ /// <summary>A non-zero bias will move the targt position away from the center of the soft zone</summary>
+ [Range(-0.5f, 0.5f)]
+ [Tooltip("A non-zero bias will move the target position horizontally away from the center of the soft zone.")]
+ public float m_BiasX = 0f;
+
+ /// <summary>A non-zero bias will move the targt position away from the center of the soft zone</summary>
+ [Range(-0.5f, 0.5f)]
+ [Tooltip("A non-zero bias will move the target position vertically away from the center of the soft zone.")]
+ public float m_BiasY = 0f;
+
+ /// <summary>Force target to center of screen when this camera activates. If false, will clamp target to the edges of the dead zone</summary>
+ [Tooltip("Force target to center of screen when this camera activates. If false, will clamp target to the edges of the dead zone")]
+ public bool m_CenterOnActivate = true;
+
+ /// <summary>What screen dimensions to consider when framing</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum FramingMode
+ {
+ /// <summary>Consider only the horizontal dimension. Vertical framing is ignored.</summary>
+ Horizontal,
+ /// <summary>Consider only the vertical dimension. Horizontal framing is ignored.</summary>
+ Vertical,
+ /// <summary>The larger of the horizontal and vertical dimensions will dominate, to get the best fit.</summary>
+ HorizontalAndVertical,
+ /// <summary>Don't do any framing adjustment</summary>
+ None
+ };
+
+ /// <summary>What screen dimensions to consider when framing</summary>
+ [Space]
+ [Tooltip("What screen dimensions to consider when framing. Can be Horizontal, Vertical, or both")]
+ [FormerlySerializedAs("m_FramingMode")]
+ public FramingMode m_GroupFramingMode = FramingMode.HorizontalAndVertical;
+
+ /// <summary>How to adjust the camera to get the desired framing</summary>
+ public enum AdjustmentMode
+ {
+ /// <summary>Do not move the camera, only adjust the FOV.</summary>
+ ZoomOnly,
+ /// <summary>Just move the camera, don't change the FOV.</summary>
+ DollyOnly,
+ /// <summary>Move the camera as much as permitted by the ranges, then
+ /// adjust the FOV if necessary to make the shot.</summary>
+ DollyThenZoom
+ };
+
+ /// <summary>How to adjust the camera to get the desired framing</summary>
+ [Tooltip("How to adjust the camera to get the desired framing. You can zoom, dolly in/out, or do both.")]
+ public AdjustmentMode m_AdjustmentMode = AdjustmentMode.DollyThenZoom;
+
+ /// <summary>How much of the screen to fill with the bounding box of the targets.</summary>
+ [Tooltip("The bounding box of the targets should occupy this amount of the screen space. 1 means fill the whole screen. 0.5 means fill half the screen, etc.")]
+ public float m_GroupFramingSize = 0.8f;
+
+ /// <summary>How much closer to the target can the camera go?</summary>
+ [Tooltip("The maximum distance toward the target that this behaviour is allowed to move the camera.")]
+ public float m_MaxDollyIn = 5000f;
+
+ /// <summary>How much farther from the target can the camera go?</summary>
+ [Tooltip("The maximum distance away the target that this behaviour is allowed to move the camera.")]
+ public float m_MaxDollyOut = 5000f;
+
+ /// <summary>Set this to limit how close to the target the camera can get</summary>
+ [Tooltip("Set this to limit how close to the target the camera can get.")]
+ public float m_MinimumDistance = 1;
+
+ /// <summary>Set this to limit how far from the taregt the camera can get</summary>
+ [Tooltip("Set this to limit how far from the target the camera can get.")]
+ public float m_MaximumDistance = 5000f;
+
+ /// <summary>If adjusting FOV, will not set the FOV lower than this</summary>
+ [Range(1, 179)]
+ [Tooltip("If adjusting FOV, will not set the FOV lower than this.")]
+ public float m_MinimumFOV = 3;
+
+ /// <summary>If adjusting FOV, will not set the FOV higher than this</summary>
+ [Range(1, 179)]
+ [Tooltip("If adjusting FOV, will not set the FOV higher than this.")]
+ public float m_MaximumFOV = 60;
+
+ /// <summary>If adjusting Orthographic Size, will not set it lower than this</summary>
+ [Tooltip("If adjusting Orthographic Size, will not set it lower than this.")]
+ public float m_MinimumOrthoSize = 1;
+
+ /// <summary>If adjusting Orthographic Size, will not set it higher than this</summary>
+ [Tooltip("If adjusting Orthographic Size, will not set it higher than this.")]
+ public float m_MaximumOrthoSize = 5000;
+
+ /// <summary>Internal API for the inspector editor</summary>
+ internal Rect SoftGuideRect
+ {
+ get
+ {
+ return new Rect(
+ m_ScreenX - m_DeadZoneWidth / 2, m_ScreenY - m_DeadZoneHeight / 2,
+ m_DeadZoneWidth, m_DeadZoneHeight);
+ }
+ set
+ {
+ m_DeadZoneWidth = Mathf.Clamp01(value.width);
+ m_DeadZoneHeight = Mathf.Clamp01(value.height);
+ m_ScreenX = Mathf.Clamp01(value.x + m_DeadZoneWidth / 2);
+ m_ScreenY = Mathf.Clamp01(value.y + m_DeadZoneHeight / 2);
+ m_SoftZoneWidth = Mathf.Max(m_SoftZoneWidth, m_DeadZoneWidth);
+ m_SoftZoneHeight = Mathf.Max(m_SoftZoneHeight, m_DeadZoneHeight);
+ }
+ }
+
+ /// <summary>Internal API for the inspector editor</summary>
+ internal Rect HardGuideRect
+ {
+ get
+ {
+ Rect r = new Rect(
+ m_ScreenX - m_SoftZoneWidth / 2, m_ScreenY - m_SoftZoneHeight / 2,
+ m_SoftZoneWidth, m_SoftZoneHeight);
+ r.position += new Vector2(
+ m_BiasX * (m_SoftZoneWidth - m_DeadZoneWidth),
+ m_BiasY * (m_SoftZoneHeight - m_DeadZoneHeight));
+ return r;
+ }
+ set
+ {
+ m_SoftZoneWidth = Mathf.Clamp(value.width, 0, 2f);
+ m_SoftZoneHeight = Mathf.Clamp(value.height, 0, 2f);
+ m_DeadZoneWidth = Mathf.Min(m_DeadZoneWidth, m_SoftZoneWidth);
+ m_DeadZoneHeight = Mathf.Min(m_DeadZoneHeight, m_SoftZoneHeight);
+
+ Vector2 center = value.center;
+ Vector2 bias = center - new Vector2(m_ScreenX, m_ScreenY);
+ float biasWidth = Mathf.Max(0, m_SoftZoneWidth - m_DeadZoneWidth);
+ float biasHeight = Mathf.Max(0, m_SoftZoneHeight - m_DeadZoneHeight);
+ m_BiasX = biasWidth < Epsilon ? 0 : Mathf.Clamp(bias.x / biasWidth, -0.5f, 0.5f);
+ m_BiasY = biasHeight < Epsilon ? 0 : Mathf.Clamp(bias.y / biasHeight, -0.5f, 0.5f);
+ }
+ }
+
+ private void OnValidate()
+ {
+ m_CameraDistance = Mathf.Max(m_CameraDistance, kMinimumCameraDistance);
+ m_DeadZoneDepth = Mathf.Max(m_DeadZoneDepth, 0);
+
+ m_GroupFramingSize = Mathf.Max(0.001f, m_GroupFramingSize);
+ m_MaxDollyIn = Mathf.Max(0, m_MaxDollyIn);
+ m_MaxDollyOut = Mathf.Max(0, m_MaxDollyOut);
+ m_MinimumDistance = Mathf.Max(0, m_MinimumDistance);
+ m_MaximumDistance = Mathf.Max(m_MinimumDistance, m_MaximumDistance);
+ m_MinimumFOV = Mathf.Max(1, m_MinimumFOV);
+ m_MaximumFOV = Mathf.Clamp(m_MaximumFOV, m_MinimumFOV, 179);
+ m_MinimumOrthoSize = Mathf.Max(0.01f, m_MinimumOrthoSize);
+ m_MaximumOrthoSize = Mathf.Max(m_MinimumOrthoSize, m_MaximumOrthoSize);
+ }
+
+ /// <summary>True if component is enabled and has a valid Follow target</summary>
+ public override bool IsValid { get { return enabled && FollowTarget != null; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Body stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Body; } }
+
+ const float kMinimumCameraDistance = 0.01f;
+
+ /// <summary>State information for damping</summary>
+ Vector3 m_PreviousCameraPosition = Vector3.zero;
+ PositionPredictor m_Predictor = new PositionPredictor();
+
+ /// <summary>Internal API for inspector</summary>
+ public Vector3 TrackedPoint { get; private set; }
+
+ /// <summary>This is called to notify the us that a target got warped,
+ /// so that we can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ base.OnTargetObjectWarped(target, positionDelta);
+ if (target == FollowTarget)
+ {
+ m_PreviousCameraPosition += positionDelta;
+ m_Predictor.ApplyTransformDelta(positionDelta);
+ }
+ }
+
+ // Convert from screen coords to normalized orthographic distance coords
+ private Rect ScreenToOrtho(Rect rScreen, float orthoSize, float aspect)
+ {
+ Rect r = new Rect();
+ r.yMax = 2 * orthoSize * ((1f-rScreen.yMin) - 0.5f);
+ r.yMin = 2 * orthoSize * ((1f-rScreen.yMax) - 0.5f);
+ r.xMin = 2 * orthoSize * aspect * (rScreen.xMin - 0.5f);
+ r.xMax = 2 * orthoSize * aspect * (rScreen.xMax - 0.5f);
+ return r;
+ }
+
+ private Vector3 OrthoOffsetToScreenBounds(Vector3 targetPos2D, Rect screenRect)
+ {
+ // Bring it to the edge of screenRect, if outside. Leave it alone if inside.
+ Vector3 delta = Vector3.zero;
+ if (targetPos2D.x < screenRect.xMin)
+ delta.x += targetPos2D.x - screenRect.xMin;
+ if (targetPos2D.x > screenRect.xMax)
+ delta.x += targetPos2D.x - screenRect.xMax;
+ if (targetPos2D.y < screenRect.yMin)
+ delta.y += targetPos2D.y - screenRect.yMin;
+ if (targetPos2D.y > screenRect.yMax)
+ delta.y += targetPos2D.y - screenRect.yMax;
+ return delta;
+ }
+
+ float m_prevFOV; // State for frame damping
+
+ /// <summary>For editor visulaization of the calculated bounding box of the group</summary>
+ public Bounds LastBounds { get; private set; }
+
+ /// <summary>For editor visualization of the calculated bounding box of the group</summary>
+ public Matrix4x4 LastBoundsMatrix { get; private set; }
+
+ /// <summary>Positions the virtual camera according to the transposer rules.</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ Vector3 followTargetPosition = FollowTargetPosition;
+ if (deltaTime < 0)
+ {
+ m_Predictor.Reset();
+ if (m_CenterOnActivate)
+ {
+ m_PreviousCameraPosition = FollowTargetPosition
+ + (curState.RawOrientation * Vector3.back) * m_CameraDistance;
+ m_prevFOV = 0;
+ }
+ }
+ if (!IsValid)
+ return;
+
+ // Compute group bounds and adjust follow target for group framing
+ CinemachineTargetGroup group = FollowTargetGroup;
+ bool isGroupFraming = group != null && m_GroupFramingMode != FramingMode.None;
+ if (isGroupFraming)
+ followTargetPosition = ComputeGroupBounds(group, ref curState);
+
+ TrackedPoint = followTargetPosition;
+ if (m_LookaheadTime > Epsilon)
+ {
+ m_Predictor.Smoothing = m_LookaheadSmoothing;
+ m_Predictor.AddPosition(followTargetPosition, deltaTime, m_LookaheadTime);
+ var delta = m_Predictor.PredictPositionDelta(m_LookaheadTime);
+ if (m_LookaheadIgnoreY)
+ delta = delta.ProjectOntoPlane(curState.ReferenceUp);
+ var p = followTargetPosition + delta;
+ if (isGroupFraming)
+ {
+ var b = LastBounds;
+ b.center += p - followTargetPosition;
+ LastBounds = b;
+ }
+ TrackedPoint = p;
+ }
+
+ if (!curState.HasLookAt)
+ curState.ReferenceLookAt = followTargetPosition;
+
+ // Adjust the desired depth for group framing
+ float targetDistance = m_CameraDistance;
+ bool isOrthographic = curState.Lens.Orthographic;
+ float targetHeight = isGroupFraming ? GetTargetHeight(LastBounds.size / m_GroupFramingSize) : 0;
+ if (!isOrthographic && isGroupFraming)
+ {
+ // Adjust height for perspective - we want the height at the near surface
+ float boundsDepth = LastBounds.extents.z;
+ float z = LastBounds.center.z;
+ if (z > boundsDepth)
+ targetHeight = Mathf.Lerp(0, targetHeight, (z - boundsDepth) / z);
+
+ if (m_AdjustmentMode != AdjustmentMode.ZoomOnly)
+ {
+ // What distance from near edge would be needed to get the adjusted
+ // target height, at the current FOV
+ targetDistance = targetHeight / (2f * Mathf.Tan(curState.Lens.FieldOfView * Mathf.Deg2Rad / 2f));
+
+ // Clamp to respect min/max distance settings to the near surface of the bounds
+ targetDistance = Mathf.Clamp(targetDistance, m_MinimumDistance, m_MaximumDistance);
+
+ // Clamp to respect min/max camera movement
+ float targetDelta = targetDistance - m_CameraDistance;
+ targetDelta = Mathf.Clamp(targetDelta, -m_MaxDollyIn, m_MaxDollyOut);
+ targetDistance = m_CameraDistance + targetDelta;
+ }
+ }
+
+ // Work in camera-local space
+ Vector3 camPosWorld = m_PreviousCameraPosition;
+ Quaternion localToWorld = curState.RawOrientation;
+ Quaternion worldToLocal = Quaternion.Inverse(localToWorld);
+ Vector3 cameraPos = worldToLocal * camPosWorld;
+ Vector3 targetPos = (worldToLocal * TrackedPoint) - cameraPos;
+ Vector3 lookAtPos = (worldToLocal * curState.ReferenceLookAt) - cameraPos;
+
+ // Move along camera z
+ Vector3 cameraOffset = Vector3.zero;
+ float cameraMin = Mathf.Max(kMinimumCameraDistance, targetDistance - m_DeadZoneDepth/2);
+ float cameraMax = Mathf.Max(cameraMin, targetDistance + m_DeadZoneDepth/2);
+ float targetZ = Mathf.Min(targetPos.z, lookAtPos.z);
+ if (targetZ < cameraMin)
+ cameraOffset.z = targetZ - cameraMin;
+ if (targetZ > cameraMax)
+ cameraOffset.z = targetZ - cameraMax;
+
+ // Move along the XY plane
+ float screenSize = curState.Lens.Orthographic
+ ? curState.Lens.OrthographicSize
+ : Mathf.Tan(0.5f * curState.Lens.FieldOfView * Mathf.Deg2Rad)
+ * (targetZ - cameraOffset.z);
+ Rect softGuideOrtho = ScreenToOrtho(SoftGuideRect, screenSize, curState.Lens.Aspect);
+ if (deltaTime < 0)
+ {
+ // No damping or hard bounds, just snap to central bounds, skipping the soft zone
+ Rect rect = softGuideOrtho;
+ if (m_CenterOnActivate)
+ rect = new Rect(rect.center, Vector2.zero); // Force to center
+ cameraOffset += OrthoOffsetToScreenBounds(targetPos, rect);
+ }
+ else
+ {
+ // Move it through the soft zone
+ cameraOffset += OrthoOffsetToScreenBounds(targetPos, softGuideOrtho);
+
+ // Find where it intersects the hard zone
+ Vector3 hard = Vector3.zero;
+ if (!m_UnlimitedSoftZone)
+ {
+ Rect hardGuideOrtho = ScreenToOrtho(HardGuideRect, screenSize, curState.Lens.Aspect);
+ hard = OrthoOffsetToScreenBounds(targetPos, hardGuideOrtho);
+ float t = Mathf.Max(hard.x / (cameraOffset.x + Epsilon), hard.y / (cameraOffset.y + Epsilon));
+ hard = cameraOffset * t;
+ }
+ // Apply damping, but only to the portion of the move that's inside the hard zone
+ cameraOffset = hard + Damper.Damp(
+ cameraOffset - hard, new Vector3(m_XDamping, m_YDamping, m_ZDamping), deltaTime);
+
+ // If we have lookahead, make sure the real target is still in the frame
+ if (!m_UnlimitedSoftZone && !(TrackedPoint - curState.ReferenceLookAt).AlmostZero())
+ {
+ Rect hardGuideOrtho = ScreenToOrtho(HardGuideRect, screenSize, curState.Lens.Aspect);
+ cameraOffset += OrthoOffsetToScreenBounds(lookAtPos - cameraOffset, hardGuideOrtho);
+ }
+ }
+ curState.RawPosition = m_PreviousCameraPosition = localToWorld * (cameraPos + cameraOffset);
+
+ // Adjust lens for group framing
+ if (isGroupFraming)
+ {
+ if (isOrthographic)
+ {
+ targetHeight = Mathf.Clamp(targetHeight, m_MinimumOrthoSize, m_MaximumOrthoSize);
+
+ // ApplyDamping
+ if (deltaTime >= 0)
+ targetHeight = m_prevFOV + Damper.Damp(targetHeight - m_prevFOV, m_ZDamping, deltaTime);
+ m_prevFOV = targetHeight;
+
+ LensSettings lens = curState.Lens;
+ lens.OrthographicSize = Mathf.Clamp(targetHeight / 2, m_MinimumOrthoSize, m_MaximumOrthoSize);
+ curState.Lens = lens;
+ }
+ else if (m_AdjustmentMode != AdjustmentMode.DollyOnly)
+ {
+ var localTarget = Quaternion.Inverse(curState.RawOrientation)
+ * (followTargetPosition - curState.RawPosition);
+ float nearBoundsDistance = localTarget.z;
+ float targetFOV = 179;
+ if (nearBoundsDistance > Epsilon)
+ targetFOV = 2f * Mathf.Atan(targetHeight / (2 * nearBoundsDistance)) * Mathf.Rad2Deg;
+ targetFOV = Mathf.Clamp(targetFOV, m_MinimumFOV, m_MaximumFOV);
+
+ // ApplyDamping
+ if (deltaTime >= 0 && m_prevFOV != 0)
+ targetFOV = m_prevFOV + Damper.Damp(targetFOV - m_prevFOV, m_ZDamping, deltaTime);
+ m_prevFOV = targetFOV;
+
+ LensSettings lens = curState.Lens;
+ lens.FieldOfView = targetFOV;
+ curState.Lens = lens;
+ }
+ }
+ }
+
+ float GetTargetHeight(Vector2 boundsSize)
+ {
+ switch (m_GroupFramingMode)
+ {
+ case FramingMode.Horizontal:
+ return boundsSize.x / VcamState.Lens.Aspect;
+ case FramingMode.Vertical:
+ return boundsSize.y;
+ default:
+ case FramingMode.HorizontalAndVertical:
+ return Mathf.Max(boundsSize.x / VcamState.Lens.Aspect, boundsSize.y);
+ }
+ }
+
+ Vector3 ComputeGroupBounds(CinemachineTargetGroup group, ref CameraState curState)
+ {
+ Vector3 cameraPos = curState.RawPosition;
+ Vector3 fwd = curState.RawOrientation * Vector3.forward;
+
+ // Get the bounding box from camera's direction in view space
+ LastBoundsMatrix = Matrix4x4.TRS(cameraPos, curState.RawOrientation, Vector3.one);
+ Bounds b = group.GetViewSpaceBoundingBox(LastBoundsMatrix);
+ Vector3 groupCenter = LastBoundsMatrix.MultiplyPoint3x4(b.center);
+ float boundsDepth = b.extents.z;
+ if (!curState.Lens.Orthographic)
+ {
+ // Parallax might change bounds - refine
+ float d = (Quaternion.Inverse(curState.RawOrientation) * (groupCenter - cameraPos)).z;
+ cameraPos = groupCenter - fwd * (Mathf.Max(d, boundsDepth) + boundsDepth);
+
+ // Will adjust cameraPos
+ b = GetScreenSpaceGroupBoundingBox(group, ref cameraPos, curState.RawOrientation);
+ LastBoundsMatrix = Matrix4x4.TRS(cameraPos, curState.RawOrientation, Vector3.one);
+ groupCenter = LastBoundsMatrix.MultiplyPoint3x4(b.center);
+ }
+ LastBounds = b;
+ return groupCenter - fwd * boundsDepth;
+ }
+
+ static Bounds GetScreenSpaceGroupBoundingBox(
+ CinemachineTargetGroup group, ref Vector3 pos, Quaternion orientation)
+ {
+ Matrix4x4 observer = Matrix4x4.TRS(pos, orientation, Vector3.one);
+ Vector2 minAngles, maxAngles, zRange;
+ group.GetViewSpaceAngularBounds(observer, out minAngles, out maxAngles, out zRange);
+
+ Quaternion q = Quaternion.identity.ApplyCameraRotation((minAngles + maxAngles) / 2, Vector3.up);
+ Vector3 localPosAdustment = q * new Vector3(0, 0, (zRange.y + zRange.x)/2);
+ localPosAdustment.z = 0;
+ pos = observer.MultiplyPoint3x4(localPosAdustment);
+ observer = Matrix4x4.TRS(pos, orientation, Vector3.one);
+ group.GetViewSpaceAngularBounds(observer, out minAngles, out maxAngles, out zRange);
+
+ float zSize = zRange.y - zRange.x;
+ float z = zRange.x + (zSize / 2);
+ Vector2 angles = new Vector2(89.5f, 89.5f);
+ if (zRange.x > 0)
+ {
+ angles = Vector3.Max(maxAngles, UnityVectorExtensions.Abs(minAngles)) * Mathf.Deg2Rad;
+ angles = Vector2.Min(angles, new Vector2(89.5f, 89.5f));
+ }
+ return new Bounds(new Vector3(0, 0, z),
+ new Vector3(Mathf.Tan(angles.y) * z * 2, Mathf.Tan(angles.x) * z * 2, zSize));
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 6ad980451443d70438faac0bc6c235a0
+timeCreated: 1502038595
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a CinemachineComponent in the Aim section of the component pipeline.
+ /// Its job is to aim the camera at a target object, with configurable offsets, damping,
+ /// and composition rules.
+ ///
+ /// In addition, if the target is a CinemachineTargetGroup, the behaviour
+ /// will adjust the FOV and the camera distance to ensure that the entire group of targets
+ /// is framed properly.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineGroupComposer : CinemachineComposer
+ {
+ /// <summary>How much of the screen to fill with the bounding box of the targets.</summary>
+ [Space]
+ [Tooltip("The bounding box of the targets should occupy this amount of the screen space. 1 means fill the whole screen. 0.5 means fill half the screen, etc.")]
+ public float m_GroupFramingSize = 0.8f;
+
+ /// <summary>What screen dimensions to consider when framing</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum FramingMode
+ {
+ /// <summary>Consider only the horizontal dimension. Vertical framing is ignored.</summary>
+ Horizontal,
+ /// <summary>Consider only the vertical dimension. Horizontal framing is ignored.</summary>
+ Vertical,
+ /// <summary>The larger of the horizontal and vertical dimensions will dominate, to get the best fit.</summary>
+ HorizontalAndVertical
+ };
+
+ /// <summary>What screen dimensions to consider when framing</summary>
+ [Tooltip("What screen dimensions to consider when framing. Can be Horizontal, Vertical, or both")]
+ public FramingMode m_FramingMode = FramingMode.HorizontalAndVertical;
+
+ /// <summary>How aggressively the camera tries to frame the group.
+ /// Small numbers are more responsive</summary>
+ [Range(0, 20)]
+ [Tooltip("How aggressively the camera tries to frame the group. Small numbers are more responsive, rapidly adjusting the camera to keep the group in the frame. Larger numbers give a more heavy slowly responding camera.")]
+ public float m_FrameDamping = 2f;
+
+ /// <summary>How to adjust the camera to get the desired framing</summary>
+ public enum AdjustmentMode
+ {
+ /// <summary>Do not move the camera, only adjust the FOV.</summary>
+ ZoomOnly,
+ /// <summary>Just move the camera, don't change the FOV.</summary>
+ DollyOnly,
+ /// <summary>Move the camera as much as permitted by the ranges, then
+ /// adjust the FOV if necessary to make the shot.</summary>
+ DollyThenZoom
+ };
+
+ /// <summary>How to adjust the camera to get the desired framing</summary>
+ [Tooltip("How to adjust the camera to get the desired framing. You can zoom, dolly in/out, or do both.")]
+ public AdjustmentMode m_AdjustmentMode = AdjustmentMode.DollyThenZoom;
+
+ /// <summary>How much closer to the target can the camera go?</summary>
+ [Tooltip("The maximum distance toward the target that this behaviour is allowed to move the camera.")]
+ public float m_MaxDollyIn = 5000f;
+
+ /// <summary>How much farther from the target can the camera go?</summary>
+ [Tooltip("The maximum distance away the target that this behaviour is allowed to move the camera.")]
+ public float m_MaxDollyOut = 5000f;
+
+ /// <summary>Set this to limit how close to the target the camera can get</summary>
+ [Tooltip("Set this to limit how close to the target the camera can get.")]
+ public float m_MinimumDistance = 1;
+
+ /// <summary>Set this to limit how far from the taregt the camera can get</summary>
+ [Tooltip("Set this to limit how far from the target the camera can get.")]
+ public float m_MaximumDistance = 5000f;
+
+ /// <summary>If adjusting FOV, will not set the FOV lower than this</summary>
+ [Range(1, 179)]
+ [Tooltip("If adjusting FOV, will not set the FOV lower than this.")]
+ public float m_MinimumFOV = 3;
+
+ /// <summary>If adjusting FOV, will not set the FOV higher than this</summary>
+ [Range(1, 179)]
+ [Tooltip("If adjusting FOV, will not set the FOV higher than this.")]
+ public float m_MaximumFOV = 60;
+
+ /// <summary>If adjusting Orthographic Size, will not set it lower than this</summary>
+ [Tooltip("If adjusting Orthographic Size, will not set it lower than this.")]
+ public float m_MinimumOrthoSize = 1;
+
+ /// <summary>If adjusting Orthographic Size, will not set it higher than this</summary>
+ [Tooltip("If adjusting Orthographic Size, will not set it higher than this.")]
+ public float m_MaximumOrthoSize = 5000;
+
+ private void OnValidate()
+ {
+ m_GroupFramingSize = Mathf.Max(0.001f, m_GroupFramingSize);
+ m_MaxDollyIn = Mathf.Max(0, m_MaxDollyIn);
+ m_MaxDollyOut = Mathf.Max(0, m_MaxDollyOut);
+ m_MinimumDistance = Mathf.Max(0, m_MinimumDistance);
+ m_MaximumDistance = Mathf.Max(m_MinimumDistance, m_MaximumDistance);
+ m_MinimumFOV = Mathf.Max(1, m_MinimumFOV);
+ m_MaximumFOV = Mathf.Clamp(m_MaximumFOV, m_MinimumFOV, 179);
+ m_MinimumOrthoSize = Mathf.Max(0.01f, m_MinimumOrthoSize);
+ m_MaximumOrthoSize = Mathf.Max(m_MinimumOrthoSize, m_MaximumOrthoSize);
+ }
+
+ // State for damping
+ float m_prevFramingDistance;
+ float m_prevFOV;
+
+ /// <summary>For editor visulaization of the calculated bounding box of the group</summary>
+ public Bounds LastBounds { get; private set; }
+
+ /// <summary>For editor visualization of the calculated bounding box of the group</summary>
+ public Matrix4x4 LastBoundsMatrix { get; private set; }
+
+ /// <summary>Applies the composer rules and orients the camera accordingly</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for calculating damping. If less than
+ /// zero, then target will snap to the center of the dead zone.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ // Can't do anything without a group to look at
+ CinemachineTargetGroup group = LookAtTargetGroup;
+ if (group == null)
+ {
+ base.MutateCameraState(ref curState, deltaTime);
+ return;
+ }
+
+ if (!IsValid || !curState.HasLookAt)
+ {
+ m_prevFramingDistance = 0;
+ m_prevFOV = 0;
+ return;
+ }
+
+ bool isOrthographic = curState.Lens.Orthographic;
+ bool canMoveCamera = !isOrthographic && m_AdjustmentMode != AdjustmentMode.ZoomOnly;
+
+ // Get the bounding box from camera's POV in view space
+ Vector3 up = curState.ReferenceUp;
+ var cameraPos = curState.RawPosition;
+ BoundingSphere s = group.Sphere;
+ Vector3 groupCenter = s.position;
+ Vector3 fwd = groupCenter - cameraPos;
+ float d = fwd.magnitude;
+ if (d < Epsilon)
+ return; // navel-gazing, get outa here
+
+ // Approximate looking at the group center
+ fwd /= d;
+ LastBoundsMatrix = Matrix4x4.TRS(
+ cameraPos, Quaternion.LookRotation(fwd, up), Vector3.one);
+
+ // Correction for the actual center
+ Bounds b;
+ if (isOrthographic)
+ {
+ b = group.GetViewSpaceBoundingBox(LastBoundsMatrix);
+ groupCenter = LastBoundsMatrix.MultiplyPoint3x4(b.center);
+ fwd = (groupCenter - cameraPos).normalized;
+ LastBoundsMatrix = Matrix4x4.TRS(cameraPos, Quaternion.LookRotation(fwd, up), Vector3.one);
+ b = group.GetViewSpaceBoundingBox(LastBoundsMatrix);
+ LastBounds = b;
+ }
+ else
+ {
+ b = GetScreenSpaceGroupBoundingBox(group, LastBoundsMatrix, out fwd);
+ LastBoundsMatrix = Matrix4x4.TRS(cameraPos, Quaternion.LookRotation(fwd, up), Vector3.one);
+ LastBounds = b;
+ groupCenter = cameraPos + fwd * b.center.z;
+ fwd = (groupCenter - cameraPos).normalized;
+ }
+
+ // Adjust bounds for framing size, and get target height
+ float boundsDepth = b.extents.z;
+ float targetHeight = GetTargetHeight(b.size / m_GroupFramingSize);
+
+ if (isOrthographic)
+ {
+ targetHeight = Mathf.Clamp(targetHeight, m_MinimumOrthoSize, m_MaximumOrthoSize);
+
+ // ApplyDamping
+ if (deltaTime >= 0)
+ targetHeight = m_prevFOV + Damper.Damp(targetHeight - m_prevFOV, m_FrameDamping, deltaTime);
+ m_prevFOV = targetHeight;
+
+ LensSettings lens = curState.Lens;
+ lens.OrthographicSize = Mathf.Clamp(targetHeight / 2, m_MinimumOrthoSize, m_MaximumOrthoSize);
+ curState.Lens = lens;
+ }
+ else
+ {
+ // Adjust height for perspective - we want the height at the near surface
+ float z = b.center.z;
+ if (z > boundsDepth)
+ targetHeight = Mathf.Lerp(0, targetHeight, (z - boundsDepth) / z);
+
+ // Move the camera
+ if (canMoveCamera)
+ {
+ // What distance from near edge would be needed to get the adjusted
+ // target height, at the current FOV
+ float targetDistance = boundsDepth
+ + targetHeight / (2f * Mathf.Tan(curState.Lens.FieldOfView * Mathf.Deg2Rad / 2f));
+
+ // Clamp to respect min/max distance settings to the near surface of the bounds
+ targetDistance = Mathf.Clamp(
+ targetDistance, boundsDepth + m_MinimumDistance, boundsDepth + m_MaximumDistance);
+
+ // Clamp to respect min/max camera movement
+ float targetDelta = targetDistance - Vector3.Distance(curState.RawPosition, groupCenter);
+ targetDelta = Mathf.Clamp(targetDelta, -m_MaxDollyIn, m_MaxDollyOut);
+
+ // ApplyDamping
+ if (deltaTime >= 0)
+ {
+ float delta = targetDelta - m_prevFramingDistance;
+ delta = Damper.Damp(delta, m_FrameDamping, deltaTime);
+ targetDelta = m_prevFramingDistance + delta;
+ }
+ m_prevFramingDistance = targetDelta;
+ curState.PositionCorrection -= fwd * targetDelta;
+ cameraPos -= fwd * targetDelta;
+ }
+
+ // Apply zoom
+ if (m_AdjustmentMode != AdjustmentMode.DollyOnly)
+ {
+ float nearBoundsDistance = (groupCenter - cameraPos).magnitude - boundsDepth;
+ float targetFOV = 179;
+ if (nearBoundsDistance > Epsilon)
+ targetFOV = 2f * Mathf.Atan(targetHeight / (2 * nearBoundsDistance)) * Mathf.Rad2Deg;
+ targetFOV = Mathf.Clamp(targetFOV, m_MinimumFOV, m_MaximumFOV);
+
+ // ApplyDamping
+ if (deltaTime >= 0 && m_prevFOV != 0)
+ targetFOV = m_prevFOV + Damper.Damp(targetFOV - m_prevFOV, m_FrameDamping, deltaTime);
+ m_prevFOV = targetFOV;
+
+ LensSettings lens = curState.Lens;
+ lens.FieldOfView = targetFOV;
+ curState.Lens = lens;
+ }
+ }
+ // Now compose normally
+ curState.ReferenceLookAt = GetLookAtPointAndSetTrackedPoint(
+ groupCenter, curState.ReferenceUp, deltaTime);
+ base.MutateCameraState(ref curState, deltaTime);
+ }
+
+ float GetTargetHeight(Vector2 boundsSize)
+ {
+ switch (m_FramingMode)
+ {
+ case FramingMode.Horizontal:
+ return Mathf.Max(Epsilon, boundsSize.x ) / VcamState.Lens.Aspect;
+ case FramingMode.Vertical:
+ return Mathf.Max(Epsilon, boundsSize.y);
+ default:
+ case FramingMode.HorizontalAndVertical:
+ return Mathf.Max(
+ Mathf.Max(Epsilon, boundsSize.x) / VcamState.Lens.Aspect,
+ Mathf.Max(Epsilon, boundsSize.y));
+ }
+ }
+
+ /// <param name="observer">Point of view</param>
+ /// <param name="newFwd">New forward direction to use when interpreting the return value</param>
+ /// <returns>Bounding box in a slightly rotated version of observer, as specified by newFwd</returns>
+ static Bounds GetScreenSpaceGroupBoundingBox(
+ CinemachineTargetGroup group, Matrix4x4 observer, out Vector3 newFwd)
+ {
+ Vector2 minAngles, maxAngles, zRange;
+ group.GetViewSpaceAngularBounds(observer, out minAngles, out maxAngles, out zRange);
+ Vector2 shift = (minAngles + maxAngles) / 2;
+
+ newFwd = Quaternion.identity.ApplyCameraRotation(shift, Vector3.up) * Vector3.forward;
+ newFwd = observer.MultiplyVector(newFwd);
+
+ float d = (zRange.y + zRange.x);
+ Vector2 angles = (maxAngles - shift) * Mathf.Deg2Rad;
+ angles = Vector2.Min(angles, new Vector2(89.5f, 89.5f));
+ return new Bounds(
+ new Vector3(0, 0, d/2),
+ new Vector3(Mathf.Tan(angles.y) * d, Mathf.Tan(angles.x) * d, zRange.y - zRange.x));
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 0f7633c93f0364a418841eeb8b058634
+timeCreated: 1496696780
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a CinemachineComponent in the Aim section of the component pipeline.
+ /// Its job is to place the camera on the Follow Target.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineHardLockToTarget : CinemachineComponentBase
+ {
+ /// <summary>True if component is enabled and has a LookAt defined</summary>
+ public override bool IsValid { get { return enabled && FollowTarget != null; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Aim stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Body; } }
+
+ /// <summary>Applies the composer rules and orients the camera accordingly</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for calculating damping. If less than
+ /// zero, then target will snap to the center of the dead zone.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ if (IsValid)
+ curState.RawPosition = FollowTargetPosition;
+ }
+ }
+}
+
--- /dev/null
+fileFormatVersion: 2
+guid: 36d1163fa822e8b418a0a603ec078d5c
+timeCreated: 1506531396
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a CinemachineComponent in the Aim section of the component pipeline.
+ /// Its job is to aim the camera hard at the LookAt target.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineHardLookAt : CinemachineComponentBase
+ {
+ /// <summary>True if component is enabled and has a LookAt defined</summary>
+ public override bool IsValid { get { return enabled && LookAtTarget != null; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Aim stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Aim; } }
+
+ /// <summary>Applies the composer rules and orients the camera accordingly</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for calculating damping. If less than
+ /// zero, then target will snap to the center of the dead zone.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ if (IsValid && curState.HasLookAt)
+ {
+ Vector3 dir = (curState.ReferenceLookAt - curState.CorrectedPosition);
+ if (dir.magnitude > Epsilon)
+ {
+ if (Vector3.Cross(dir.normalized, curState.ReferenceUp).magnitude < Epsilon)
+ curState.RawOrientation = Quaternion.FromToRotation(Vector3.forward, dir);
+ else
+ curState.RawOrientation = Quaternion.LookRotation(dir, curState.ReferenceUp);
+ }
+ }
+ }
+ }
+}
+
--- /dev/null
+fileFormatVersion: 2
+guid: 1e8b78ac948f05a46a6d8339a503172b
+timeCreated: 1506531396
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using UnityEngine;
+using Cinemachine.Utility;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a CinemachineComponent in the the Body section of the component pipeline.
+ /// Its job is to position the camera in a variable relationship to a the vcam's
+ /// Follow target object, with offsets and damping.
+ ///
+ /// This component is typically used to implement a camera that follows its target.
+ /// It can accept player input from an input device, which allows the player to
+ /// dynamically control the relationship between the camera and the target,
+ /// for example with a joystick.
+ ///
+ /// The OrbitalTransposer introduces the concept of __Heading__, which is the direction
+ /// in which the target is moving, and the OrbitalTransposer will attempt to position
+ /// the camera in relationship to the heading, which is by default directly behind the target.
+ /// You can control the default relationship by adjusting the Heading Bias setting.
+ ///
+ /// If you attach an input controller to the OrbitalTransposer, then the player can also
+ /// control the way the camera positions itself in relation to the target heading. This allows
+ /// the camera to move to any spot on an orbit around the target.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineOrbitalTransposer : CinemachineTransposer
+ {
+ /// <summary>
+ /// How the "forward" direction is defined. Orbital offset is in relation to the forward
+ /// direction.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct Heading
+ {
+ /// <summary>
+ /// Sets the algorithm for determining the target's heading for purposes
+ /// of re-centering the camera
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum HeadingDefinition
+ {
+ /// <summary>
+ /// Target heading calculated from the difference between its position on
+ /// the last update and current frame.
+ /// </summary>
+ PositionDelta,
+ /// <summary>
+ /// Target heading calculated from its <b>Rigidbody</b>'s velocity.
+ /// If no <b>Rigidbody</b> exists, it will fall back
+ /// to HeadingDerivationMode.PositionDelta
+ /// </summary>
+ Velocity,
+ /// <summary>
+ /// Target heading calculated from the Target <b>Transform</b>'s euler Y angle
+ /// </summary>
+ TargetForward,
+ /// <summary>
+ /// Default heading is a constant world space heading.
+ /// </summary>
+ WorldForward,
+ }
+ /// <summary>The method by which the 'default heading' is calculated if
+ /// recentering to target heading is enabled</summary>
+ [FormerlySerializedAs("m_HeadingDefinition")]
+ [Tooltip("How 'forward' is defined. The camera will be placed by default behind the target. PositionDelta will consider 'forward' to be the direction in which the target is moving.")]
+ public HeadingDefinition m_Definition;
+
+ /// <summary>Size of the velocity sampling window for target heading filter.
+ /// Used only if deriving heading from target's movement</summary>
+ [Range(0, 10)]
+ [Tooltip("Size of the velocity sampling window for target heading filter. This filters out irregularities in the target's movement. Used only if deriving heading from target's movement (PositionDelta or Velocity)")]
+ public int m_VelocityFilterStrength;
+
+ /// <summary>Additional Y rotation applied to the target heading.
+ /// When this value is 0, the camera will be placed behind the target</summary>
+ [Range(-180f, 180f)]
+ [FormerlySerializedAs("m_HeadingBias")]
+ [Tooltip("Where the camera is placed when the X-axis value is zero. This is a rotation in degrees around the Y axis. When this value is 0, the camera will be placed behind the target. Nonzero offsets will rotate the zero position around the target.")]
+ public float m_Bias;
+
+ /// <summary>Constructor</summary>
+ public Heading(HeadingDefinition def, int filterStrength, float bias)
+ {
+ m_Definition = def;
+ m_VelocityFilterStrength = filterStrength;
+ m_Bias = bias;
+ }
+ };
+
+ /// <summary>The definition of Forward. Camera will follow behind.</summary>
+ [Space]
+ [OrbitalTransposerHeadingProperty]
+ [Tooltip("The definition of Forward. Camera will follow behind.")]
+ public Heading m_Heading = new Heading(Heading.HeadingDefinition.TargetForward, 4, 0);
+
+ /// <summary>Parameters that control Automating Heading Recentering</summary>
+ [Tooltip("Automatic heading recentering. The settings here defines how the camera will reposition itself in the absence of player input.")]
+ public AxisState.Recentering m_RecenterToTargetHeading = new AxisState.Recentering(true, 1, 2);
+
+ /// <summary>Axis representing the current heading. Value is in degrees
+ /// and represents a rotation about the up vector</summary>
+ [Tooltip("Heading Control. The settings here control the behaviour of the camera in response to the player's input.")]
+ [AxisStateProperty]
+ public AxisState m_XAxis = new AxisState(-180, 180, true, false, 300f, 0.1f, 0.1f, "Mouse X", true);
+
+ /// <summary>Legacy support</summary>
+ [SerializeField] [HideInInspector] [FormerlySerializedAs("m_Radius")] private float m_LegacyRadius = float.MaxValue;
+ [SerializeField] [HideInInspector] [FormerlySerializedAs("m_HeightOffset")] private float m_LegacyHeightOffset = float.MaxValue;
+ [SerializeField] [HideInInspector] [FormerlySerializedAs("m_HeadingBias")] private float m_LegacyHeadingBias = float.MaxValue;
+ protected override void OnValidate()
+ {
+ // Upgrade after a legacy deserialize
+ if (m_LegacyRadius != float.MaxValue
+ && m_LegacyHeightOffset != float.MaxValue
+ && m_LegacyHeadingBias != float.MaxValue)
+ {
+ m_FollowOffset = new Vector3(0, m_LegacyHeightOffset, -m_LegacyRadius);
+ m_LegacyHeightOffset = m_LegacyRadius = float.MaxValue;
+
+ m_Heading.m_Bias = m_LegacyHeadingBias;
+ m_XAxis.m_MaxSpeed /= 10;
+ m_XAxis.m_AccelTime /= 10;
+ m_XAxis.m_DecelTime /= 10;
+ m_LegacyHeadingBias = float.MaxValue;
+ int heading = (int)m_Heading.m_Definition;
+ if (m_RecenterToTargetHeading.LegacyUpgrade(ref heading, ref m_Heading.m_VelocityFilterStrength))
+ m_Heading.m_Definition = (Heading.HeadingDefinition)heading;
+ }
+ m_XAxis.Validate();
+ m_RecenterToTargetHeading.Validate();
+
+ base.OnValidate();
+ }
+
+ /// <summary>
+ /// Drive the x-axis setting programmatically.
+ /// Automatic heading updating will be disabled.
+ /// </summary>
+ [HideInInspector, NoSaveDuringPlay]
+ public bool m_HeadingIsSlave = false;
+
+ /// <summary>
+ /// Delegate that allows the the m_XAxis object to be replaced with another one.
+ /// </summary>
+ internal delegate float UpdateHeadingDelegate(
+ CinemachineOrbitalTransposer orbital, float deltaTime, Vector3 up);
+
+ /// <summary>
+ /// Delegate that allows the the XAxis object to be replaced with another one.
+ /// To use it, just call orbital.UpdateHeading() with a reference to a
+ /// private AxisState object, and that AxisState object will be updated and
+ /// used to calculate the heading.
+ /// </summary>
+ internal UpdateHeadingDelegate HeadingUpdater
+ = (CinemachineOrbitalTransposer orbital, float deltaTime, Vector3 up)
+ => { return orbital.UpdateHeading(deltaTime, up, ref orbital.m_XAxis); };
+
+ /// <summary>
+ /// Update the X axis and calculate the heading. This can be called by a delegate
+ /// with a custom axis.
+ /// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
+ /// <param name="up">World Up, set by the CinemachineBrain</param>
+ /// <param name="axis"></param>
+ /// <returns>Axis value</returns>
+ /// </summary>
+ public float UpdateHeading(float deltaTime, Vector3 up, ref AxisState axis)
+ {
+ // Only read joystick when game is playing
+ if (deltaTime < 0 || !CinemachineCore.Instance.IsLive(VirtualCamera))
+ {
+ axis.Reset();
+ m_RecenterToTargetHeading.CancelRecentering();
+ }
+ else if (axis.Update(deltaTime))
+ m_RecenterToTargetHeading.CancelRecentering();
+
+ float targetHeading = GetTargetHeading(axis.Value, GetReferenceOrientation(up), deltaTime);
+ if (m_BindingMode != BindingMode.SimpleFollowWithWorldUp)
+ m_RecenterToTargetHeading.DoRecentering(ref axis, deltaTime, targetHeading);
+
+ float finalHeading = axis.Value;
+ if (m_BindingMode == BindingMode.SimpleFollowWithWorldUp)
+ axis.Value = 0;
+ return finalHeading;
+ }
+
+ private void OnEnable()
+ {
+ // GML todo: do we really need this?
+ PreviousTarget = null;
+ mLastTargetPosition = Vector3.zero;
+ }
+
+ private Vector3 mLastTargetPosition = Vector3.zero;
+ private HeadingTracker mHeadingTracker;
+ private Rigidbody mTargetRigidBody = null;
+ private Transform PreviousTarget { get; set; }
+ private Quaternion mHeadingPrevFrame = Quaternion.identity;
+ private Vector3 mOffsetPrevFrame = Vector3.zero;
+
+ /// <summary>This is called to notify the us that a target got warped,
+ /// so that we can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ base.OnTargetObjectWarped(target, positionDelta);
+ if (target == FollowTarget)
+ {
+ mLastTargetPosition += positionDelta;
+ }
+ }
+
+ /// <summary>Notification that this virtual camera is going live.
+ /// Base class implementation does nothing.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ /// <returns>True if the vcam should do an internal update as a result of this call</returns>
+ public override bool OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime,
+ ref CinemachineVirtualCameraBase.TransitionParams transitionParams)
+ {
+ if (fromCam != null //&& fromCam.Follow == FollowTarget
+ && m_BindingMode != CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp
+ && transitionParams.m_InheritPosition)
+ {
+ m_XAxis.Value = GetAxisClosestValue(fromCam.State.RawPosition, worldUp);
+ return true;
+ }
+ return false;
+ }
+
+ /// <summary>
+ /// What axis value would we need to get as close as possible to the desired cameraPos?
+ /// </summary>
+ /// <param name="cameraPos">camera position we would like to approximate</param>
+ /// <param name="up">world up</param>
+ /// <returns>The best value to put into the X axis, to approximate the desired camera pos</returns>
+ public float GetAxisClosestValue(Vector3 cameraPos, Vector3 up)
+ {
+ Quaternion orient = GetReferenceOrientation(up);
+ Vector3 fwd = (orient * Vector3.forward).ProjectOntoPlane(up);
+ if (!fwd.AlmostZero() && FollowTarget != null)
+ {
+ // Get the base camera placement
+ float heading = 0;
+ if (m_BindingMode != BindingMode.SimpleFollowWithWorldUp)
+ heading += m_Heading.m_Bias;
+ orient = orient * Quaternion.AngleAxis(heading, up);
+ Vector3 targetPos = FollowTargetPosition;
+ Vector3 pos = targetPos + orient * EffectiveOffset;
+
+ Vector3 a = (pos - targetPos).ProjectOntoPlane(up);
+ Vector3 b = (cameraPos - targetPos).ProjectOntoPlane(up);
+ return Vector3.SignedAngle(a, b, up);
+ }
+ return LastHeading; // Can't calculate, stay conservative
+ }
+
+ float LastHeading { get; set; }
+
+ /// <summary>Positions the virtual camera according to the transposer rules.</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ InitPrevFrameStateInfo(ref curState, deltaTime);
+
+ // Update the heading
+ if (FollowTarget != PreviousTarget)
+ {
+ PreviousTarget = FollowTarget;
+ mTargetRigidBody = (PreviousTarget == null) ? null : PreviousTarget.GetComponent<Rigidbody>();
+ mLastTargetPosition = (PreviousTarget == null) ? Vector3.zero : PreviousTarget.position;
+ mHeadingTracker = null;
+ }
+ LastHeading = HeadingUpdater(this, deltaTime, curState.ReferenceUp);
+ float heading = LastHeading;
+
+ if (IsValid)
+ {
+ mLastTargetPosition = FollowTargetPosition;
+
+ // Calculate the heading
+ if (m_BindingMode != BindingMode.SimpleFollowWithWorldUp)
+ heading += m_Heading.m_Bias;
+ Quaternion headingRot = Quaternion.AngleAxis(heading, Vector3.up);
+
+ // Track the target, with damping
+ Vector3 offset = EffectiveOffset;
+ Vector3 pos;
+ Quaternion orient;
+ TrackTarget(deltaTime, curState.ReferenceUp, headingRot * offset, out pos, out orient);
+
+ // Place the camera
+ curState.ReferenceUp = orient * Vector3.up;
+ if (deltaTime >= 0)
+ {
+ Vector3 bypass = (headingRot * offset) - mHeadingPrevFrame * mOffsetPrevFrame;
+ bypass = orient * bypass;
+ curState.PositionDampingBypass = bypass;
+ }
+ orient = orient * headingRot;
+ curState.RawPosition = pos + orient * offset;
+
+ mHeadingPrevFrame = (m_BindingMode == BindingMode.SimpleFollowWithWorldUp)
+ ? Quaternion.identity : headingRot;
+ mOffsetPrevFrame = offset;
+ }
+ }
+
+ /// <summary>Internal API for the Inspector Editor, so it can draw a marker at the target</summary>
+ public override Vector3 GetTargetCameraPosition(Vector3 worldUp)
+ {
+ if (!IsValid)
+ return Vector3.zero;
+ float heading = LastHeading;
+ if (m_BindingMode != BindingMode.SimpleFollowWithWorldUp)
+ heading += m_Heading.m_Bias;
+ Quaternion orient = Quaternion.AngleAxis(heading, Vector3.up);
+ orient = GetReferenceOrientation(worldUp) * orient;
+ var pos = orient * EffectiveOffset;
+ pos += mLastTargetPosition;
+ return pos;
+ }
+
+ static string GetFullName(GameObject current)
+ {
+ if (current == null)
+ return "";
+ if (current.transform.parent == null)
+ return "/" + current.name;
+ return GetFullName(current.transform.parent.gameObject) + "/" + current.name;
+ }
+
+ // Make sure this is calld only once per frame
+ private float GetTargetHeading(
+ float currentHeading, Quaternion targetOrientation, float deltaTime)
+ {
+ if (m_BindingMode == BindingMode.SimpleFollowWithWorldUp)
+ return 0;
+ if (FollowTarget == null)
+ return currentHeading;
+
+ var headingDef = m_Heading.m_Definition;
+ if (headingDef == Heading.HeadingDefinition.Velocity && mTargetRigidBody == null)
+ headingDef = Heading.HeadingDefinition.PositionDelta;
+
+ Vector3 velocity = Vector3.zero;
+ switch (headingDef)
+ {
+ case Heading.HeadingDefinition.PositionDelta:
+ velocity = FollowTargetPosition - mLastTargetPosition;
+ break;
+ case Heading.HeadingDefinition.Velocity:
+ velocity = mTargetRigidBody.velocity;
+ break;
+ case Heading.HeadingDefinition.TargetForward:
+ velocity = FollowTargetRotation * Vector3.forward;
+ break;
+ default:
+ case Heading.HeadingDefinition.WorldForward:
+ return 0;
+ }
+
+ // Process the velocity and derive the heading from it.
+ int filterSize = m_Heading.m_VelocityFilterStrength * 5;
+ if (mHeadingTracker == null || mHeadingTracker.FilterSize != filterSize)
+ mHeadingTracker = new HeadingTracker(filterSize);
+ mHeadingTracker.DecayHistory();
+ Vector3 up = targetOrientation * Vector3.up;
+ velocity = velocity.ProjectOntoPlane(up);
+ if (!velocity.AlmostZero())
+ mHeadingTracker.Add(velocity);
+
+ velocity = mHeadingTracker.GetReliableHeading();
+ if (!velocity.AlmostZero())
+ return UnityVectorExtensions.SignedAngle(targetOrientation * Vector3.forward, velocity, up);
+
+ // If no reliable heading, then stay where we are.
+ return currentHeading;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 9384ab8608cdc3d479fe89cd51eed48f
+timeCreated: 1485281954
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a CinemachineComponent in the Aim section of the component pipeline.
+ /// Its job is to aim the camera in response to the user's mouse or joystick input.
+ ///
+ /// The composer does not change the camera's position. It will only pan and tilt the
+ /// camera where it is, in order to get the desired framing. To move the camera, you have
+ /// to use the virtual camera's Body section.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachinePOV : CinemachineComponentBase
+ {
+ /// <summary>The Vertical axis. Value is -90..90. Controls the vertical orientation</summary>
+ [Tooltip("The Vertical axis. Value is -90..90. Controls the vertical orientation")]
+ [AxisStateProperty]
+ public AxisState m_VerticalAxis = new AxisState(-70, 70, false, false, 300f, 0.1f, 0.1f, "Mouse Y", true);
+
+ /// <summary>Controls how automatic recentering of the Vertical axis is accomplished</summary>
+ [Tooltip("Controls how automatic recentering of the Vertical axis is accomplished")]
+ public AxisState.Recentering m_VerticalRecentering = new AxisState.Recentering(false, 1, 2);
+
+ /// <summary>The Horizontal axis. Value is -180..180. Controls the horizontal orientation</summary>
+ [Tooltip("The Horizontal axis. Value is -180..180. Controls the horizontal orientation")]
+ [AxisStateProperty]
+ public AxisState m_HorizontalAxis = new AxisState(-180, 180, true, false, 300f, 0.1f, 0.1f, "Mouse X", false);
+
+ /// <summary>Controls how automatic recentering of the Horizontal axis is accomplished</summary>
+ [Tooltip("Controls how automatic recentering of the Horizontal axis is accomplished")]
+ public AxisState.Recentering m_HorizontalRecentering = new AxisState.Recentering(false, 1, 2);
+
+ /// <summary>True if component is enabled and has a LookAt defined</summary>
+ public override bool IsValid { get { return enabled; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Aim stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Aim; } }
+
+ private void OnValidate()
+ {
+ m_VerticalAxis.Validate();
+ m_VerticalRecentering.Validate();
+ m_HorizontalAxis.Validate();
+ m_HorizontalRecentering.Validate();
+ }
+
+ /// <summary>Applies the axis values and orients the camera accordingly</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for calculating damping. Not used.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ if (!IsValid)
+ return;
+
+ // Only read joystick when game is playing
+ if (deltaTime >= 0 && CinemachineCore.Instance.IsLive(VirtualCamera))
+ {
+ if (m_HorizontalAxis.Update(deltaTime))
+ m_HorizontalRecentering.CancelRecentering();
+ if (m_VerticalAxis.Update(deltaTime))
+ m_VerticalRecentering.CancelRecentering();
+ }
+ m_HorizontalRecentering.DoRecentering(ref m_HorizontalAxis, deltaTime, 0);
+ m_VerticalRecentering.DoRecentering(ref m_VerticalAxis, deltaTime, 0);
+
+ // If we have a transform parent, then apply POV in the local space of the parent
+ Quaternion rot = Quaternion.Euler(m_VerticalAxis.Value, m_HorizontalAxis.Value, 0);
+ Transform parent = VirtualCamera.transform.parent;
+ if (parent != null)
+ rot = parent.rotation * rot;
+ else
+ rot = rot * Quaternion.FromToRotation(Vector3.up, curState.ReferenceUp);
+ curState.RawOrientation = rot;
+ }
+
+ /// <summary>Notification that this virtual camera is going live.
+ /// Base class implementation does nothing.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ /// <returns>True if the vcam should do an internal update as a result of this call</returns>
+ public override bool OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime,
+ ref CinemachineVirtualCameraBase.TransitionParams transitionParams)
+ {
+ if (fromCam != null && transitionParams.m_InheritPosition)
+ {
+ Vector3 up = VcamState.ReferenceUp;
+ Quaternion targetRot = fromCam.State.RawOrientation;
+ Vector3 fwd = Vector3.forward;
+ Transform parent = VirtualCamera.transform.parent;
+ if (parent != null)
+ fwd = parent.rotation * fwd;
+
+ m_HorizontalAxis.Value = 0;
+ m_HorizontalAxis.Reset();
+ Vector3 targetFwd = targetRot * Vector3.forward;
+ Vector3 a = fwd.ProjectOntoPlane(up);
+ Vector3 b = targetFwd.ProjectOntoPlane(up);
+ if (!a.AlmostZero() && !b.AlmostZero())
+ m_HorizontalAxis.Value = Vector3.SignedAngle(a, b, up);
+
+ m_VerticalAxis.Value = 0;
+ m_VerticalAxis.Reset();
+ fwd = Quaternion.AngleAxis(m_HorizontalAxis.Value, up) * fwd;
+ Vector3 right = Vector3.Cross(up, fwd);
+ if (!right.AlmostZero())
+ m_VerticalAxis.Value = Vector3.SignedAngle(fwd, targetFwd, right);
+ return true;
+ }
+ return false;
+ }
+ }
+}
\ No newline at end of file
--- /dev/null
+fileFormatVersion: 2
+guid: 3c9beda531928fc40968802117a5d256
+timeCreated: 1504204894
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a CinemachineComponent in the Aim section of the component pipeline.
+ /// Its job is to match the orientation of the Follow target.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineSameAsFollowTarget : CinemachineComponentBase
+ {
+ /// <summary>True if component is enabled and has a Follow target defined</summary>
+ public override bool IsValid { get { return enabled && FollowTarget != null; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Aim stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Aim; } }
+
+ /// <summary>Orients the camera to match the Follow target's orientation</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Not used.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ if (IsValid)
+ curState.RawOrientation = FollowTargetRotation;
+ }
+ }
+}
+
--- /dev/null
+fileFormatVersion: 2
+guid: a4c41ac9245b87c4192012080077d830
+timeCreated: 1511551300
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using Cinemachine.Utility;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// A Cinemachine Virtual Camera Body component that constrains camera motion
+ /// to a CinemachinePath. The camera can move along the path.
+ ///
+ /// This behaviour can operate in two modes: manual positioning, and Auto-Dolly positioning.
+ /// In Manual mode, the camera's position is specified by animating the Path Position field.
+ /// In Auto-Dolly mode, the Path Position field is animated automatically every frame by finding
+ /// the position on the path that's closest to the virtual camera's Follow target.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineTrackedDolly : CinemachineComponentBase
+ {
+ /// <summary>The path to which the camera will be constrained. This must be non-null.</summary>
+ [Tooltip("The path to which the camera will be constrained. This must be non-null.")]
+ public CinemachinePathBase m_Path;
+
+ /// <summary>The position along the path at which the camera will be placed.
+ /// This can be animated directly, or set automatically by the Auto-Dolly feature
+ /// to get as close as possible to the Follow target.</summary>
+ [Tooltip("The position along the path at which the camera will be placed. This can be animated directly, or set automatically by the Auto-Dolly feature to get as close as possible to the Follow target. The value is interpreted according to the Position Units setting.")]
+ public float m_PathPosition;
+
+ /// <summary>How to interpret the Path Position</summary>
+ [Tooltip("How to interpret Path Position. If set to Path Units, values are as follows: 0 represents the first waypoint on the path, 1 is the second, and so on. Values in-between are points on the path in between the waypoints. If set to Distance, then Path Position represents distance along the path.")]
+ public CinemachinePathBase.PositionUnits m_PositionUnits = CinemachinePathBase.PositionUnits.PathUnits;
+
+ /// <summary>Where to put the camera realtive to the path postion. X is perpendicular to the path, Y is up, and Z is parallel to the path.</summary>
+ [Tooltip("Where to put the camera relative to the path position. X is perpendicular to the path, Y is up, and Z is parallel to the path. This allows the camera to be offset from the path itself (as if on a tripod, for example).")]
+ public Vector3 m_PathOffset = Vector3.zero;
+
+ /// <summary>How aggressively the camera tries to maintain the offset perpendicular to the path.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the target's
+ /// x-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain its position in a direction perpendicular to the path. Small numbers are more responsive, rapidly translating the camera to keep the target's x-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_XDamping = 0f;
+
+ /// <summary>How aggressively the camera tries to maintain the offset in the path-local up direction.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the target's
+ /// y-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain its position in the path-local up direction. Small numbers are more responsive, rapidly translating the camera to keep the target's y-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_YDamping = 0f;
+
+ /// <summary>How aggressively the camera tries to maintain the offset parallel to the path.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the
+ /// target's z-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain its position in a direction parallel to the path. Small numbers are more responsive, rapidly translating the camera to keep the target's z-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_ZDamping = 1f;
+
+ /// <summary>Different ways to set the camera's up vector</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum CameraUpMode
+ {
+ /// <summary>Leave the camera's up vector alone. It will be set according to the Brain's WorldUp.</summary>
+ Default,
+ /// <summary>Take the up vector from the path's up vector at the current point</summary>
+ Path,
+ /// <summary>Take the up vector from the path's up vector at the current point, but with the roll zeroed out</summary>
+ PathNoRoll,
+ /// <summary>Take the up vector from the Follow target's up vector</summary>
+ FollowTarget,
+ /// <summary>Take the up vector from the Follow target's up vector, but with the roll zeroed out</summary>
+ FollowTargetNoRoll,
+ };
+
+ /// <summary>How to set the virtual camera's Up vector. This will affect the screen composition.</summary>
+ [Tooltip("How to set the virtual camera's Up vector. This will affect the screen composition, because the camera Aim behaviours will always try to respect the Up direction.")]
+ public CameraUpMode m_CameraUp = CameraUpMode.Default;
+
+ /// <summary>"How aggressively the camera tries to track the target rotation's X angle.
+ /// Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to track the target rotation's X angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.")]
+ public float m_PitchDamping = 0;
+
+ /// <summary>How aggressively the camera tries to track the target rotation's Y angle.
+ /// Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to track the target rotation's Y angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.")]
+ public float m_YawDamping = 0;
+
+ /// <summary>How aggressively the camera tries to track the target rotation's Z angle.
+ /// Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to track the target rotation's Z angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.")]
+ public float m_RollDamping = 0f;
+
+ /// <summary>Controls how automatic dollying occurs</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct AutoDolly
+ {
+ /// <summary>If checked, will enable automatic dolly, which chooses a path position
+ /// that is as close as possible to the Follow target.</summary>
+ [Tooltip("If checked, will enable automatic dolly, which chooses a path position that is as close as possible to the Follow target. Note: this can have significant performance impact")]
+ public bool m_Enabled;
+
+ /// <summary>Offset, in current position units, from the closest point on the path to the follow target.</summary>
+ [Tooltip("Offset, in current position units, from the closest point on the path to the follow target")]
+ public float m_PositionOffset;
+
+ /// <summary>Search up to how many waypoints on either side of the current position. Use 0 for Entire path</summary>
+ [Tooltip("Search up to how many waypoints on either side of the current position. Use 0 for Entire path.")]
+ public int m_SearchRadius;
+
+ /// <summary>We search between waypoints by dividing the segment into this many straight pieces.
+ /// The higher the number, the more accurate the result, but performance is
+ /// proportionally slower for higher numbers</summary>
+ [FormerlySerializedAs("m_StepsPerSegment")]
+ [Tooltip("We search between waypoints by dividing the segment into this many straight pieces. The higher the number, the more accurate the result, but performance is proportionally slower for higher numbers")]
+ public int m_SearchResolution;
+
+ /// <summary>Constructor with specific field values</summary>
+ public AutoDolly(bool enabled, float positionOffset, int searchRadius, int stepsPerSegment)
+ {
+ m_Enabled = enabled;
+ m_PositionOffset = positionOffset;
+ m_SearchRadius = searchRadius;
+ m_SearchResolution = stepsPerSegment;
+ }
+ };
+
+ /// <summary>Controls how automatic dollying occurs</summary>
+ [Tooltip("Controls how automatic dollying occurs. A Follow target is necessary to use this feature.")]
+ public AutoDolly m_AutoDolly = new AutoDolly(false, 0, 2, 5);
+
+ /// <summary>True if component is enabled and has a path</summary>
+ public override bool IsValid { get { return enabled && m_Path != null; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Body stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Body; } }
+
+ /// <summary>Positions the virtual camera according to the transposer rules.</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for damping. If less that 0, no damping is done.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ // Init previous frame state info
+ if (deltaTime < 0)
+ {
+ m_PreviousPathPosition = m_PathPosition;
+ m_PreviousCameraPosition = curState.RawPosition;
+ }
+
+ if (!IsValid)
+ return;
+
+ // Get the new ideal path base position
+ if (m_AutoDolly.m_Enabled && FollowTarget != null)
+ {
+ float prevPos = m_Path.ToNativePathUnits(m_PreviousPathPosition, m_PositionUnits);
+ // This works in path units
+ m_PathPosition = m_Path.FindClosestPoint(
+ FollowTargetPosition,
+ Mathf.FloorToInt(prevPos),
+ (deltaTime < 0 || m_AutoDolly.m_SearchRadius <= 0)
+ ? -1 : m_AutoDolly.m_SearchRadius,
+ m_AutoDolly.m_SearchResolution);
+ m_PathPosition = m_Path.FromPathNativeUnits(m_PathPosition, m_PositionUnits);
+
+ // Apply the path position offset
+ m_PathPosition += m_AutoDolly.m_PositionOffset;
+ }
+ float newPathPosition = m_PathPosition;
+
+ if (deltaTime >= 0)
+ {
+ // Normalize previous position to find the shortest path
+ float maxUnit = m_Path.MaxUnit(m_PositionUnits);
+ if (maxUnit > 0)
+ {
+ float prev = m_Path.StandardizeUnit(m_PreviousPathPosition, m_PositionUnits);
+ float next = m_Path.StandardizeUnit(newPathPosition, m_PositionUnits);
+ if (m_Path.Looped && Mathf.Abs(next - prev) > maxUnit / 2)
+ {
+ if (next > prev)
+ prev += maxUnit;
+ else
+ prev -= maxUnit;
+ }
+ m_PreviousPathPosition = prev;
+ newPathPosition = next;
+ }
+
+ // Apply damping along the path direction
+ float offset = m_PreviousPathPosition - newPathPosition;
+ offset = Damper.Damp(offset, m_ZDamping, deltaTime);
+ newPathPosition = m_PreviousPathPosition - offset;
+ }
+ m_PreviousPathPosition = newPathPosition;
+ Quaternion newPathOrientation = m_Path.EvaluateOrientationAtUnit(newPathPosition, m_PositionUnits);
+
+ // Apply the offset to get the new camera position
+ Vector3 newCameraPos = m_Path.EvaluatePositionAtUnit(newPathPosition, m_PositionUnits);
+ Vector3 offsetX = newPathOrientation * Vector3.right;
+ Vector3 offsetY = newPathOrientation * Vector3.up;
+ Vector3 offsetZ = newPathOrientation * Vector3.forward;
+ newCameraPos += m_PathOffset.x * offsetX;
+ newCameraPos += m_PathOffset.y * offsetY;
+ newCameraPos += m_PathOffset.z * offsetZ;
+
+ // Apply damping to the remaining directions
+ if (deltaTime >= 0)
+ {
+ Vector3 currentCameraPos = m_PreviousCameraPosition;
+ Vector3 delta = (currentCameraPos - newCameraPos);
+ Vector3 delta1 = Vector3.Dot(delta, offsetY) * offsetY;
+ Vector3 delta0 = delta - delta1;
+ delta0 = Damper.Damp(delta0, m_XDamping, deltaTime);
+ delta1 = Damper.Damp(delta1, m_YDamping, deltaTime);
+ newCameraPos = currentCameraPos - (delta0 + delta1);
+ }
+ curState.RawPosition = m_PreviousCameraPosition = newCameraPos;
+
+ // Set the orientation and up
+ Quaternion newOrientation
+ = GetCameraOrientationAtPathPoint(newPathOrientation, curState.ReferenceUp);
+ if (deltaTime < 0)
+ m_PreviousOrientation = newOrientation;
+ else
+ {
+ if (deltaTime >= 0)
+ {
+ Vector3 relative = (Quaternion.Inverse(m_PreviousOrientation)
+ * newOrientation).eulerAngles;
+ for (int i = 0; i < 3; ++i)
+ if (relative[i] > 180)
+ relative[i] -= 360;
+ relative = Damper.Damp(relative, AngularDamping, deltaTime);
+ newOrientation = m_PreviousOrientation * Quaternion.Euler(relative);
+ }
+ m_PreviousOrientation = newOrientation;
+ }
+
+ curState.RawOrientation = newOrientation;
+ if (m_CameraUp != CameraUpMode.Default)
+ curState.ReferenceUp = curState.RawOrientation * Vector3.up;
+ }
+
+ private Quaternion GetCameraOrientationAtPathPoint(Quaternion pathOrientation, Vector3 up)
+ {
+ switch (m_CameraUp)
+ {
+ default:
+ case CameraUpMode.Default: break;
+ case CameraUpMode.Path: return pathOrientation;
+ case CameraUpMode.PathNoRoll:
+ return Quaternion.LookRotation(pathOrientation * Vector3.forward, up);
+ case CameraUpMode.FollowTarget:
+ if (FollowTarget != null)
+ return FollowTargetRotation;
+ break;
+ case CameraUpMode.FollowTargetNoRoll:
+ if (FollowTarget != null)
+ return Quaternion.LookRotation(FollowTargetRotation * Vector3.forward, up);
+ break;
+ }
+ return Quaternion.LookRotation(transform.rotation * Vector3.forward, up);
+ }
+
+ private Vector3 AngularDamping
+ {
+ get
+ {
+ switch (m_CameraUp)
+ {
+ case CameraUpMode.PathNoRoll:
+ case CameraUpMode.FollowTargetNoRoll:
+ return new Vector3(m_PitchDamping, m_YawDamping, 0);
+ case CameraUpMode.Default:
+ return Vector3.zero;
+ default:
+ return new Vector3(m_PitchDamping, m_YawDamping, m_RollDamping);
+ }
+ }
+ }
+
+ private float m_PreviousPathPosition = 0;
+ Quaternion m_PreviousOrientation = Quaternion.identity;
+ private Vector3 m_PreviousCameraPosition = Vector3.zero;
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 418e42c7d0405cc48a7b83f63ea53bb3
+timeCreated: 1493213884
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using Cinemachine.Utility;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is a CinemachineComponent in the Body section of the component pipeline.
+ /// Its job is to position the camera in a fixed relationship to the vcam's Follow
+ /// target object, with offsets and damping.
+ ///
+ /// The Tansposer will only change the camera's position in space. It will not
+ /// re-orient or otherwise aim the camera. To to that, you need to instruct
+ /// the vcam in the Aim section of its pipeline.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [AddComponentMenu("")] // Don't display in add component menu
+ [SaveDuringPlay]
+ public class CinemachineTransposer : CinemachineComponentBase
+ {
+ /// <summary>
+ /// The coordinate space to use when interpreting the offset from the target
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum BindingMode
+ {
+ /// <summary>
+ /// Camera will be bound to the Follow target using a frame of reference consisting
+ /// of the target's local frame at the moment when the virtual camera was enabled,
+ /// or when the target was assigned.
+ /// </summary>
+ LockToTargetOnAssign = 0,
+ /// <summary>
+ /// Camera will be bound to the Follow target using a frame of reference consisting
+ /// of the target's local frame, with the tilt and roll zeroed out.
+ /// </summary>
+ LockToTargetWithWorldUp = 1,
+ /// <summary>
+ /// Camera will be bound to the Follow target using a frame of reference consisting
+ /// of the target's local frame, with the roll zeroed out.
+ /// </summary>
+ LockToTargetNoRoll = 2,
+ /// <summary>
+ /// Camera will be bound to the Follow target using the target's local frame.
+ /// </summary>
+ LockToTarget = 3,
+ /// <summary>Camera will be bound to the Follow target using a world space offset.</summary>
+ WorldSpace = 4,
+ /// <summary>Offsets will be calculated relative to the target, using Camera-local axes</summary>
+ SimpleFollowWithWorldUp = 5
+ }
+ /// <summary>The coordinate space to use when interpreting the offset from the target</summary>
+ [Tooltip("The coordinate space to use when interpreting the offset from the target. This is also used to set the camera's Up vector, which will be maintained when aiming the camera.")]
+ public BindingMode m_BindingMode = BindingMode.LockToTargetWithWorldUp;
+
+ /// <summary>The distance which the transposer will attempt to maintain from the transposer subject</summary>
+ [Tooltip("The distance vector that the transposer will attempt to maintain from the Follow target")]
+ public Vector3 m_FollowOffset = Vector3.back * 10f;
+
+ /// <summary>How aggressively the camera tries to maintain the offset in the X-axis.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the target's
+ /// x-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain the offset in the X-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's x-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_XDamping = 1f;
+
+ /// <summary>How aggressively the camera tries to maintain the offset in the Y-axis.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the target's
+ /// y-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain the offset in the Y-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's y-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_YDamping = 1f;
+
+ /// <summary>How aggressively the camera tries to maintain the offset in the Z-axis.
+ /// Small numbers are more responsive, rapidly translating the camera to keep the
+ /// target's z-axis offset. Larger numbers give a more heavy slowly responding camera.
+ /// Using different settings per axis can yield a wide range of camera behaviors</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to maintain the offset in the Z-axis. Small numbers are more responsive, rapidly translating the camera to keep the target's z-axis offset. Larger numbers give a more heavy slowly responding camera. Using different settings per axis can yield a wide range of camera behaviors.")]
+ public float m_ZDamping = 1f;
+
+ /// <summary>How to calculate the angular damping for the target orientation</summary>
+ public enum AngularDampingMode
+ {
+ /// <summary>Use Euler angles to specify damping values.
+ /// Subject to gimbal-lock fwhen pitch is steep.</summary>
+ Euler,
+ /// <summary>
+ /// Use quaternions to calculate angular damping.
+ /// No per-channel control, but not susceptible to gimbal-lock</summary>
+ Quaternion
+ }
+
+ /// <summary>How to calculate the angular damping for the target orientation.
+ /// Use Quaternion if you expect the target to take on very steep pitches, which would
+ /// be subject to gimbal lock if Eulers are used.</summary>
+ public AngularDampingMode m_AngularDampingMode = AngularDampingMode.Euler;
+
+ /// <summary>How aggressively the camera tries to track the target rotation's X angle.
+ /// Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to track the target rotation's X angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.")]
+ public float m_PitchDamping = 0;
+
+ /// <summary>How aggressively the camera tries to track the target rotation's Y angle.
+ /// Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to track the target rotation's Y angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.")]
+ public float m_YawDamping = 0;
+
+ /// <summary>How aggressively the camera tries to track the target rotation's Z angle.
+ /// Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to track the target rotation's Z angle. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.")]
+ public float m_RollDamping = 0f;
+
+ /// <summary>How aggressively the camera tries to track the target's orientation.
+ /// Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.</summary>
+ [Range(0f, 20f)]
+ [Tooltip("How aggressively the camera tries to track the target's orientation. Small numbers are more responsive. Larger numbers give a more heavy slowly responding camera.")]
+ public float m_AngularDamping = 0f;
+
+ /// <summary>Derived classes should call this from their OnValidate() implementation</summary>
+ protected virtual void OnValidate()
+ {
+ m_FollowOffset = EffectiveOffset;
+ }
+
+ /// <summary>Hide the offset in int inspector. Used by FreeLook.</summary>
+ public bool HideOffsetInInspector { get; set; }
+
+ /// <summary>Get the target offset, with sanitization</summary>
+ public Vector3 EffectiveOffset
+ {
+ get
+ {
+ Vector3 offset = m_FollowOffset;
+ if (m_BindingMode == BindingMode.SimpleFollowWithWorldUp)
+ {
+ offset.x = 0;
+ offset.z = -Mathf.Abs(offset.z);
+ }
+ return offset;
+ }
+ }
+
+ /// <summary>True if component is enabled and has a valid Follow target</summary>
+ public override bool IsValid { get { return enabled && FollowTarget != null; } }
+
+ /// <summary>Get the Cinemachine Pipeline stage that this component implements.
+ /// Always returns the Body stage</summary>
+ public override CinemachineCore.Stage Stage { get { return CinemachineCore.Stage.Body; } }
+
+ /// <summary>Positions the virtual camera according to the transposer rules.</summary>
+ /// <param name="curState">The current camera state</param>
+ /// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
+ public override void MutateCameraState(ref CameraState curState, float deltaTime)
+ {
+ InitPrevFrameStateInfo(ref curState, deltaTime);
+ if (IsValid)
+ {
+ Vector3 pos;
+ Quaternion orient;
+ Vector3 offset = EffectiveOffset;
+ TrackTarget(deltaTime, curState.ReferenceUp, offset, out pos, out orient);
+ curState.RawPosition = pos + orient * offset;
+ curState.ReferenceUp = orient * Vector3.up;
+ }
+ }
+
+ /// <summary>This is called to notify the us that a target got warped,
+ /// so that we can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ base.OnTargetObjectWarped(target, positionDelta);
+ if (target == FollowTarget)
+ m_PreviousTargetPosition += positionDelta;
+ }
+
+ /// <summary>Initializes the state for previous frame if appropriate.</summary>
+ protected void InitPrevFrameStateInfo(
+ ref CameraState curState, float deltaTime)
+ {
+ if (m_previousTarget != FollowTarget || deltaTime < 0)
+ {
+ m_previousTarget = FollowTarget;
+ m_targetOrientationOnAssign
+ = (m_previousTarget == null) ? Quaternion.identity : FollowTargetRotation;
+ }
+ if (deltaTime < 0)
+ {
+ m_PreviousTargetPosition = FollowTargetPosition;
+ m_PreviousReferenceOrientation = GetReferenceOrientation(curState.ReferenceUp);
+ }
+ }
+
+ /// <summary>Positions the virtual camera according to the transposer rules.</summary>
+ /// <param name="deltaTime">Used for damping. If less than 0, no damping is done.</param>
+ /// <param name="up">Current camera up</param>
+ /// <param name="desiredCameraOffset">Where we want to put the camera relative to the follow target</param>
+ /// <param name="outTargetPosition">Resulting camera position</param>
+ /// <param name="outTargetOrient">Damped target orientation</param>
+ protected void TrackTarget(
+ float deltaTime, Vector3 up, Vector3 desiredCameraOffset,
+ out Vector3 outTargetPosition, out Quaternion outTargetOrient)
+ {
+ Quaternion targetOrientation = GetReferenceOrientation(up);
+ Quaternion dampedOrientation = targetOrientation;
+ if (deltaTime >= 0)
+ {
+ if (m_AngularDampingMode == AngularDampingMode.Quaternion
+ && m_BindingMode == BindingMode.LockToTarget)
+ {
+ float t = Damper.Damp(1, m_AngularDamping, deltaTime);
+ dampedOrientation = Quaternion.Slerp(
+ m_PreviousReferenceOrientation, targetOrientation, t);
+ }
+ else
+ {
+ Vector3 relative = (Quaternion.Inverse(m_PreviousReferenceOrientation)
+ * targetOrientation).eulerAngles;
+ for (int i = 0; i < 3; ++i)
+ if (relative[i] > 180)
+ relative[i] -= 360;
+ relative = Damper.Damp(relative, AngularDamping, deltaTime);
+ dampedOrientation = m_PreviousReferenceOrientation * Quaternion.Euler(relative);
+ }
+ }
+ m_PreviousReferenceOrientation = dampedOrientation;
+
+ Vector3 targetPosition = FollowTargetPosition;
+ Vector3 currentPosition = m_PreviousTargetPosition;
+ Vector3 worldOffset = targetPosition - currentPosition;
+
+ // Adjust for damping, which is done in camera-offset-local coords
+ if (deltaTime >= 0)
+ {
+ Quaternion dampingSpace;
+ if (desiredCameraOffset.AlmostZero())
+ dampingSpace = VcamState.RawOrientation;
+ else
+ dampingSpace = Quaternion.LookRotation(dampedOrientation * desiredCameraOffset.normalized, up);
+ Vector3 localOffset = Quaternion.Inverse(dampingSpace) * worldOffset;
+ localOffset = Damper.Damp(localOffset, Damping, deltaTime);
+ worldOffset = dampingSpace * localOffset;
+ }
+ outTargetPosition = m_PreviousTargetPosition = currentPosition + worldOffset;
+ outTargetOrient = dampedOrientation;
+ }
+
+ /// <summary>
+ /// Damping speeds for each of the 3 axes of the offset from target
+ /// </summary>
+ protected Vector3 Damping
+ {
+ get
+ {
+ switch (m_BindingMode)
+ {
+ case BindingMode.SimpleFollowWithWorldUp:
+ return new Vector3(0, m_YDamping, m_ZDamping);
+ default:
+ return new Vector3(m_XDamping, m_YDamping, m_ZDamping);
+ }
+ }
+ }
+
+ /// <summary>
+ /// Damping speeds for each of the 3 axes of the target's rotation
+ /// </summary>
+ protected Vector3 AngularDamping
+ {
+ get
+ {
+ switch (m_BindingMode)
+ {
+ case BindingMode.LockToTargetNoRoll:
+ return new Vector3(m_PitchDamping, m_YawDamping, 0);
+ case BindingMode.LockToTargetWithWorldUp:
+ return new Vector3(0, m_YawDamping, 0);
+ case BindingMode.LockToTargetOnAssign:
+ case BindingMode.WorldSpace:
+ case BindingMode.SimpleFollowWithWorldUp:
+ return Vector3.zero;
+ default:
+ return new Vector3(m_PitchDamping, m_YawDamping, m_RollDamping);
+ }
+ }
+ }
+
+ /// <summary>Internal API for the Inspector Editor, so it can draw a marker at the target</summary>
+ public virtual Vector3 GetTargetCameraPosition(Vector3 worldUp)
+ {
+ if (!IsValid)
+ return Vector3.zero;
+ return FollowTargetPosition + GetReferenceOrientation(worldUp) * EffectiveOffset;
+ }
+
+ /// <summary>State information for damping</summary>
+ Vector3 m_PreviousTargetPosition = Vector3.zero;
+ Quaternion m_PreviousReferenceOrientation = Quaternion.identity;
+ Quaternion m_targetOrientationOnAssign = Quaternion.identity;
+ Transform m_previousTarget = null;
+
+ /// <summary>Internal API for the Inspector Editor, so it can draw a marker at the target</summary>
+ public Quaternion GetReferenceOrientation(Vector3 worldUp)
+ {
+ if (FollowTarget != null)
+ {
+ Quaternion targetOrientation = FollowTarget.rotation;
+ switch (m_BindingMode)
+ {
+ case BindingMode.LockToTargetOnAssign:
+ return m_targetOrientationOnAssign;
+ case BindingMode.LockToTargetWithWorldUp:
+ return Uppify(targetOrientation, worldUp);
+ case BindingMode.LockToTargetNoRoll:
+ return Quaternion.LookRotation(targetOrientation * Vector3.forward, worldUp);
+ case BindingMode.LockToTarget:
+ return targetOrientation;
+ case BindingMode.SimpleFollowWithWorldUp:
+ {
+ Vector3 dir = FollowTargetPosition - VcamState.RawPosition;
+ dir = dir.ProjectOntoPlane(worldUp);
+ if (dir.AlmostZero())
+ break;
+ return Quaternion.LookRotation(dir.normalized, worldUp);
+ }
+ default:
+ break;
+ }
+ }
+ return Quaternion.identity;
+ }
+
+ static Quaternion Uppify(Quaternion q, Vector3 up)
+ {
+ Quaternion r = Quaternion.FromToRotation(q * Vector3.up, up);
+ return r * q;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: fa7155796051b734daa718462081dc5f
+timeCreated: 1484001119
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 3d53800f587b60a4191877d7713cd17c
+folderAsset: yes
+timeCreated: 1489096338
+licenseType: Pro
+DefaultImporter:
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using Cinemachine.Utility;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Axis state for defining how to react to player input.
+ /// The settings here control the responsiveness of the axis to player input.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct AxisState
+ {
+ /// <summary>The current value of the axis</summary>
+ [NoSaveDuringPlay]
+ [Tooltip("The current value of the axis.")]
+ public float Value;
+
+ /// <summary>How fast the axis value can travel. Increasing this number
+ /// makes the behaviour more responsive to joystick input</summary>
+ [Tooltip("The maximum speed of this axis in units/second")]
+ public float m_MaxSpeed;
+
+ /// <summary>The amount of time in seconds it takes to accelerate to
+ /// MaxSpeed with the supplied Axis at its maximum value</summary>
+ [Tooltip("The amount of time in seconds it takes to accelerate to MaxSpeed with the supplied Axis at its maximum value")]
+ public float m_AccelTime;
+
+ /// <summary>The amount of time in seconds it takes to decelerate
+ /// the axis to zero if the supplied axis is in a neutral position</summary>
+ [Tooltip("The amount of time in seconds it takes to decelerate the axis to zero if the supplied axis is in a neutral position")]
+ public float m_DecelTime;
+
+ /// <summary>The name of this axis as specified in Unity Input manager.
+ /// Setting to an empty string will disable the automatic updating of this axis</summary>
+ [FormerlySerializedAs("m_AxisName")]
+ [Tooltip("The name of this axis as specified in Unity Input manager. Setting to an empty string will disable the automatic updating of this axis")]
+ public string m_InputAxisName;
+
+ /// <summary>The value of the input axis. A value of 0 means no input
+ /// You can drive this directly from a
+ /// custom input system, or you can set the Axis Name and have the value
+ /// driven by the internal Input Manager</summary>
+ [NoSaveDuringPlay]
+ [Tooltip("The value of the input axis. A value of 0 means no input. You can drive this directly from a custom input system, or you can set the Axis Name and have the value driven by the internal Input Manager")]
+ public float m_InputAxisValue;
+
+ /// <summary>If checked, then the raw value of the input axis will be inverted
+ /// before it is used.</summary>
+ [FormerlySerializedAs("m_InvertAxis")]
+ [Tooltip("If checked, then the raw value of the input axis will be inverted before it is used")]
+ public bool m_InvertInput;
+
+ /// <summary>The minimum value for the axis</summary>
+ [Tooltip("The minimum value for the axis")]
+ public float m_MinValue;
+
+ /// <summary>The maximum value for the axis</summary>
+ [Tooltip("The maximum value for the axis")]
+ public float m_MaxValue;
+
+ /// <summary>If checked, then the axis will wrap around at the min/max values, forming a loop</summary>
+ [Tooltip("If checked, then the axis will wrap around at the min/max values, forming a loop")]
+ public bool m_Wrap;
+
+ /// <summary>Automatic recentering. Valid only if HasRecentering is true</summary>
+ [Tooltip("Automatic recentering to at-rest position")]
+ public Recentering m_Recentering;
+
+ private float mCurrentSpeed;
+
+ /// <summary>Constructor with specific values</summary>
+ public AxisState(
+ float minValue, float maxValue, bool wrap, bool rangeLocked,
+ float maxSpeed, float accelTime, float decelTime,
+ string name, bool invert)
+ {
+ m_MinValue = minValue;
+ m_MaxValue = maxValue;
+ m_Wrap = wrap;
+ ValueRangeLocked = rangeLocked;
+
+ HasRecentering = false;
+ m_Recentering = new Recentering(false, 1, 2);
+
+ m_MaxSpeed = maxSpeed;
+ m_AccelTime = accelTime;
+ m_DecelTime = decelTime;
+ Value = (minValue + maxValue) / 2;
+ m_InputAxisName = name;
+ m_InputAxisValue = 0;
+ m_InvertInput = invert;
+
+ mCurrentSpeed = 0f;
+ }
+
+ /// <summary>Call from OnValidate: Make sure the fields are sensible</summary>
+ public void Validate()
+ {
+ m_MaxSpeed = Mathf.Max(0, m_MaxSpeed);
+ m_AccelTime = Mathf.Max(0, m_AccelTime);
+ m_DecelTime = Mathf.Max(0, m_DecelTime);
+ m_MaxValue = Mathf.Clamp(m_MaxValue, m_MinValue, m_MaxValue);
+ }
+
+ const float Epsilon = UnityVectorExtensions.Epsilon;
+
+ public void Reset()
+ {
+ m_InputAxisValue = 0;
+ mCurrentSpeed = 0;
+ }
+
+ /// <summary>
+ /// Updates the state of this axis based on the axis defined
+ /// by AxisState.m_AxisName
+ /// </summary>
+ /// <param name="deltaTime">Delta time in seconds</param>
+ /// <returns>Returns <b>true</b> if this axis' input was non-zero this Update,
+ /// <b>false</b> otherwise</returns>
+ public bool Update(float deltaTime)
+ {
+ if (!string.IsNullOrEmpty(m_InputAxisName))
+ {
+ try
+ {
+ m_InputAxisValue = CinemachineCore.GetInputAxis(m_InputAxisName);
+ }
+ catch (ArgumentException e)
+ {
+ Debug.LogError(e.ToString());
+ }
+ }
+
+ float input = m_InputAxisValue;
+ if (m_InvertInput)
+ input *= -1f;
+
+ if (m_MaxSpeed > Epsilon)
+ {
+ float targetSpeed = input * m_MaxSpeed;
+ if (Mathf.Abs(targetSpeed) < Epsilon
+ || (Mathf.Sign(mCurrentSpeed) == Mathf.Sign(targetSpeed)
+ && Mathf.Abs(targetSpeed) < Mathf.Abs(mCurrentSpeed)))
+ {
+ // Need to decelerate
+ float a = Mathf.Abs(targetSpeed - mCurrentSpeed) / Mathf.Max(Epsilon, m_DecelTime);
+ float delta = Mathf.Min(a * deltaTime, Mathf.Abs(mCurrentSpeed));
+ mCurrentSpeed -= Mathf.Sign(mCurrentSpeed) * delta;
+ }
+ else
+ {
+ // Accelerate to the target speed
+ float a = Mathf.Abs(targetSpeed - mCurrentSpeed) / Mathf.Max(Epsilon, m_AccelTime);
+ mCurrentSpeed += Mathf.Sign(targetSpeed) * a * deltaTime;
+ if (Mathf.Sign(mCurrentSpeed) == Mathf.Sign(targetSpeed)
+ && Mathf.Abs(mCurrentSpeed) > Mathf.Abs(targetSpeed))
+ {
+ mCurrentSpeed = targetSpeed;
+ }
+ }
+ }
+
+ // Clamp our max speeds so we don't go crazy
+ float maxSpeed = GetMaxSpeed();
+ mCurrentSpeed = Mathf.Clamp(mCurrentSpeed, -maxSpeed, maxSpeed);
+
+ Value += mCurrentSpeed * deltaTime;
+ bool isOutOfRange = (Value > m_MaxValue) || (Value < m_MinValue);
+ if (isOutOfRange)
+ {
+ if (m_Wrap)
+ {
+ if (Value > m_MaxValue)
+ Value = m_MinValue + (Value - m_MaxValue);
+ else
+ Value = m_MaxValue + (Value - m_MinValue);
+ }
+ else
+ {
+ Value = Mathf.Clamp(Value, m_MinValue, m_MaxValue);
+ mCurrentSpeed = 0f;
+ }
+ }
+ return Mathf.Abs(input) > Epsilon;
+ }
+
+ // MaxSpeed may be limited as we approach the range ends, in order
+ // to prevent a hard bump
+ private float GetMaxSpeed()
+ {
+ float range = m_MaxValue - m_MinValue;
+ if (!m_Wrap && range > 0)
+ {
+ float threshold = range / 10f;
+ if (mCurrentSpeed > 0 && (m_MaxValue - Value) < threshold)
+ {
+ float t = (m_MaxValue - Value) / threshold;
+ return Mathf.Lerp(0, m_MaxSpeed, t);
+ }
+ else if (mCurrentSpeed < 0 && (Value - m_MinValue) < threshold)
+ {
+ float t = (Value - m_MinValue) / threshold;
+ return Mathf.Lerp(0, m_MaxSpeed, t);
+ }
+ }
+ return m_MaxSpeed;
+ }
+
+ /// <summary>Value range is locked, i.e. not adjustable by the user (used by editor)</summary>
+ public bool ValueRangeLocked { get; set; }
+
+ /// <summary>True if the Recentering member is valid (bcak-compatibility support:
+ /// old versions had recentering in a separate structure)</summary>
+ public bool HasRecentering { get; set; }
+
+ /// <summary>Helper for automatic axis recentering</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct Recentering
+ {
+ /// <summary>If checked, will enable automatic recentering of the
+ /// axis. If FALSE, recenting is disabled.</summary>
+ [Tooltip("If checked, will enable automatic recentering of the axis. If unchecked, recenting is disabled.")]
+ public bool m_enabled;
+
+ /// <summary>If no input has been detected, the camera will wait
+ /// this long in seconds before moving its heading to the default heading.</summary>
+ [Tooltip("If no user input has been detected on the axis, the axis will wait this long in seconds before recentering.")]
+ public float m_WaitTime;
+
+ /// <summary>How long it takes to reach destination once recentering has started</summary>
+ [Tooltip("How long it takes to reach destination once recentering has started.")]
+ public float m_RecenteringTime;
+
+ /// <summary>Constructor with specific field values</summary>
+ public Recentering(bool enabled, float waitTime, float recenteringTime)
+ {
+ m_enabled = enabled;
+ m_WaitTime = waitTime;
+ m_RecenteringTime = recenteringTime;
+ mLastAxisInputTime = 0;
+ mRecenteringVelocity = 0;
+ m_LegacyHeadingDefinition = m_LegacyVelocityFilterStrength = -1;
+ }
+
+ /// <summary>Call this from OnValidate()</summary>
+ public void Validate()
+ {
+ m_WaitTime = Mathf.Max(0, m_WaitTime);
+ m_RecenteringTime = Mathf.Max(0, m_RecenteringTime);
+ }
+
+ // Internal state
+ float mLastAxisInputTime;
+ float mRecenteringVelocity;
+ public void CopyStateFrom(ref Recentering other)
+ {
+ if (mLastAxisInputTime != other.mLastAxisInputTime)
+ other.mRecenteringVelocity = 0;
+ mLastAxisInputTime = other.mLastAxisInputTime;
+ }
+
+ /// <summary>Cancel any recenetering in progress.</summary>
+ public void CancelRecentering()
+ {
+ mLastAxisInputTime = Time.time;
+ mRecenteringVelocity = 0;
+ }
+
+ /// <summary>Skip the wait time and start recentering now (only if enabled).</summary>
+ public void RecenterNow()
+ {
+ mLastAxisInputTime = 0;
+ }
+
+ /// <summary>Bring the axis back to the cenetered state (only if enabled).</summary>
+ public void DoRecentering(ref AxisState axis, float deltaTime, float recenterTarget)
+ {
+ if (!m_enabled)
+ return;
+
+ if (deltaTime < 0)
+ {
+ CancelRecentering();
+ axis.Value = recenterTarget;
+ }
+ else if (Time.time > (mLastAxisInputTime + m_WaitTime))
+ {
+ // Scale value determined heuristically, to account for accel/decel
+ float recenterTime = m_RecenteringTime / 3f;
+ if (recenterTime <= deltaTime)
+ axis.Value = recenterTarget;
+ else
+ {
+ float headingError = Mathf.DeltaAngle(axis.Value, recenterTarget);
+ float absHeadingError = Mathf.Abs(headingError);
+ if (absHeadingError < UnityVectorExtensions.Epsilon)
+ {
+ axis.Value = recenterTarget;
+ mRecenteringVelocity = 0;
+ }
+ else
+ {
+ float scale = deltaTime / recenterTime;
+ float desiredVelocity = Mathf.Sign(headingError)
+ * Mathf.Min(absHeadingError, absHeadingError * scale);
+ // Accelerate to the desired velocity
+ float accel = desiredVelocity - mRecenteringVelocity;
+ if ((desiredVelocity < 0 && accel < 0) || (desiredVelocity > 0 && accel > 0))
+ desiredVelocity = mRecenteringVelocity + desiredVelocity * scale;
+ axis.Value += desiredVelocity;
+ mRecenteringVelocity = desiredVelocity;
+ }
+ }
+ }
+ }
+
+ // Legacy support
+ [SerializeField] [HideInInspector] [FormerlySerializedAs("m_HeadingDefinition")] private int m_LegacyHeadingDefinition;
+ [SerializeField] [HideInInspector] [FormerlySerializedAs("m_VelocityFilterStrength")] private int m_LegacyVelocityFilterStrength;
+ internal bool LegacyUpgrade(ref int heading, ref int velocityFilter)
+ {
+ if (m_LegacyHeadingDefinition != -1 && m_LegacyVelocityFilterStrength != -1)
+ {
+ heading = m_LegacyHeadingDefinition;
+ velocityFilter = m_LegacyVelocityFilterStrength;
+ m_LegacyHeadingDefinition = m_LegacyVelocityFilterStrength = -1;
+ return true;
+ }
+ return false;
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 557c6f70a7173744abaa3967b6da6f5d
+timeCreated: 1504195334
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using Cinemachine.Utility;
+using System.Collections.Generic;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// The output of the Cinemachine engine for a specific virtual camera. The information
+ /// in this struct can be blended, and provides what is needed to calculate an
+ /// appropriate camera position, orientation, and lens setting.
+ ///
+ /// Raw values are what the Cinemachine behaviours generate. The correction channel
+ /// holds perturbations to the raw values - e.g. noise or smoothing, or obstacle
+ /// avoidance corrections. Coirrections are not considered when making time-based
+ /// calculations such as damping.
+ ///
+ /// The Final position and orientation is the comination of the raw values and
+ /// their corrections.
+ /// </summary>
+ public struct CameraState
+ {
+ /// <summary>
+ /// Camera Lens Settings.
+ /// </summary>
+ public LensSettings Lens { get; set; }
+
+ /// <summary>
+ /// Which way is up. World space unit vector. Must have a length of 1.
+ /// </summary>
+ public Vector3 ReferenceUp { get; set; }
+
+ /// <summary>
+ /// The world space focus point of the camera. What the camera wants to look at.
+ /// There is a special constant define to represent "nothing". Be careful to
+ /// check for that (or check the HasLookAt property).
+ /// </summary>
+ public Vector3 ReferenceLookAt { get; set; }
+
+ /// <summary>
+ /// Returns true if this state has a valid ReferenceLookAt value.
+ /// </summary>
+ public bool HasLookAt { get { return ReferenceLookAt == ReferenceLookAt; } } // will be false if NaN
+
+ /// <summary>
+ /// This constant represents "no point in space" or "no direction".
+ /// </summary>
+ public static Vector3 kNoPoint = new Vector3(float.NaN, float.NaN, float.NaN);
+
+ /// <summary>
+ /// Raw (un-corrected) world space position of this camera
+ /// </summary>
+ public Vector3 RawPosition { get; set; }
+
+ /// <summary>
+ /// Raw (un-corrected) world space orientation of this camera
+ /// </summary>
+ public Quaternion RawOrientation { get; set; }
+
+ /// <summary>This is a way for the Body component to bypass aim damping,
+ /// useful for when the body need to rotate its point of view, but does not
+ /// want interference from the aim damping</summary>
+ public Vector3 PositionDampingBypass { get; set; }
+
+ /// <summary>
+ /// Subjective estimation of how "good" the shot is.
+ /// Larger values mean better quality. Default is 1.
+ /// </summary>
+ public float ShotQuality { get; set; }
+
+ /// <summary>
+ /// Position correction. This will be added to the raw position.
+ /// This value doesn't get fed back into the system when calculating the next frame.
+ /// Can be noise, or smoothing, or both, or something else.
+ /// </summary>
+ public Vector3 PositionCorrection { get; set; }
+
+ /// <summary>
+ /// Orientation correction. This will be added to the raw orientation.
+ /// This value doesn't get fed back into the system when calculating the next frame.
+ /// Can be noise, or smoothing, or both, or something else.
+ /// </summary>
+ public Quaternion OrientationCorrection { get; set; }
+
+ /// <summary>
+ /// Position with correction applied.
+ /// </summary>
+ public Vector3 CorrectedPosition { get { return RawPosition + PositionCorrection; } }
+
+ /// <summary>
+ /// Orientation with correction applied.
+ /// </summary>
+ public Quaternion CorrectedOrientation { get { return RawOrientation * OrientationCorrection; } }
+
+ /// <summary>
+ /// Position with correction applied. This is what the final camera gets.
+ /// </summary>
+ public Vector3 FinalPosition { get { return RawPosition + PositionCorrection; } }
+
+ /// <summary>
+ /// Orientation with correction and dutch applied. This is what the final camera gets.
+ /// </summary>
+ public Quaternion FinalOrientation
+ {
+ get
+ {
+ if (Mathf.Abs(Lens.Dutch) > UnityVectorExtensions.Epsilon)
+ return CorrectedOrientation * Quaternion.AngleAxis(Lens.Dutch, Vector3.forward);
+ return CorrectedOrientation;
+ }
+ }
+
+ /// <summary>
+ /// These hints can be or'ed toether to influence how blending is done, and how state
+ /// is applied to the camera
+ /// </summary>
+ public enum BlendHintValue
+ {
+ /// <summary>Normal state blending</summary>
+ Nothing = 0,
+ /// <summary>This state does not affect the camera position</summary>
+ NoPosition = 1,
+ /// <summary>This state does not affect the camera rotation</summary>
+ NoOrientation = 2,
+ /// <summary>Combination of NoPosition and NoOrientation</summary>
+ NoTransform = NoPosition | NoOrientation,
+ /// <summary>Spherical blend about the LookAt target (if any)</summary>
+ SphericalPositionBlend = 4,
+ /// <summary>Cylindrical blend about the LookAt target (if any)</summary>
+ CylindricalPositionBlend = 8,
+ /// <summary>Radial blend when the LookAt target changes(if any)</summary>
+ RadialAimBlend = 16,
+ /// <summary>Ignore the LookAt target and just slerp the orientation</summary>
+ IgnoreLookAtTarget = 32,
+ /// <summary>This state does not affect the lens</summary>
+ NoLens = 64,
+ }
+
+ /// <summary>
+ /// These hints can be or'ed toether to influence how blending is done, and how state
+ /// is applied to the camera
+ /// </summary>
+ public BlendHintValue BlendHint { get; set; }
+
+ /// <summary>
+ /// State with default values
+ /// </summary>
+ public static CameraState Default
+ {
+ get
+ {
+ CameraState state = new CameraState();
+ state.Lens = LensSettings.Default;
+ state.ReferenceUp = Vector3.up;
+ state.ReferenceLookAt = kNoPoint;
+ state.RawPosition = Vector3.zero;
+ state.RawOrientation = Quaternion.identity;
+ state.ShotQuality = 1;
+ state.PositionCorrection = Vector3.zero;
+ state.OrientationCorrection = Quaternion.identity;
+ state.PositionDampingBypass = Vector3.zero;
+ state.BlendHint = BlendHintValue.Nothing;
+ return state;
+ }
+ }
+
+ /// <summary>Opaque structure represent extra blendable stuff and its weight.
+ /// The base system ignores this data - it is intended for extension modules</summary>
+ public struct CustomBlendable
+ {
+ /// <summary>The custom stuff that the extension module will consider</summary>
+ public Object m_Custom;
+ /// <summary>The weight of the custom stuff. Must be 0...1</summary>
+ public float m_Weight;
+
+ /// <summary>Constructor with specific values</summary>
+ /// <param name="custom">The custom stuff that the extension module will consider</param>
+ /// <param name="weight">The weight of the custom stuff. Must be 0...1</param>
+ public CustomBlendable(Object custom, float weight)
+ { m_Custom = custom; m_Weight = weight; }
+ };
+
+ // This is to avoid excessive GC allocs
+ CustomBlendable mCustom0;
+ CustomBlendable mCustom1;
+ CustomBlendable mCustom2;
+ CustomBlendable mCustom3;
+ List<CustomBlendable> m_CustomOverflow;
+
+ /// <summary>The number of custom blendables that will be applied to the camera.
+ /// The base system manages but otherwise ignores this data - it is intended for
+ /// extension modules</summary>
+ public int NumCustomBlendables { get; private set; }
+
+ /// <summary>Get a custom blendable that will be applied to the camera.
+ /// The base system manages but otherwise ignores this data - it is intended for
+ /// extension modules</summary>
+ /// <param name="index">Which one to get. Must be in range [0...NumCustomBlendables)</param>
+ /// <returns>The custom blendable at the specified index.</returns>
+ public CustomBlendable GetCustomBlendable(int index)
+ {
+ switch (index)
+ {
+ case 0: return mCustom0;
+ case 1: return mCustom1;
+ case 2: return mCustom2;
+ case 3: return mCustom3;
+ default:
+ {
+ index -= 4;
+ if (m_CustomOverflow != null && index < m_CustomOverflow.Count)
+ return m_CustomOverflow[index];
+ return new CustomBlendable(null, 0);
+ }
+ }
+ }
+
+ int FindCustomBlendable(Object custom)
+ {
+ if (mCustom0.m_Custom == custom)
+ return 0;
+ if (mCustom1.m_Custom == custom)
+ return 1;
+ if (mCustom2.m_Custom == custom)
+ return 2;
+ if (mCustom3.m_Custom == custom)
+ return 3;
+ if (m_CustomOverflow != null)
+ {
+ for (int i = 0; i < m_CustomOverflow.Count; ++i)
+ if (m_CustomOverflow[i].m_Custom == custom)
+ return i + 4;
+ }
+ return -1;
+ }
+
+ /// <summary>Add a custom blendable to the pot for eventual application to the camera.
+ /// The base system manages but otherwise ignores this data - it is intended for
+ /// extension modules</summary>
+ /// <param name="b">The custom blendable to add. If b.m_Custom is the same as an
+ /// already-added custom blendable, then they will be merged and the weights combined.</param>
+ public void AddCustomBlendable(CustomBlendable b)
+ {
+ // Attempt to merge common blendables to avoid growth
+ int index = FindCustomBlendable(b.m_Custom);
+ if (index >= 0)
+ b.m_Weight += GetCustomBlendable(index).m_Weight;
+ else
+ {
+ index = NumCustomBlendables;
+ NumCustomBlendables = index + 1;
+ }
+ switch (index)
+ {
+ case 0: mCustom0 = b; break;
+ case 1: mCustom1 = b; break;
+ case 2: mCustom2 = b; break;
+ case 3: mCustom3 = b; break;
+ default:
+ {
+ if (m_CustomOverflow == null)
+ m_CustomOverflow = new List<CustomBlendable>();
+ m_CustomOverflow.Add(b);
+ break;
+ }
+ }
+ }
+
+ /// <summary>Intelligently blend the contents of two states.</summary>
+ /// <param name="stateA">The first state, corresponding to t=0</param>
+ /// <param name="stateB">The second state, corresponding to t=1</param>
+ /// <param name="t">How much to interpolate. Internally clamped to 0..1</param>
+ /// <returns>Linearly interpolated CameraState</returns>
+ public static CameraState Lerp(CameraState stateA, CameraState stateB, float t)
+ {
+ t = Mathf.Clamp01(t);
+ float adjustedT = t;
+
+ CameraState state = new CameraState();
+
+ // Combine the blend hints intelligently
+ if (((stateA.BlendHint & stateB.BlendHint) & BlendHintValue.NoPosition) != 0)
+ state.BlendHint |= BlendHintValue.NoPosition;
+ if (((stateA.BlendHint & stateB.BlendHint) & BlendHintValue.NoOrientation) != 0)
+ state.BlendHint |= BlendHintValue.NoOrientation;
+ if (((stateA.BlendHint & stateB.BlendHint) & BlendHintValue.NoLens) != 0)
+ state.BlendHint |= BlendHintValue.NoLens;
+ if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.SphericalPositionBlend) != 0)
+ state.BlendHint |= BlendHintValue.SphericalPositionBlend;
+ if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.CylindricalPositionBlend) != 0)
+ state.BlendHint |= BlendHintValue.CylindricalPositionBlend;
+
+ if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.NoLens) == 0)
+ state.Lens = LensSettings.Lerp(stateA.Lens, stateB.Lens, t);
+ else if (((stateA.BlendHint & stateB.BlendHint) & BlendHintValue.NoLens) == 0)
+ {
+ if ((stateA.BlendHint & BlendHintValue.NoLens) != 0)
+ state.Lens = stateB.Lens;
+ else
+ state.Lens = stateA.Lens;
+ }
+ state.ReferenceUp = Vector3.Slerp(stateA.ReferenceUp, stateB.ReferenceUp, t);
+ state.ShotQuality = Mathf.Lerp(stateA.ShotQuality, stateB.ShotQuality, t);
+
+ state.PositionCorrection = ApplyPosBlendHint(
+ stateA.PositionCorrection, stateA.BlendHint,
+ stateB.PositionCorrection, stateB.BlendHint,
+ state.PositionCorrection,
+ Vector3.Lerp(stateA.PositionCorrection, stateB.PositionCorrection, t));
+
+ state.OrientationCorrection = ApplyRotBlendHint(
+ stateA.OrientationCorrection, stateA.BlendHint,
+ stateB.OrientationCorrection, stateB.BlendHint,
+ state.OrientationCorrection,
+ Quaternion.Slerp(stateA.OrientationCorrection, stateB.OrientationCorrection, t));
+
+ // LookAt target
+ if (!stateA.HasLookAt || !stateB.HasLookAt)
+ state.ReferenceLookAt = kNoPoint;
+ else
+ {
+ // Re-interpolate FOV to preserve target composition, if possible
+ float fovA = stateA.Lens.FieldOfView;
+ float fovB = stateB.Lens.FieldOfView;
+ if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.NoLens) == 0
+ && !state.Lens.Orthographic && !Mathf.Approximately(fovA, fovB))
+ {
+ LensSettings lens = state.Lens;
+ lens.FieldOfView = InterpolateFOV(
+ fovA, fovB,
+ Mathf.Max((stateA.ReferenceLookAt - stateA.CorrectedPosition).magnitude, stateA.Lens.NearClipPlane),
+ Mathf.Max((stateB.ReferenceLookAt - stateB.CorrectedPosition).magnitude, stateB.Lens.NearClipPlane), t);
+ state.Lens = lens;
+
+ // Make sure we preserve the screen composition through FOV changes
+ adjustedT = Mathf.Abs((lens.FieldOfView - fovA) / (fovB - fovA));
+ }
+
+ // Linear interpolation of lookAt target point
+ state.ReferenceLookAt = Vector3.Lerp(
+ stateA.ReferenceLookAt, stateB.ReferenceLookAt, adjustedT);
+ }
+
+ // Raw position
+ state.RawPosition = ApplyPosBlendHint(
+ stateA.RawPosition, stateA.BlendHint,
+ stateB.RawPosition, stateB.BlendHint,
+ state.RawPosition, state.InterpolatePosition(
+ stateA.RawPosition, stateA.ReferenceLookAt,
+ stateB.RawPosition, stateB.ReferenceLookAt,
+ t));
+
+ // Interpolate the LookAt in Screen Space if requested
+ if (state.HasLookAt
+ && ((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.RadialAimBlend) != 0)
+ {
+ state.ReferenceLookAt = state.RawPosition + Vector3.Slerp(
+ stateA.ReferenceLookAt - state.RawPosition,
+ stateB.ReferenceLookAt - state.RawPosition, adjustedT);
+ }
+
+ // Clever orientation interpolation
+ Quaternion newOrient = state.RawOrientation;
+ if (((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.NoOrientation) == 0)
+ {
+ Vector3 dirTarget = Vector3.zero;
+ if (state.HasLookAt)//&& ((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.RadialAimBlend) == 0)
+ {
+ // If orientations are different, use LookAt to blend them
+ float angle = Quaternion.Angle(stateA.RawOrientation, stateB.RawOrientation);
+ if (angle > UnityVectorExtensions.Epsilon)
+ dirTarget = state.ReferenceLookAt - state.CorrectedPosition;
+ }
+ if (dirTarget.AlmostZero()
+ || ((stateA.BlendHint | stateB.BlendHint) & BlendHintValue.IgnoreLookAtTarget) != 0)
+ {
+ // Don't know what we're looking at - can only slerp
+ newOrient = UnityQuaternionExtensions.SlerpWithReferenceUp(
+ stateA.RawOrientation, stateB.RawOrientation, t, state.ReferenceUp);
+ }
+ else
+ {
+ // Rotate while preserving our lookAt target
+ dirTarget = dirTarget.normalized;
+ if ((dirTarget - state.ReferenceUp).AlmostZero()
+ || (dirTarget + state.ReferenceUp).AlmostZero())
+ {
+ // Looking up or down at the pole
+ newOrient = UnityQuaternionExtensions.SlerpWithReferenceUp(
+ stateA.RawOrientation, stateB.RawOrientation, t, state.ReferenceUp);
+ }
+ else
+ {
+ // Put the target in the center
+ newOrient = Quaternion.LookRotation(dirTarget, state.ReferenceUp);
+
+ // Blend the desired offsets from center
+ Vector2 deltaA = -stateA.RawOrientation.GetCameraRotationToTarget(
+ stateA.ReferenceLookAt - stateA.CorrectedPosition, stateA.ReferenceUp);
+ Vector2 deltaB = -stateB.RawOrientation.GetCameraRotationToTarget(
+ stateB.ReferenceLookAt - stateB.CorrectedPosition, stateB.ReferenceUp);
+ newOrient = newOrient.ApplyCameraRotation(
+ Vector2.Lerp(deltaA, deltaB, adjustedT), state.ReferenceUp);
+ }
+ }
+ }
+ state.RawOrientation = ApplyRotBlendHint(
+ stateA.RawOrientation, stateA.BlendHint,
+ stateB.RawOrientation, stateB.BlendHint,
+ state.RawOrientation, newOrient);
+
+ // Accumulate the custom blendables and apply the weights
+ for (int i = 0; i < stateA.NumCustomBlendables; ++i)
+ {
+ CustomBlendable b = stateA.GetCustomBlendable(i);
+ b.m_Weight *= (1-t);
+ if (b.m_Weight > UnityVectorExtensions.Epsilon)
+ state.AddCustomBlendable(b);
+ }
+ for (int i = 0; i < stateB.NumCustomBlendables; ++i)
+ {
+ CustomBlendable b = stateB.GetCustomBlendable(i);
+ b.m_Weight *= t;
+ if (b.m_Weight > UnityVectorExtensions.Epsilon)
+ state.AddCustomBlendable(b);
+ }
+ return state;
+ }
+
+ static float InterpolateFOV(float fovA, float fovB, float dA, float dB, float t)
+ {
+ // We interpolate shot height
+ float hA = dA * 2f * Mathf.Tan(fovA * Mathf.Deg2Rad / 2f);
+ float hB = dB * 2f * Mathf.Tan(fovB * Mathf.Deg2Rad / 2f);
+ float h = Mathf.Lerp(hA, hB, t);
+ float fov = 179f;
+ float d = Mathf.Lerp(dA, dB, t);
+ if (d > UnityVectorExtensions.Epsilon)
+ fov = 2f * Mathf.Atan(h / (2 * d)) * Mathf.Rad2Deg;
+ return Mathf.Clamp(fov, Mathf.Min(fovA, fovB), Mathf.Max(fovA, fovB));
+ }
+
+ static Vector3 ApplyPosBlendHint(
+ Vector3 posA, BlendHintValue hintA,
+ Vector3 posB, BlendHintValue hintB,
+ Vector3 original, Vector3 blended)
+ {
+ if (((hintA | hintB) & BlendHintValue.NoPosition) == 0)
+ return blended;
+ if (((hintA & hintB) & BlendHintValue.NoPosition) != 0)
+ return original;
+ if ((hintA & BlendHintValue.NoPosition) != 0)
+ return posB;
+ return posA;
+ }
+
+ static Quaternion ApplyRotBlendHint(
+ Quaternion rotA, BlendHintValue hintA,
+ Quaternion rotB, BlendHintValue hintB,
+ Quaternion original, Quaternion blended)
+ {
+ if (((hintA | hintB) & BlendHintValue.NoOrientation) == 0)
+ return blended;
+ if (((hintA & hintB) & BlendHintValue.NoOrientation) != 0)
+ return original;
+ if ((hintA & BlendHintValue.NoOrientation) != 0)
+ return rotB;
+ return rotA;
+ }
+
+ Vector3 InterpolatePosition(
+ Vector3 posA, Vector3 pivotA,
+ Vector3 posB, Vector3 pivotB,
+ float t)
+ {
+ #pragma warning disable 1718 // comparison made to same variable
+ if (pivotA == pivotA && pivotB == pivotB) // check for NaN
+ {
+ if ((BlendHint & BlendHintValue.CylindricalPositionBlend) != 0)
+ {
+ // Cylindrical interpolation about pivot
+ var a = Vector3.ProjectOnPlane(posA - pivotA, ReferenceUp);
+ var b = Vector3.ProjectOnPlane(posB - pivotB, ReferenceUp);
+ var c = Vector3.Slerp(a, b, t);
+ posA = (posA - a) + c;
+ posB = (posB - b) + c;
+ }
+ else if ((BlendHint & BlendHintValue.SphericalPositionBlend) != 0)
+ {
+ // Spherical interpolation about pivot
+ var c = Vector3.Slerp(posA - pivotA, posB - pivotB, t);
+ posA = pivotA + c;
+ posB = pivotB + c;
+ }
+ }
+ return Vector3.Lerp(posA, posB, t);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: c2a918f460a69394eb9726b31e1d404c
+timeCreated: 1488314898
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using System;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Describes a blend between 2 Cinemachine Virtual Cameras, and holds the
+ /// current state of the blend.
+ /// </summary>
+ public class CinemachineBlend
+ {
+ /// <summary>First camera in the blend</summary>
+ public ICinemachineCamera CamA { get; set; }
+
+ /// <summary>Second camera in the blend</summary>
+ public ICinemachineCamera CamB { get; set; }
+
+ /// <summary>The curve that describes the way the blend transitions over time
+ /// from the first camera to the second. X-axis is normalized time (0...1) over which
+ /// the blend takes place and Y axis is blend weight (0..1)</summary>
+ public AnimationCurve BlendCurve { get; set; }
+
+ /// <summary>The current time relative to the start of the blend</summary>
+ public float TimeInBlend { get; set; }
+
+ /// <summary>The current weight of the blend. This is an evaluation of the
+ /// BlendCurve at the current time relative to the start of the blend.
+ /// 0 means camA, 1 means camB.</summary>
+ public float BlendWeight
+ {
+ get
+ {
+ if (BlendCurve == null || BlendCurve.length < 2 || IsComplete)
+ return 1;
+ return Mathf.Clamp01(BlendCurve.Evaluate(TimeInBlend / Duration));
+ }
+ }
+
+ /// <summary>Validity test for the blend. True if either camera is defined.</summary>
+ public bool IsValid { get { return ((CamA != null && CamA.IsValid) || (CamB != null && CamB.IsValid)); } }
+
+ /// <summary>Duration in seconds of the blend.</summary>
+ public float Duration { get; set; }
+
+ /// <summary>True if the time relative to the start of the blend is greater
+ /// than or equal to the blend duration</summary>
+ public bool IsComplete { get { return TimeInBlend >= Duration || !IsValid; } }
+
+ /// <summary>Text description of the blend, for debugging</summary>
+ public string Description
+ {
+ get
+ {
+ var sb = CinemachineDebug.SBFromPool();
+ if (CamB == null || !CamB.IsValid)
+ sb.Append("(none)");
+ else
+ {
+ sb.Append("[");
+ sb.Append(CamB.Name);
+ sb.Append("]");
+ }
+ sb.Append(" ");
+ sb.Append((int)(BlendWeight * 100f));
+ sb.Append("% from ");
+ if (CamA == null || !CamA.IsValid)
+ sb.Append("(none)");
+ else
+ {
+ sb.Append("[");
+ sb.Append(CamA.Name);
+ sb.Append("]");
+ }
+ string text = sb.ToString();
+ CinemachineDebug.ReturnToPool(sb);
+ return text;
+ }
+ }
+
+ /// <summary>Does the blend use a specific Cinemachine Virtual Camera?</summary>
+ /// <param name="cam">The camera to test</param>
+ /// <returns>True if the camera is involved in the blend</returns>
+ public bool Uses(ICinemachineCamera cam)
+ {
+ if (cam == CamA || cam == CamB)
+ return true;
+ BlendSourceVirtualCamera b = CamA as BlendSourceVirtualCamera;
+ if (b != null && b.Blend.Uses(cam))
+ return true;
+ b = CamB as BlendSourceVirtualCamera;
+ if (b != null && b.Blend.Uses(cam))
+ return true;
+ return false;
+ }
+
+ /// <summary>Construct a blend</summary>
+ /// <param name="a">First camera</param>
+ /// <param name="b">Second camera</param>
+ /// <param name="curve">Blend curve</param>
+ /// <param name="duration">Duration of the blend, in seconds</param>
+ /// <param name="t">Current time in blend, relative to the start of the blend</param>
+ public CinemachineBlend(
+ ICinemachineCamera a, ICinemachineCamera b, AnimationCurve curve, float duration, float t)
+ {
+ CamA = a;
+ CamB = b;
+ BlendCurve = curve;
+ TimeInBlend = t;
+ Duration = duration;
+ }
+
+ /// <summary>Make sure the source cameras get updated.</summary>
+ /// <param name="worldUp">Default world up. Individual vcams may modify this</param>
+ /// <param name="deltaTime">Time increment used for calculating time-based behaviours (e.g. damping)</param>
+ public void UpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ // Make sure both cameras have been updated (they are not necessarily
+ // enabled, and only enabled cameras get updated automatically
+ // every frame)
+ if (CamA != null && CamA.IsValid)
+ CamA.UpdateCameraState(worldUp, deltaTime);
+ if (CamB != null && CamB.IsValid)
+ CamB.UpdateCameraState(worldUp, deltaTime);
+ }
+
+ /// <summary>Compute the blended CameraState for the current time in the blend.</summary>
+ public CameraState State
+ {
+ get
+ {
+ if (CamA == null || !CamA.IsValid)
+ {
+ if (CamB == null || !CamB.IsValid)
+ return CameraState.Default;
+ return CamB.State;
+ }
+ if (CamB == null || !CamB.IsValid)
+ return CamA.State;
+ return CameraState.Lerp(CamA.State, CamB.State, BlendWeight);
+ }
+ }
+ }
+
+ /// <summary>Definition of a Camera blend. This struct holds the information
+ /// necessary to generate a suitable AnimationCurve for a Cinemachine Blend.</summary>
+ [Serializable]
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public struct CinemachineBlendDefinition
+ {
+ /// <summary>Supported predefined shapes for the blend curve.</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public enum Style
+ {
+ /// <summary>Zero-length blend</summary>
+ Cut,
+ /// <summary>S-shaped curve, giving a gentle and smooth transition</summary>
+ EaseInOut,
+ /// <summary>Linear out of the outgoing shot, and easy into the incoming</summary>
+ EaseIn,
+ /// <summary>Easy out of the outgoing shot, and linear into the incoming</summary>
+ EaseOut,
+ /// <summary>Easy out of the outgoing, and hard into the incoming</summary>
+ HardIn,
+ /// <summary>Hard out of the outgoing, and easy into the incoming</summary>
+ HardOut,
+ /// <summary>Linear blend. Mechanical-looking.</summary>
+ Linear,
+ /// <summary>Custom blend curve.</summary>
+ Custom
+ };
+
+ /// <summary>The shape of the blend curve.</summary>
+ [Tooltip("Shape of the blend curve")]
+ public Style m_Style;
+
+ /// <summary>The duration (in seconds) of the blend</summary>
+ [Tooltip("Duration of the blend, in seconds")]
+ public float m_Time;
+
+ /// <summary>Constructor</summary>
+ /// <param name="style">The shape of the blend curve.</param>
+ /// <param name="time">The duration (in seconds) of the blend</param>
+ public CinemachineBlendDefinition(Style style, float time)
+ {
+ m_Style = style;
+ m_Time = time;
+ m_CustomCurve = null;
+ }
+
+ /// <summary>
+ /// A user-defined AnimationCurve, used only if style is Custom.
+ /// Curve MUST be normalized, i.e. time range [0...1], value range [0...1].
+ /// </summary>
+ public AnimationCurve m_CustomCurve;
+
+ static AnimationCurve[] sStandardCurves;
+ void CreateStandardCurves()
+ {
+ sStandardCurves = new AnimationCurve[(int)Style.Custom];
+
+ sStandardCurves[(int)Style.Cut] = null;
+ sStandardCurves[(int)Style.EaseInOut] = AnimationCurve.EaseInOut(0f, 0f, 1, 1f);
+
+ sStandardCurves[(int)Style.EaseIn] = AnimationCurve.Linear(0f, 0f, 1, 1f);
+ Keyframe[] keys = sStandardCurves[(int)Style.EaseIn].keys;
+ keys[1].inTangent = 0;
+ sStandardCurves[(int)Style.EaseIn].keys = keys;
+
+ sStandardCurves[(int)Style.EaseOut] = AnimationCurve.Linear(0f, 0f, 1, 1f);
+ keys = sStandardCurves[(int)Style.EaseOut].keys;
+ keys[0].outTangent = 0;
+ sStandardCurves[(int)Style.EaseOut].keys = keys;
+
+ sStandardCurves[(int)Style.HardIn] = AnimationCurve.Linear(0f, 0f, 1, 1f);
+ keys = sStandardCurves[(int)Style.HardIn].keys;
+ keys[0].outTangent = 0;
+ keys[1].inTangent = 1.5708f; // pi/2 = up
+ sStandardCurves[(int)Style.HardIn].keys = keys;
+
+ sStandardCurves[(int)Style.HardOut] = AnimationCurve.Linear(0f, 0f, 1, 1f);
+ keys = sStandardCurves[(int)Style.HardOut].keys;
+ keys[0].outTangent = 1.5708f; // pi/2 = up
+ keys[1].inTangent = 0;
+ sStandardCurves[(int)Style.HardOut].keys = keys;
+
+ sStandardCurves[(int)Style.Linear] = AnimationCurve.Linear(0f, 0f, 1, 1f);
+ }
+
+ /// <summary>
+ /// A normalized AnimationCurve specifying the interpolation curve
+ /// for this camera blend. Y-axis values must be in range [0,1] (internally clamped
+ /// within Blender) and time must be in range of [0, 1].
+ /// </summary>
+ public AnimationCurve BlendCurve
+ {
+ get
+ {
+ if (m_Style == Style.Custom)
+ {
+ if (m_CustomCurve == null)
+ m_CustomCurve = AnimationCurve.EaseInOut(0f, 0f, 1, 1f);
+ return m_CustomCurve;
+ }
+ if (sStandardCurves == null)
+ CreateStandardCurves();
+ return sStandardCurves[(int)m_Style];
+ }
+ }
+ }
+
+ /// <summary>
+ /// Point source for blending. It's not really a virtual camera, but takes
+ /// a CameraState and exposes it as a virtual camera for the purposes of blending.
+ /// </summary>
+ internal class StaticPointVirtualCamera : ICinemachineCamera
+ {
+ public StaticPointVirtualCamera(CameraState state, string name) { State = state; Name = name; }
+ public void SetState(CameraState state) { State = state; }
+
+ public string Name { get; private set; }
+ public string Description { get { return ""; }}
+ public int Priority { get; set; }
+ public Transform LookAt { get; set; }
+ public Transform Follow { get; set; }
+ public CameraState State { get; private set; }
+ public GameObject VirtualCameraGameObject { get { return null; } }
+ public bool IsValid { get { return true; } }
+ public ICinemachineCamera ParentCamera { get { return null; } }
+ public bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false) { return false; }
+ public void UpdateCameraState(Vector3 worldUp, float deltaTime) {}
+ public void InternalUpdateCameraState(Vector3 worldUp, float deltaTime) {}
+ public void OnTransitionFromCamera(ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime) {}
+ public void OnTargetObjectWarped(Transform target, Vector3 positionDelta) {}
+ }
+
+ /// <summary>
+ /// Blend result source for blending. This exposes a CinemachineBlend object
+ /// as an ersatz virtual camera for the purposes of blending. This achieves the purpose
+ /// of blending the result oif a blend.
+ /// </summary>
+ internal class BlendSourceVirtualCamera : ICinemachineCamera
+ {
+ public BlendSourceVirtualCamera(CinemachineBlend blend) { Blend = blend; }
+ public CinemachineBlend Blend { get; set; }
+
+ public string Name { get { return "Mid-blend"; }}
+ public string Description { get { return Blend == null ? "(null)" : Blend.Description; }}
+ public int Priority { get; set; }
+ public Transform LookAt { get; set; }
+ public Transform Follow { get; set; }
+ public CameraState State { get; private set; }
+ public GameObject VirtualCameraGameObject { get { return null; } }
+ public bool IsValid { get { return Blend != null && Blend.IsValid; } }
+ public ICinemachineCamera ParentCamera { get { return null; } }
+ public bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false)
+ { return Blend != null && (vcam == Blend.CamA || vcam == Blend.CamB); }
+ public CameraState CalculateNewState(float deltaTime) { return State; }
+ public void UpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ if (Blend != null)
+ {
+ Blend.UpdateCameraState(worldUp, deltaTime);
+ State = Blend.State;
+ }
+ }
+ public void InternalUpdateCameraState(Vector3 worldUp, float deltaTime) {}
+ public void OnTransitionFromCamera(ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime) {}
+ public void OnTargetObjectWarped(Transform target, Vector3 positionDelta) {}
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 3fed8968b96eb924891cf86f5c51f661
+timeCreated: 1484407000
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Asset that defines the rules for blending between Virtual Cameras.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public sealed class CinemachineBlenderSettings : ScriptableObject
+ {
+ /// <summary>
+ /// Container specifying how two specific Cinemachine Virtual Cameras
+ /// blend together.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct CustomBlend
+ {
+ [Tooltip("When blending from this camera")]
+ public string m_From;
+
+ [Tooltip("When blending to this camera")]
+ public string m_To;
+
+ [CinemachineBlendDefinitionProperty]
+ [Tooltip("Blend curve definition")]
+ public CinemachineBlendDefinition m_Blend;
+ }
+ /// <summary>The array containing explicitly defined blends between two Virtual Cameras</summary>
+ [Tooltip("The array containing explicitly defined blends between two Virtual Cameras")]
+ public CustomBlend[] m_CustomBlends = null;
+
+ /// <summary>Internal API for the inspector editopr: a label to represent any camera</summary>
+ public const string kBlendFromAnyCameraLabel = "**ANY CAMERA**";
+
+ /// <summary>
+ /// Attempts to find a blend definition which matches the to and from cameras as specified.
+ /// If no match is found, the function returns the supplied default blend.
+ /// </summary>
+ /// <param name="fromCameraName">The game object name of the from camera</param>
+ /// <param name="toCameraName">The game object name of the to camera</param>
+ /// <param name="defaultBlend">Blend to return if no custom blend found.</param>
+ /// <returns></returns>
+ public CinemachineBlendDefinition GetBlendForVirtualCameras(
+ string fromCameraName, string toCameraName, CinemachineBlendDefinition defaultBlend)
+ {
+ bool gotAnyToMe = false;
+ bool gotMeToAny = false;
+ CinemachineBlendDefinition anyToMe = defaultBlend;
+ CinemachineBlendDefinition meToAny = defaultBlend;
+ if (m_CustomBlends != null)
+ {
+ for (int i = 0; i < m_CustomBlends.Length; ++i)
+ {
+ // Attempt to find direct name first
+ CustomBlend blendParams = m_CustomBlends[i];
+ if ((blendParams.m_From == fromCameraName)
+ && (blendParams.m_To == toCameraName))
+ {
+ return blendParams.m_Blend;
+ }
+ // If we come across applicable wildcards, remember them
+ if (blendParams.m_From == kBlendFromAnyCameraLabel)
+ {
+ if (!string.IsNullOrEmpty(toCameraName)
+ && blendParams.m_To == toCameraName)
+ {
+ anyToMe = blendParams.m_Blend;
+ gotAnyToMe = true;
+ }
+ else if (blendParams.m_To == kBlendFromAnyCameraLabel)
+ defaultBlend = blendParams.m_Blend;
+ }
+ else if (blendParams.m_To == kBlendFromAnyCameraLabel
+ && !string.IsNullOrEmpty(fromCameraName)
+ && blendParams.m_From == fromCameraName)
+ {
+ meToAny = blendParams.m_Blend;
+ gotMeToAny = true;
+ }
+ }
+ }
+
+ // If nothing is found try to find wild card blends from any
+ // camera to our new one
+ if (gotAnyToMe)
+ return anyToMe;
+
+ // Still have nothing? Try from our camera to any camera
+ if (gotMeToAny)
+ return meToAny;
+
+ return defaultBlend;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 36baaa8bdcb9d8b49b9199833965d2c3
+timeCreated: 1486497606
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// An abstract representation of a mutator acting on a Cinemachine Virtual Camera
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.API)]
+ public abstract class CinemachineComponentBase : MonoBehaviour
+ {
+ /// <summary>Useful constant for very small floats</summary>
+ protected const float Epsilon = Utility.UnityVectorExtensions.Epsilon;
+
+ /// <summary>Get the associated CinemachineVirtualCameraBase</summary>
+ public CinemachineVirtualCameraBase VirtualCamera
+ {
+ get
+ {
+ if (m_vcamOwner == null)
+ m_vcamOwner = GetComponent<CinemachineVirtualCameraBase>();
+ if (m_vcamOwner == null && transform.parent != null)
+ m_vcamOwner = transform.parent.GetComponent<CinemachineVirtualCameraBase>();
+ return m_vcamOwner;
+ }
+ }
+ CinemachineVirtualCameraBase m_vcamOwner;
+
+ /// <summary>Returns the owner vcam's Follow target.</summary>
+ public Transform FollowTarget
+ {
+ get
+ {
+ CinemachineVirtualCameraBase vcam = VirtualCamera;
+ return vcam == null ? null : vcam.Follow;
+ }
+ }
+
+ /// <summary>Returns the owner vcam's LookAt target.</summary>
+ public Transform LookAtTarget
+ {
+ get
+ {
+ CinemachineVirtualCameraBase vcam = VirtualCamera;
+ return vcam == null ? null : vcam.LookAt;
+ }
+ }
+
+ private Transform mCachedFollowTarget;
+ private CinemachineVirtualCameraBase mCachedFollowTargetVcam;
+ private CinemachineTargetGroup mCachedFollowTargetGroup;
+
+ void UpdateFollowTargetCache()
+ {
+ mCachedFollowTargetVcam = null;
+ mCachedFollowTargetGroup = null;
+ mCachedFollowTarget = FollowTarget;
+ if (mCachedFollowTarget != null)
+ {
+ mCachedFollowTargetVcam = mCachedFollowTarget.GetComponent<CinemachineVirtualCameraBase>();
+ mCachedFollowTargetGroup = mCachedFollowTarget.GetComponent<CinemachineTargetGroup>();
+ }
+ }
+
+ /// <summary>Get Follow target as CinemachineTargetGroup, or null if target is not a group</summary>
+ public CinemachineTargetGroup FollowTargetGroup
+ {
+ get
+ {
+ if (FollowTarget != mCachedFollowTarget)
+ UpdateFollowTargetCache();
+ return mCachedFollowTargetGroup;
+ }
+ }
+
+ /// <summary>Get the position of the Follow target. Special handling: If the Follow target is
+ /// a VirtualCamera, returns the vcam State's position, not the transform's position</summary>
+ public Vector3 FollowTargetPosition
+ {
+ get
+ {
+ Transform target = FollowTarget;
+ if (target != mCachedFollowTarget)
+ UpdateFollowTargetCache();
+ if (mCachedFollowTargetVcam != null)
+ return mCachedFollowTargetVcam.State.FinalPosition;
+ if (target != null)
+ return target.position;
+ return Vector3.zero;
+ }
+ }
+
+ /// <summary>Get the rotation of the Follow target. Special handling: If the Follow target is
+ /// a VirtualCamera, returns the vcam State's rotation, not the transform's rotation</summary>
+ public Quaternion FollowTargetRotation
+ {
+ get
+ {
+ Transform target = FollowTarget;
+ if (target != mCachedFollowTarget)
+ {
+ mCachedFollowTargetVcam = null;
+ mCachedFollowTarget = target;
+ if (target != null)
+ mCachedFollowTargetVcam = target.GetComponent<CinemachineVirtualCameraBase>();
+ }
+ if (mCachedFollowTargetVcam != null)
+ return mCachedFollowTargetVcam.State.FinalOrientation;
+ if (target != null)
+ return target.rotation;
+ return Quaternion.identity;
+ }
+ }
+
+ private Transform mCachedLookAtTarget;
+ private CinemachineVirtualCameraBase mCachedLookAtTargetVcam;
+ private CinemachineTargetGroup mCachedLookAtTargetGroup;
+
+ void UpdateLookAtTargetCache()
+ {
+ mCachedLookAtTargetVcam = null;
+ mCachedLookAtTargetGroup = null;
+ mCachedLookAtTarget = LookAtTarget;
+ if (mCachedLookAtTarget != null)
+ {
+ mCachedLookAtTargetVcam = mCachedLookAtTarget.GetComponent<CinemachineVirtualCameraBase>();
+ mCachedLookAtTargetGroup = mCachedLookAtTarget.GetComponent<CinemachineTargetGroup>();
+ }
+ }
+
+ /// <summary>Get LookAt target as CinemachineTargetGroup, or null if target is not a group</summary>
+ public CinemachineTargetGroup LookAtTargetGroup
+ {
+ get
+ {
+ if (LookAtTarget != mCachedLookAtTarget)
+ UpdateLookAtTargetCache();
+ return mCachedLookAtTargetGroup;
+ }
+ }
+
+ /// <summary>Get the position of the LookAt target. Special handling: If the LookAt target is
+ /// a VirtualCamera, returns the vcam State's position, not the transform's position</summary>
+ public Vector3 LookAtTargetPosition
+ {
+ get
+ {
+ Transform target = LookAtTarget;
+ if (target != mCachedLookAtTarget)
+ UpdateLookAtTargetCache();
+ if (mCachedLookAtTargetVcam != null)
+ return mCachedLookAtTargetVcam.State.FinalPosition;
+ if (target != null)
+ return target.position;
+ return Vector3.zero;
+ }
+ }
+
+ /// <summary>Get the rotation of the LookAt target. Special handling: If the LookAt target is
+ /// a VirtualCamera, returns the vcam State's rotation, not the transform's rotation</summary>
+ public Quaternion LookAtTargetRotation
+ {
+ get
+ {
+ Transform target = LookAtTarget;
+ if (target != mCachedLookAtTarget)
+ UpdateLookAtTargetCache();
+ if (mCachedLookAtTargetVcam != null)
+ return mCachedLookAtTargetVcam.State.FinalOrientation;
+ if (target != null)
+ return target.rotation;
+ return Quaternion.identity;
+ }
+ }
+
+ /// <summary>Returns the owner vcam's CameraState.</summary>
+ public CameraState VcamState
+ {
+ get
+ {
+ CinemachineVirtualCameraBase vcam = VirtualCamera;
+ return vcam == null ? CameraState.Default : vcam.State;
+ }
+ }
+
+ /// <summary>Returns true if this object is enabled and set up to produce results.</summary>
+ public abstract bool IsValid { get; }
+
+ /// <summary>Override this to do such things as offset the RefereceLookAt.
+ /// Base class implementation does nothing.</summary>
+ /// <param name="curState">Input state that must be mutated</param>
+ public virtual void PrePipelineMutateCameraState(ref CameraState curState, float deltaTime) {}
+
+ /// <summary>What part of the pipeline this fits into</summary>
+ public abstract CinemachineCore.Stage Stage { get; }
+
+ /// <summary>Mutates the camera state. This state will later be applied to the camera.</summary>
+ /// <param name="curState">Input state that must be mutated</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ public abstract void MutateCameraState(ref CameraState curState, float deltaTime);
+
+ /// <summary>Notification that this virtual camera is going live.
+ /// Base class implementation does nothing.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ /// <returns>True if the vcam should do an internal update as a result of this call</returns>
+ public virtual bool OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime,
+ ref CinemachineVirtualCameraBase.TransitionParams transitionParams)
+ { return false; }
+
+ /// <summary>This is called to notify the component that a target got warped,
+ /// so that the component can update its internal state to make the camera
+ /// also warp seamlessy. Base class implementation does nothing.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public virtual void OnTargetObjectWarped(Transform target, Vector3 positionDelta) {}
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: b2f73bdc979030e419f33c10913639cc
+timeCreated: 1510078351
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Cinemachine
+{
+ /// <summary>A singleton that manages complete lists of CinemachineBrain and,
+ /// Cinemachine Virtual Cameras, and the priority queue. Provides
+ /// services to keeping track of whether Cinemachine Virtual Cameras have
+ /// been updated each frame.</summary>
+ public sealed class CinemachineCore
+ {
+ /// <summary>Data version string. Used to upgrade from legacy projects</summary>
+ public static readonly int kStreamingVersion = 20170927;
+
+ /// <summary>Human-readable Cinemachine Version</summary>
+ public static readonly string kVersionString = "2.3.4";
+
+ /// <summary>
+ /// Stages in the Cinemachine Component pipeline, used for
+ /// UI organization>. This enum defines the pipeline order.
+ /// </summary>
+ public enum Stage
+ {
+ /// <summary>Second stage: position the camera in space</summary>
+ Body,
+
+ /// <summary>Third stage: orient the camera to point at the target</summary>
+ Aim,
+
+ /// <summary>Final pipeline stage: apply noise (this is done separately, in the
+ /// Correction channel of the CameraState)</summary>
+ Noise,
+
+ /// <summary>Not a pipeline stage. This is invoked on all virtual camera
+ /// types, after the pipeline is complete</summary>
+ Finalize
+ };
+
+ private static CinemachineCore sInstance = null;
+
+ /// <summary>Get the singleton instance</summary>
+ public static CinemachineCore Instance
+ {
+ get
+ {
+ if (sInstance == null)
+ sInstance = new CinemachineCore();
+ return sInstance;
+ }
+ }
+
+ /// <summary>
+ /// If true, show hidden Cinemachine objects, to make manual script mapping possible.
+ /// </summary>
+ public static bool sShowHiddenObjects = false;
+
+ /// <summary>Delegate for overriding Unity's default input system. Returns the value
+ /// of the named axis.</summary>
+ public delegate float AxisInputDelegate(string axisName);
+
+ /// <summary>Delegate for overriding Unity's default input system.
+ /// If you set this, then your delegate will be called instead of
+ /// System.Input.GetAxis(axisName) whenever in-game user input is needed.</summary>
+ public static AxisInputDelegate GetInputAxis = UnityEngine.Input.GetAxis;
+
+ /// <summary>
+ /// Delegate for overriding a blend that is about to be applied to a transition.
+ /// A handler can either return the default blend, or a new blend specific to
+ /// current conditions.
+ /// </summary>
+ /// <param name="fromVcam">The outgoing virtual camera</param>
+ /// <param name="toVcam">Yhe incoming virtual camera</param>
+ /// <param name="defaultBlend">The blend that would normally be applied</param>
+ /// <param name="owner">The context in which the blend is taking place.
+ /// Can be a CinemachineBrain, or CinemachineStateDrivenCamera, or other manager
+ /// object that can initiate a blend</param>
+ /// <returns>The blend definition to use for this transition.</returns>
+ public delegate CinemachineBlendDefinition GetBlendOverrideDelegate(
+ ICinemachineCamera fromVcam, ICinemachineCamera toVcam,
+ CinemachineBlendDefinition defaultBlend,
+ MonoBehaviour owner);
+
+ /// <summary>
+ /// Delegate for overriding a blend that is about to be applied to a transition.
+ /// A handler can either return the default blend, or a new blend specific to
+ /// current conditions.
+ /// </summary>
+ public static GetBlendOverrideDelegate GetBlendOverride;
+
+ /// <summary>This event will fire after a brain updates its Camera</summary>
+ public static CinemachineBrain.BrainEvent CameraUpdatedEvent = new CinemachineBrain.BrainEvent();
+
+ /// <summary>List of all active CinemachineBrains.</summary>
+ private List<CinemachineBrain> mActiveBrains = new List<CinemachineBrain>();
+
+ /// <summary>Access the array of active CinemachineBrains in the scene</summary>
+ public int BrainCount { get { return mActiveBrains.Count; } }
+
+ /// <summary>Access the array of active CinemachineBrains in the scene
+ /// without gebnerating garbage</summary>
+ /// <param name="index">Index of the brain to access, range 0-BrainCount</param>
+ /// <returns>The brain at the specified index</returns>
+ public CinemachineBrain GetActiveBrain(int index)
+ {
+ return mActiveBrains[index];
+ }
+
+ /// <summary>Called when a CinemachineBrain is enabled.</summary>
+ internal void AddActiveBrain(CinemachineBrain brain)
+ {
+ // First remove it, just in case it's being added twice
+ RemoveActiveBrain(brain);
+ mActiveBrains.Insert(0, brain);
+ }
+
+ /// <summary>Called when a CinemachineBrain is disabled.</summary>
+ internal void RemoveActiveBrain(CinemachineBrain brain)
+ {
+ mActiveBrains.Remove(brain);
+ }
+
+ /// <summary>List of all active ICinemachineCameras.</summary>
+ private List<CinemachineVirtualCameraBase> mActiveCameras = new List<CinemachineVirtualCameraBase>();
+
+ /// <summary>
+ /// List of all active Cinemachine Virtual Cameras for all brains.
+ /// This list is kept sorted by priority.
+ /// </summary>
+ public int VirtualCameraCount { get { return mActiveCameras.Count; } }
+
+ /// <summary>Access the array of active ICinemachineCamera in the scene
+ /// without gebnerating garbage</summary>
+ /// <param name="index">Index of the camera to access, range 0-VirtualCameraCount</param>
+ /// <returns>The virtual camera at the specified index</returns>
+ public CinemachineVirtualCameraBase GetVirtualCamera(int index)
+ {
+ return mActiveCameras[index];
+ }
+
+ /// <summary>Called when a Cinemachine Virtual Camera is enabled.</summary>
+ internal void AddActiveCamera(CinemachineVirtualCameraBase vcam)
+ {
+ // Bring it to the top of the list
+ RemoveActiveCamera(vcam);
+
+ // Keep list sorted by priority
+ int insertIndex;
+ for (insertIndex = 0; insertIndex < mActiveCameras.Count; ++insertIndex)
+ if (vcam.Priority >= mActiveCameras[insertIndex].Priority)
+ break;
+
+ mActiveCameras.Insert(insertIndex, vcam);
+ }
+
+ /// <summary>Called when a Cinemachine Virtual Camera is disabled.</summary>
+ internal void RemoveActiveCamera(CinemachineVirtualCameraBase vcam)
+ {
+ mActiveCameras.Remove(vcam);
+ }
+
+ // Registry of all vcams that are present, active or not
+ private List<List<CinemachineVirtualCameraBase>> mAllCameras
+ = new List<List<CinemachineVirtualCameraBase>>();
+
+ /// <summary>Called when a vcam is awakened.</summary>
+ internal void CameraAwakened(CinemachineVirtualCameraBase vcam)
+ {
+ int parentLevel = 0;
+ for (ICinemachineCamera p = vcam.ParentCamera; p != null; p = p.ParentCamera)
+ ++parentLevel;
+ while (mAllCameras.Count <= parentLevel)
+ mAllCameras.Add(new List<CinemachineVirtualCameraBase>());
+ mAllCameras[parentLevel].Add(vcam);
+ }
+
+ /// <summary>Called when a vcam is destroyed.</summary>
+ internal void CameraDestroyed(CinemachineVirtualCameraBase vcam)
+ {
+ for (int i = 0; i < mAllCameras.Count; ++i)
+ mAllCameras[i].Remove(vcam);
+ }
+
+ CinemachineVirtualCameraBase mRoundRobinVcamLastFrame = null;
+
+ static float mLastUpdateTime;
+ static int FixedFrameCount { get; set; } // Current fixed frame count
+
+ /// <summary>Update all the active vcams in the scene, in the correct dependency order.</summary>
+ internal void UpdateAllActiveVirtualCameras(int layerMask, Vector3 worldUp, float deltaTime)
+ {
+ // Setup for roundRobin standby updating
+ var filter = CurrentUpdateFilter;
+ bool canUpdateStandby = (filter != UpdateFilter.SmartFixed); // never in smart fixed
+ CinemachineVirtualCameraBase currentRoundRobin = mRoundRobinVcamLastFrame;
+
+ // Update the fixed frame count
+ float now = Time.time;
+ if (now != mLastUpdateTime)
+ {
+ mLastUpdateTime = now;
+ if ((filter & ~UpdateFilter.Smart) == UpdateFilter.Fixed)
+ ++FixedFrameCount;
+ }
+
+ // Update the leaf-most cameras first
+ for (int i = mAllCameras.Count-1; i >= 0; --i)
+ {
+ var sublist = mAllCameras[i];
+ for (int j = sublist.Count - 1; j >= 0; --j)
+ {
+ var vcam = sublist[j];
+ if (canUpdateStandby && vcam == mRoundRobinVcamLastFrame)
+ currentRoundRobin = null; // update the next roundrobin candidate
+ if (vcam == null)
+ {
+ sublist.RemoveAt(j);
+ continue; // deleted
+ }
+ if (vcam.m_StandbyUpdate == CinemachineVirtualCameraBase.StandbyUpdateMode.Always
+ || IsLive(vcam))
+ {
+ // Skip this vcam if it's not on the layer mask
+ if (((1 << vcam.gameObject.layer) & layerMask) != 0)
+ UpdateVirtualCamera(vcam, worldUp, deltaTime);
+ }
+ else if (currentRoundRobin == null
+ && mRoundRobinVcamLastFrame != vcam
+ && canUpdateStandby
+ && vcam.m_StandbyUpdate != CinemachineVirtualCameraBase.StandbyUpdateMode.Never
+ && vcam.isActiveAndEnabled)
+ {
+ // Do the round-robin update
+ CurrentUpdateFilter &= ~UpdateFilter.Smart; // force it
+ UpdateVirtualCamera(vcam, worldUp, deltaTime);
+ CurrentUpdateFilter = filter;
+ currentRoundRobin = vcam;
+ }
+ }
+ }
+
+ // Did we manage to update a roundrobin?
+ if (canUpdateStandby)
+ {
+ if (currentRoundRobin == mRoundRobinVcamLastFrame)
+ currentRoundRobin = null; // take the first candidate
+ mRoundRobinVcamLastFrame = currentRoundRobin;
+ }
+ }
+
+ /// <summary>
+ /// Update a single Cinemachine Virtual Camera if and only if it
+ /// hasn't already been updated this frame. Always update vcams via this method.
+ /// Calling this more than once per frame for the same camera will have no effect.
+ /// </summary>
+ internal void UpdateVirtualCamera(
+ CinemachineVirtualCameraBase vcam, Vector3 worldUp, float deltaTime)
+ {
+ if (vcam == null)
+ return;
+
+ bool isSmartUpdate = (CurrentUpdateFilter & UpdateFilter.Smart) == UpdateFilter.Smart;
+ UpdateTracker.UpdateClock updateClock
+ = (UpdateTracker.UpdateClock)(CurrentUpdateFilter & ~UpdateFilter.Smart);
+
+ // If we're in smart update mode and the target moved, then we must examine
+ // how the target has been moving recently in order to figure out whether to
+ // update now
+ if (isSmartUpdate)
+ {
+ Transform updateTarget = GetUpdateTarget(vcam);
+ if (updateTarget == null)
+ return; // vcam deleted
+ if (UpdateTracker.GetPreferredUpdate(updateTarget) != updateClock)
+ return; // wrong clock
+ }
+
+ // Have we already been updated this frame?
+ if (mUpdateStatus == null)
+ mUpdateStatus = new Dictionary<CinemachineVirtualCameraBase, UpdateStatus>();
+ UpdateStatus status;
+ if (!mUpdateStatus.TryGetValue(vcam, out status))
+ {
+ status = new UpdateStatus();
+ mUpdateStatus.Add(vcam, status);
+ }
+ int frameDelta = (updateClock == UpdateTracker.UpdateClock.Late)
+ ? Time.frameCount - status.lastUpdateFrame
+ : FixedFrameCount - status.lastUpdateFixedFrame;
+ if (deltaTime >= 0)
+ {
+ if (frameDelta == 0 && status.lastUpdateMode == updateClock)
+ return; // already updated
+ if (frameDelta > 0)
+ deltaTime *= frameDelta; // try to catch up if multiple frames
+ }
+//Debug.Log((vcam.ParentCamera == null ? "" : vcam.ParentCamera.Name + ".") + vcam.Name + ": frame " + Time.frameCount + "/" + status.lastUpdateFixedFrame + ", " + CurrentUpdateFilter + ", deltaTime = " + deltaTime);
+ vcam.InternalUpdateCameraState(worldUp, deltaTime);
+ status.lastUpdateFrame = Time.frameCount;
+ status.lastUpdateFixedFrame = FixedFrameCount;
+ status.lastUpdateMode = updateClock;
+ }
+
+ class UpdateStatus
+ {
+ public int lastUpdateFrame;
+ public int lastUpdateFixedFrame;
+ public UpdateTracker.UpdateClock lastUpdateMode;
+ public UpdateStatus()
+ {
+ lastUpdateFrame = -2;
+ lastUpdateFixedFrame = 0;
+ lastUpdateMode = UpdateTracker.UpdateClock.Late;
+ }
+ }
+ static Dictionary<CinemachineVirtualCameraBase, UpdateStatus> mUpdateStatus;
+
+ [RuntimeInitializeOnLoadMethod]
+ static void InitializeModule()
+ {
+ mUpdateStatus = new Dictionary<CinemachineVirtualCameraBase, UpdateStatus>();
+ }
+
+ /// <summary>Internal use only</summary>
+ internal enum UpdateFilter
+ {
+ Fixed = UpdateTracker.UpdateClock.Fixed,
+ Late = UpdateTracker.UpdateClock.Late,
+ Smart = 8, // meant to be or'ed with the others
+ SmartFixed = Smart | Fixed,
+ SmartLate = Smart | Late
+ }
+ internal UpdateFilter CurrentUpdateFilter { get; set; }
+
+ private static Transform GetUpdateTarget(CinemachineVirtualCameraBase vcam)
+ {
+ if (vcam == null || vcam.gameObject == null)
+ return null;
+ Transform target = vcam.LookAt;
+ if (target != null)
+ return target;
+ target = vcam.Follow;
+ if (target != null)
+ return target;
+ // If no target, use the vcam itself
+ return vcam.transform;
+ }
+
+ /// <summary>Internal use only - inspector</summary>
+ internal UpdateTracker.UpdateClock GetVcamUpdateStatus(CinemachineVirtualCameraBase vcam)
+ {
+ UpdateStatus status;
+ if (mUpdateStatus == null || !mUpdateStatus.TryGetValue(vcam, out status))
+ return UpdateTracker.UpdateClock.Late;
+ return status.lastUpdateMode;
+ }
+
+ /// <summary>
+ /// Is this virtual camera currently actively controlling any Camera?
+ /// </summary>
+ public bool IsLive(ICinemachineCamera vcam)
+ {
+ if (vcam != null)
+ {
+ for (int i = 0; i < BrainCount; ++i)
+ {
+ CinemachineBrain b = GetActiveBrain(i);
+ if (b != null && b.IsLive(vcam))
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /// <summary>
+ /// Signal that the virtual has been activated.
+ /// If the camera is live, then all CinemachineBrains that are showing it will
+ /// send an activation event.
+ /// </summary>
+ public void GenerateCameraActivationEvent(ICinemachineCamera vcam, ICinemachineCamera vcamFrom)
+ {
+ if (vcam != null)
+ {
+ for (int i = 0; i < BrainCount; ++i)
+ {
+ CinemachineBrain b = GetActiveBrain(i);
+ if (b != null && b.IsLive(vcam))
+ b.m_CameraActivatedEvent.Invoke(vcam, vcamFrom);
+ }
+ }
+ }
+
+ /// <summary>
+ /// Signal that the virtual camera's content is discontinuous WRT the previous frame.
+ /// If the camera is live, then all CinemachineBrains that are showing it will send a cut event.
+ /// </summary>
+ public void GenerateCameraCutEvent(ICinemachineCamera vcam)
+ {
+ if (vcam != null)
+ {
+ for (int i = 0; i < BrainCount; ++i)
+ {
+ CinemachineBrain b = GetActiveBrain(i);
+ if (b != null && b.IsLive(vcam))
+ b.m_CameraCutEvent.Invoke(b);
+ }
+ }
+ }
+
+ /// <summary>
+ /// Try to find a CinemachineBrain to associate with a
+ /// Cinemachine Virtual Camera. The first CinemachineBrain
+ /// in which this Cinemachine Virtual Camera is live will be used.
+ /// If none, then the first active CinemachineBrain with the correct
+ /// layer filter will be used.
+ /// Brains with OutputCamera == null will not be returned.
+ /// Final result may be null.
+ /// </summary>
+ /// <param name="vcam">Virtual camera whose potential brain we need.</param>
+ /// <returns>First CinemachineBrain found that might be
+ /// appropriate for this vcam, or null</returns>
+ public CinemachineBrain FindPotentialTargetBrain(CinemachineVirtualCameraBase vcam)
+ {
+ if (vcam != null)
+ {
+ int numBrains = BrainCount;
+ for (int i = 0; i < numBrains; ++i)
+ {
+ CinemachineBrain b = GetActiveBrain(i);
+ if (b != null && b.OutputCamera != null && b.IsLive(vcam))
+ return b;
+ }
+ int layer = 1 << vcam.gameObject.layer;
+ for (int i = 0; i < numBrains; ++i)
+ {
+ CinemachineBrain b = GetActiveBrain(i);
+ if (b != null && b.OutputCamera != null && (b.OutputCamera.cullingMask & layer) != 0)
+ return b;
+ }
+ }
+ return null;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: c7d73314dfe49f8458398c6dc8edcda8
+timeCreated: 1484001119
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Cinemachine.Utility
+{
+ /// <summary>Manages onscreen positions for Cinemachine debugging output</summary>
+ public class CinemachineDebug
+ {
+ static HashSet<Object> mClients;
+
+ /// <summary>Release a screen rectangle previously obtained through GetScreenPos()</summary>
+ /// <param name="client">The client caller. Used as a handle.</param>
+ public static void ReleaseScreenPos(Object client)
+ {
+ if (mClients != null && mClients.Contains(client))
+ mClients.Remove(client);
+ }
+
+ /// <summary>Reserve an on-screen rectangle for debugging output.</summary>
+ /// <param name="client">The client caller. This is used as a handle.</param>
+ /// <param name="text">Sample text, for determining rectangle size</param>
+ /// <param name="style">What style will be used to draw, used here for
+ /// determining rect size</param>
+ /// <returns>An area on the game screen large enough to print the text
+ /// in the style indicated</returns>
+ public static Rect GetScreenPos(Object client, string text, GUIStyle style)
+ {
+ if (mClients == null)
+ mClients = new HashSet<Object>();
+ if (!mClients.Contains(client))
+ mClients.Add(client);
+
+ Vector2 pos = new Vector2(0, 0);
+ Vector2 size = style.CalcSize(new GUIContent(text));
+ if (mClients != null)
+ {
+ foreach (var c in mClients)
+ {
+ if (c == client)
+ break;
+ pos.y += size.y;
+ }
+ }
+ return new Rect(pos, size);
+ }
+
+ /// <summary>
+ /// Delegate for OnGUI debugging.
+ /// This will be called by the CinemachineBrain in its OnGUI (editor only)
+ /// </summary>
+ public delegate void OnGUIDelegate();
+
+ /// <summary>
+ /// Delegate for OnGUI debugging.
+ /// This will be called by the CinemachineBrain in its OnGUI (editor only)
+ /// </summary>
+ public static OnGUIDelegate OnGUIHandlers;
+
+ private static List<StringBuilder> mAvailableStringBuilders;
+
+ /// <summary>Get a preallocated StringBuilder from the pool</summary>
+ public static StringBuilder SBFromPool()
+ {
+ if (mAvailableStringBuilders == null || mAvailableStringBuilders.Count == 0)
+ return new StringBuilder();
+ var sb = mAvailableStringBuilders[mAvailableStringBuilders.Count - 1];
+ mAvailableStringBuilders.RemoveAt(mAvailableStringBuilders.Count - 1);
+ sb.Length = 0;
+ return sb;
+ }
+
+ /// <summary>Return a StringBuilder to the preallocated pool</summary>
+ public static void ReturnToPool(StringBuilder sb)
+ {
+ if (mAvailableStringBuilders == null)
+ mAvailableStringBuilders = new List<StringBuilder>();
+ mAvailableStringBuilders.Add(sb);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 10e6f8c815d3c4d45b1d98b951d53912
+timeCreated: 1481654954
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Base class for a Cinemachine Virtual Camera extension module.
+ /// Hooks into the Cinemachine Pipeline.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.API)]
+ public abstract class CinemachineExtension : MonoBehaviour
+ {
+ /// <summary>Useful constant for very small floats</summary>
+ protected const float Epsilon = Utility.UnityVectorExtensions.Epsilon;
+
+ /// <summary>Get the associated CinemachineVirtualCameraBase</summary>
+ public CinemachineVirtualCameraBase VirtualCamera
+ {
+ get
+ {
+ if (m_vcamOwner == null)
+ m_vcamOwner = GetComponent<CinemachineVirtualCameraBase>();
+ return m_vcamOwner;
+ }
+ }
+ CinemachineVirtualCameraBase m_vcamOwner;
+
+ /// <summary>Connect to virtual camera pipeline.
+ /// Override implementations must call this base implementation</summary>
+ protected virtual void Awake()
+ {
+ ConnectToVcam(true);
+ }
+
+#if UNITY_EDITOR
+ /// <summary>Does nothing. This is only here so we get the little "enabled"
+ /// checkbox in the inspector</summary>
+ void Update() {}
+
+ [UnityEditor.Callbacks.DidReloadScripts]
+ static void OnScriptReload()
+ {
+ var extensions = Resources.FindObjectsOfTypeAll(
+ typeof(CinemachineExtension)) as CinemachineExtension[];
+ foreach (var e in extensions)
+ e.ConnectToVcam(true);
+ }
+#endif
+ /// <summary>Disconnect from virtual camera pipeline.
+ /// Override implementations must call this base implementation</summary>
+ protected virtual void OnDestroy()
+ {
+ ConnectToVcam(false);
+ }
+
+ /// <summary>Connect to virtual camera. Implementation must be safe to be called
+ /// redundantly. Override implementations must call this base implementation</summary>
+ /// <param name="connect">True if connectinf, false if disconnecting</param>
+ protected virtual void ConnectToVcam(bool connect)
+ {
+ if (connect && VirtualCamera == null)
+ Debug.LogError("CinemachineExtension requires a Cinemachine Virtual Camera component");
+ if (VirtualCamera != null)
+ {
+ if (connect)
+ VirtualCamera.AddExtension(this);
+ else
+ VirtualCamera.RemoveExtension(this);
+ }
+ mExtraState = null;
+ }
+
+ /// <summary>Legacy support. This is only here to avoid changing the API
+ /// to make PostPipelineStageCallback() public</summary>
+ public void InvokePostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
+ {
+ PostPipelineStageCallback(vcam, stage, ref state, deltaTime);
+ }
+
+ /// <summary>
+ /// This callback will be called after the virtual camera has implemented
+ /// each stage in the pipeline. This method may modify the referenced state.
+ /// If deltaTime less than 0, reset all state info and perform no damping.
+ /// </summary>
+ protected abstract void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime);
+
+ /// <summary>This is called to notify the extension that a target got warped,
+ /// so that the extension can update its internal state to make the camera
+ /// also warp seamlessy. Base class implementation does nothing.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public virtual void OnTargetObjectWarped(Transform target, Vector3 positionDelta) {}
+
+ /// <summary>Because extensions can be placed on manager cams and will in that
+ /// case be called for all the vcam children, vcam-specific state information
+ /// should be stored here. Just define a class to hold your state info
+ /// and use it exclusively when calling this.</summary>
+ protected T GetExtraState<T>(ICinemachineCamera vcam) where T : class, new()
+ {
+ if (mExtraState == null)
+ mExtraState = new Dictionary<ICinemachineCamera, System.Object>();
+ System.Object extra = null;
+ if (!mExtraState.TryGetValue(vcam, out extra))
+ extra = mExtraState[vcam] = new T();
+ return extra as T;
+ }
+
+ /// <summary>Ineffeicient method to get all extra state infor for all vcams.
+ /// Intended for Editor use only, not runtime!
+ /// </summary>
+ protected List<T> GetAllExtraStates<T>() where T : class, new()
+ {
+ var list = new List<T>();
+ if (mExtraState != null)
+ foreach (var v in mExtraState)
+ list.Add(v.Value as T);
+ return list;
+ }
+
+ private Dictionary<ICinemachineCamera, System.Object> mExtraState;
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 4fa53a91a43ae1a4bbf6b29961b45c38
+timeCreated: 1504804419
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using UnityEngine;
+using Cinemachine.Utility;
+
+namespace Cinemachine
+{
+ [Serializable]
+ public struct CinemachineInputAxisDriver
+ {
+ [Tooltip("Multiply the input by this amount prior to processing. Controls the input power.")]
+ public float multiplier;
+
+ [Tooltip("The amount of time in seconds it takes to accelerate to a higher speed")]
+ public float accelTime;
+
+ [Tooltip("The amount of time in seconds it takes to decelerate to a lower speed")]
+ public float decelTime;
+
+ [Tooltip("The name of this axis as specified in Unity Input manager. "
+ + "Setting to an empty string will disable the automatic updating of this axis")]
+ public string name;
+
+ [NoSaveDuringPlay]
+ [Tooltip("The value of the input axis. A value of 0 means no input. You can drive "
+ + "this directly from a custom input system, or you can set the Axis Name and "
+ + "have the value driven by the internal Input Manager")]
+ public float inputValue;
+
+ /// Internal state
+ private float mCurrentSpeed;
+ const float Epsilon = UnityVectorExtensions.Epsilon;
+
+ /// Call from OnValidate: Make sure the fields are sensible
+ public void Validate()
+ {
+ accelTime = Mathf.Max(0, accelTime);
+ decelTime = Mathf.Max(0, decelTime);
+ }
+
+ public bool Update(float deltaTime, ref AxisState axis)
+ {
+ if (!string.IsNullOrEmpty(name))
+ {
+ try { inputValue = CinemachineCore.GetInputAxis(name); }
+ catch (ArgumentException) {}
+ //catch (ArgumentException e) { Debug.LogError(e.ToString()); }
+ }
+
+ float input = inputValue * multiplier;
+ if (deltaTime < Epsilon)
+ mCurrentSpeed = 0;
+ else
+ {
+ float speed = input / deltaTime;
+ float dampTime = Mathf.Abs(speed) < Mathf.Abs(mCurrentSpeed) ? decelTime : accelTime;
+ speed = mCurrentSpeed + Damper.Damp(speed - mCurrentSpeed, dampTime, deltaTime);
+ mCurrentSpeed = speed;
+
+ // Decelerate to the end points of the range if not wrapping
+ float range = axis.m_MaxValue - axis.m_MinValue;
+ if (!axis.m_Wrap && decelTime > Epsilon && range > Epsilon)
+ {
+ float v0 = ClampValue(ref axis, axis.Value);
+ float v = ClampValue(ref axis, v0 + speed * deltaTime);
+ float d = (speed > 0) ? axis.m_MaxValue - v : v - axis.m_MinValue;
+ if (d < (0.1f * range) && Mathf.Abs(speed) > Epsilon)
+ speed = Damper.Damp(v - v0, decelTime, deltaTime) / deltaTime;
+ }
+ input = speed * deltaTime;
+ }
+
+ axis.Value = ClampValue(ref axis, axis.Value + input);
+ return Mathf.Abs(inputValue) > Epsilon;
+ }
+
+ float ClampValue(ref AxisState axis, float v)
+ {
+ float r = axis.m_MaxValue - axis.m_MinValue;
+ if (axis.m_Wrap && r > Epsilon)
+ {
+ v = (v - axis.m_MinValue) % r;
+ v += axis.m_MinValue + ((v < 0) ? r : 0);
+ }
+ return Mathf.Clamp(v, axis.m_MinValue, axis.m_MaxValue);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 6d862fce0b0707949bb86058d777b116
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using Cinemachine.Utility;
+using System;
+
+namespace Cinemachine
+{
+ /// <summary>Abstract base class for a world-space path,
+ /// suitable for a camera dolly track.</summary>
+ public abstract class CinemachinePathBase : MonoBehaviour
+ {
+ /// <summary>Path samples per waypoint</summary>
+ [Tooltip("Path samples per waypoint. This is used for calculating path distances.")]
+ [Range(1, 100)]
+ public int m_Resolution = 20;
+
+ /// <summary>This class holds the settings that control how the path
+ /// will appear in the editor scene view. The path is not visible in the game view</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable] public class Appearance
+ {
+ [Tooltip("The color of the path itself when it is active in the editor")]
+ public Color pathColor = Color.green;
+ [Tooltip("The color of the path itself when it is inactive in the editor")]
+ public Color inactivePathColor = Color.gray;
+ [Tooltip("The width of the railroad-tracks that are drawn to represent the path")]
+ [Range(0f, 10f)]
+ public float width = 0.2f;
+ }
+ /// <summary>The settings that control how the path
+ /// will appear in the editor scene view.</summary>
+ [Tooltip("The settings that control how the path will appear in the editor scene view.")]
+ public Appearance m_Appearance = new Appearance();
+
+ /// <summary>The minimum value for the path position</summary>
+ public abstract float MinPos { get; }
+
+ /// <summary>The maximum value for the path position</summary>
+ public abstract float MaxPos { get; }
+
+ /// <summary>True if the path ends are joined to form a continuous loop</summary>
+ public abstract bool Looped { get; }
+
+ /// <summary>Get a standardized path position, taking spins into account if looped</summary>
+ /// <param name="pos">Position along the path</param>
+ /// <returns>Standardized position, between MinPos and MaxPos</returns>
+ public virtual float StandardizePos(float pos)
+ {
+ if (MaxPos == 0)
+ return 0;
+ if (Looped)
+ {
+ pos = pos % MaxPos;
+ if (pos < 0)
+ pos += MaxPos;
+ return pos > MaxPos - UnityVectorExtensions.Epsilon ? 0 : pos;
+ }
+ return Mathf.Clamp(pos, 0, MaxPos);
+ }
+
+ /// <summary>Get a worldspace position of a point along the path</summary>
+ /// <param name="pos">Postion along the path. Need not be standardized.</param>
+ /// <returns>World-space position of the point along at path at pos</returns>
+ public abstract Vector3 EvaluatePosition(float pos);
+
+ /// <summary>Get the tangent of the curve at a point along the path.</summary>
+ /// <param name="pos">Postion along the path. Need not be standardized.</param>
+ /// <returns>World-space direction of the path tangent.
+ /// Length of the vector represents the tangent strength</returns>
+ public abstract Vector3 EvaluateTangent(float pos);
+
+ /// <summary>Get the orientation the curve at a point along the path.</summary>
+ /// <param name="pos">Postion along the path. Need not be standardized.</param>
+ /// <returns>World-space orientation of the path</returns>
+ public abstract Quaternion EvaluateOrientation(float pos);
+
+ /// <summary>Find the closest point on the path to a given worldspace target point.</summary>
+ /// <remarks>Performance could be improved by checking the bounding polygon of each segment,
+ /// and only entering the best segment(s)</remarks>
+ /// <param name="p">Worldspace target that we want to approach</param>
+ /// <param name="startSegment">In what segment of the path to start the search.
+ /// A Segment is a section of path between 2 waypoints.</param>
+ /// <param name="searchRadius">How many segments on either side of the startSegment
+ /// to search. -1 means no limit, i.e. search the entire path</param>
+ /// <param name="stepsPerSegment">We search a segment by dividing it into this many
+ /// straight pieces. The higher the number, the more accurate the result, but performance
+ /// is proportionally slower for higher numbers</param>
+ /// <returns>The position along the path that is closest to the target point.
+ /// The value is in Path Units, not Distance units.</returns>
+ public virtual float FindClosestPoint(
+ Vector3 p, int startSegment, int searchRadius, int stepsPerSegment)
+ {
+ float start = MinPos;
+ float end = MaxPos;
+ if (searchRadius >= 0)
+ {
+ int r = Mathf.FloorToInt(Mathf.Min(searchRadius, (end - start) / 2f));
+ start = startSegment - r;
+ end = startSegment + r + 1;
+ if (!Looped)
+ {
+ start = Mathf.Max(start, MinPos);
+ end = Mathf.Max(end, MaxPos);
+ }
+ }
+ stepsPerSegment = Mathf.RoundToInt(Mathf.Clamp(stepsPerSegment, 1f, 100f));
+ float stepSize = 1f / stepsPerSegment;
+ float bestPos = startSegment;
+ float bestDistance = float.MaxValue;
+ int iterations = (stepsPerSegment == 1) ? 1 : 3;
+ for (int i = 0; i < iterations; ++i)
+ {
+ Vector3 v0 = EvaluatePosition(start);
+ for (float f = start + stepSize; f <= end; f += stepSize)
+ {
+ Vector3 v = EvaluatePosition(f);
+ float t = p.ClosestPointOnSegment(v0, v);
+ float d = Vector3.SqrMagnitude(p - Vector3.Lerp(v0, v, t));
+ if (d < bestDistance)
+ {
+ bestDistance = d;
+ bestPos = f - (1 - t) * stepSize;
+ }
+ v0 = v;
+ }
+ start = bestPos - stepSize;
+ end = bestPos + stepSize;
+ stepSize /= stepsPerSegment;
+ }
+ return bestPos;
+ }
+
+ /// <summary>How to interpret the Path Position</summary>
+ public enum PositionUnits
+ {
+ /// <summary>Use PathPosition units, where 0 is first waypoint, 1 is second waypoint, etc</summary>
+ PathUnits,
+ /// <summary>Use Distance Along Path. Path will be sampled according to its Resolution
+ /// setting, and a distance lookup table will be cached internally</summary>
+ Distance,
+ /// <summary>Normalized units, where 0 is the start of the path, and 1 is the end.
+ /// Path will be sampled according to its Resolution
+ /// setting, and a distance lookup table will be cached internally</summary>
+ Normalized
+ }
+
+ /// <summary>Get the minimum value, for the given unit type</summary>
+ /// <param name="units">The unit type</param>
+ /// <returns>The minimum allowable value for this path</returns>
+ public float MinUnit(PositionUnits units)
+ {
+ if (units == PositionUnits.Normalized)
+ return 0;
+ return units == PositionUnits.Distance ? 0 : MinPos;
+ }
+
+ /// <summary>Get the maximum value, for the given unit type</summary>
+ /// <param name="units">The unit type</param>
+ /// <returns>The maximum allowable value for this path</returns>
+ public float MaxUnit(PositionUnits units)
+ {
+ if (units == PositionUnits.Normalized)
+ return 1;
+ return units == PositionUnits.Distance ? PathLength : MaxPos;
+ }
+
+ /// <summary>Standardize the unit, so that it lies between MinUmit and MaxUnit</summary>
+ /// <param name="pos">The value to be standardized</param>
+ /// <param name="units">The unit type</param>
+ /// <returns>The standardized value of pos, between MinUnit and MaxUnit</returns>
+ public virtual float StandardizeUnit(float pos, PositionUnits units)
+ {
+ if (units == PositionUnits.PathUnits)
+ return StandardizePos(pos);
+ if (units == PositionUnits.Distance)
+ return StandardizePathDistance(pos);
+ float len = PathLength;
+ if (len < UnityVectorExtensions.Epsilon)
+ return 0;
+ return StandardizePathDistance(pos * len) / len;
+ }
+
+ /// <summary>Get a worldspace position of a point along the path</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <param name="units">The unit to use when interpreting the value of pos.</param>
+ /// <returns>World-space position of the point along at path at pos</returns>
+ public Vector3 EvaluatePositionAtUnit(float pos, PositionUnits units)
+ {
+ return EvaluatePosition(ToNativePathUnits(pos, units));
+ }
+
+ /// <summary>Get the tangent of the curve at a point along the path.</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <param name="units">The unit to use when interpreting the value of pos.</param>
+ /// <returns>World-space direction of the path tangent.
+ /// Length of the vector represents the tangent strength</returns>
+ public Vector3 EvaluateTangentAtUnit(float pos, PositionUnits units)
+ {
+ return EvaluateTangent(ToNativePathUnits(pos, units));
+ }
+
+ /// <summary>Get the orientation the curve at a point along the path.</summary>
+ /// <param name="pos">Postion along the path. Need not be normalized.</param>
+ /// <param name="units">The unit to use when interpreting the value of pos.</param>
+ /// <returns>World-space orientation of the path</returns>
+ public Quaternion EvaluateOrientationAtUnit(float pos, PositionUnits units)
+ {
+ return EvaluateOrientation(ToNativePathUnits(pos, units));
+ }
+
+ /// <summary>When calculating the distance cache, sample the path this many
+ /// times between points</summary>
+ public abstract int DistanceCacheSampleStepsPerSegment { get; }
+
+ /// <summary>Call this if the path changes in such a way as to affect distances
+ /// or other cached path elements</summary>
+ public virtual void InvalidateDistanceCache()
+ {
+ m_DistanceToPos = null;
+ m_PosToDistance = null;
+ m_CachedSampleSteps = 0;
+ m_PathLength = 0;
+ }
+
+ /// <summary>See whether the distance cache is valid. If it's not valid,
+ /// then any call to GetPathLength() or ToNativePathUnits() will
+ /// trigger a potentially costly regeneration of the path distance cache</summary>
+ /// <returns>Whether the cache is valid</returns>
+ public bool DistanceCacheIsValid()
+ {
+ return (MaxPos == MinPos)
+ || (m_DistanceToPos != null && m_PosToDistance != null
+ && m_CachedSampleSteps == DistanceCacheSampleStepsPerSegment
+ && m_CachedSampleSteps > 0);
+ }
+
+ /// <summary>Get the length of the path in distance units.
+ /// If the distance cache is not valid, then calling this will
+ /// trigger a potentially costly regeneration of the path distance cache</summary>
+ /// <returns>The length of the path in distance units, when sampled at this rate</returns>
+ public float PathLength
+ {
+ get
+ {
+ if (DistanceCacheSampleStepsPerSegment < 1)
+ return 0;
+ if (!DistanceCacheIsValid())
+ ResamplePath(DistanceCacheSampleStepsPerSegment);
+ return m_PathLength;
+ }
+ }
+
+ /// <summary>Standardize a distance along the path based on the path length.
+ /// If the distance cache is not valid, then calling this will
+ /// trigger a potentially costly regeneration of the path distance cache</summary>
+ /// <param name="distance">The distance to standardize</param>
+ /// <returns>The standardized distance, ranging from 0 to path length</returns>
+ public float StandardizePathDistance(float distance)
+ {
+ float length = PathLength;
+ if (length < Vector3.kEpsilon)
+ return 0;
+ if (Looped)
+ {
+ distance = distance % length;
+ if (distance < 0)
+ distance += length;
+ }
+ return Mathf.Clamp(distance, 0, length);
+ }
+
+ /// <summary>Get the path position (in native path units) corresponding to the psovided
+ /// value, in the units indicated.
+ /// If the distance cache is not valid, then calling this will
+ /// trigger a potentially costly regeneration of the path distance cache</summary>
+ /// <param name="pos">The value to convert from</param>
+ /// <param name="units">The units in which pos is expressed</param>
+ /// <returns>The length of the path in native units, when sampled at this rate</returns>
+ public float ToNativePathUnits(float pos, PositionUnits units)
+ {
+ if (units == PositionUnits.PathUnits)
+ return pos;
+ if (DistanceCacheSampleStepsPerSegment < 1 || PathLength < UnityVectorExtensions.Epsilon)
+ return MinPos;
+ if (units == PositionUnits.Normalized)
+ pos *= PathLength;
+ pos = StandardizePathDistance(pos);
+ float d = pos / m_cachedDistanceStepSize;
+ int i = Mathf.FloorToInt(d);
+ if (i >= m_DistanceToPos.Length-1)
+ return MaxPos;
+ float t = d - (float)i;
+ return MinPos + Mathf.Lerp(m_DistanceToPos[i], m_DistanceToPos[i+1], t);
+ }
+
+ /// <summary>Get the path position (in path units) corresponding to this distance along the path.
+ /// If the distance cache is not valid, then calling this will
+ /// trigger a potentially costly regeneration of the path distance cache</summary>
+ /// <param name="pos">The value to convert from, in native units</param>
+ /// <param name="units">The units to convert toexpressed</param>
+ /// <returns>The length of the path in distance units, when sampled at this rate</returns>
+ public float FromPathNativeUnits(float pos, PositionUnits units)
+ {
+ if (units == PositionUnits.PathUnits)
+ return pos;
+ float length = PathLength;
+ if (DistanceCacheSampleStepsPerSegment < 1 || length < UnityVectorExtensions.Epsilon)
+ return 0;
+ pos = StandardizePos(pos);
+ float d = pos / m_cachedPosStepSize;
+ int i = Mathf.FloorToInt(d);
+ if (i >= m_PosToDistance.Length-1)
+ pos = m_PathLength;
+ else
+ {
+ float t = d - (float)i;
+ pos = Mathf.Lerp(m_PosToDistance[i], m_PosToDistance[i+1], t);
+ }
+ if (units == PositionUnits.Normalized)
+ pos /= length;
+ return pos;
+ }
+
+ private float[] m_DistanceToPos;
+ private float[] m_PosToDistance;
+ private int m_CachedSampleSteps;
+ private float m_PathLength;
+ private float m_cachedPosStepSize;
+ private float m_cachedDistanceStepSize;
+
+ private void ResamplePath(int stepsPerSegment)
+ {
+ InvalidateDistanceCache();
+
+ float minPos = MinPos;
+ float maxPos = MaxPos;
+ float stepSize = 1f / Mathf.Max(1, stepsPerSegment);
+
+ // Sample the positions
+ int numKeys = Mathf.RoundToInt((maxPos - minPos) / stepSize) + 1;
+ m_PosToDistance = new float[numKeys];
+ m_CachedSampleSteps = stepsPerSegment;
+ m_cachedPosStepSize = stepSize;
+
+ Vector3 p0 = EvaluatePosition(0);
+ m_PosToDistance[0] = 0;
+ float pos = minPos;
+ for (int i = 1; i < numKeys; ++i)
+ {
+ pos += stepSize;
+ Vector3 p = EvaluatePosition(pos);
+ float d = Vector3.Distance(p0, p);
+ m_PathLength += d;
+ p0 = p;
+ m_PosToDistance[i] = m_PathLength;
+ }
+
+ // Resample the distances
+ m_DistanceToPos = new float[numKeys];
+ m_DistanceToPos[0] = 0;
+ if (numKeys > 1)
+ {
+ stepSize = m_PathLength / (numKeys - 1);
+ m_cachedDistanceStepSize = stepSize;
+ float distance = 0;
+ int posIndex = 1;
+ for (int i = 1; i < numKeys; ++i)
+ {
+ distance += stepSize;
+ float d = m_PosToDistance[posIndex];
+ while (d < distance && posIndex < numKeys-1)
+ d = m_PosToDistance[++posIndex];
+ float d0 = m_PosToDistance[posIndex-1];
+ float delta = d - d0;
+ float t = (distance - d0) / delta;
+ m_DistanceToPos[i] = m_cachedPosStepSize * (t + posIndex - 1);
+ }
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: a73149a4b6c41d741bc5e4e3b7711c0d
+timeCreated: 1494359378
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Property applied to AxisState. Used for custom drawing in the inspector.
+ /// </summary>
+ public sealed class AxisStatePropertyAttribute : PropertyAttribute {}
+
+ /// <summary>
+ /// Property applied to OrbitalTransposer.Heading. Used for custom drawing in the inspector.
+ /// </summary>
+ public sealed class OrbitalTransposerHeadingPropertyAttribute : PropertyAttribute {}
+
+ /// <summary>
+ /// Property applied to LensSettings. Used for custom drawing in the inspector.
+ /// </summary>
+ public sealed class LensSettingsPropertyAttribute : PropertyAttribute {}
+
+ /// <summary>
+ /// Property applied to CinemachineBlendDefinition. Used for custom drawing in the inspector.
+ /// </summary>
+ public sealed class CinemachineBlendDefinitionPropertyAttribute : PropertyAttribute {}
+
+ /// <summary>
+ /// Invoke play-mode-save for a class. This class's fields will be scanned
+ /// upon exiting play mode, and its property values will be applied to the scene object.
+ /// This is a stopgap measure that will become obsolete once Unity implements
+ /// play-mode-save in a more general way.
+ /// </summary>
+ public sealed class SaveDuringPlayAttribute : System.Attribute {}
+
+ /// <summary>
+ /// Suppresses play-mode-save for a field. Use it if the calsee has [SaveDuringPlay]
+ /// attribute but there are fields in the class that shouldn't be saved.
+ /// </summary>
+ public sealed class NoSaveDuringPlayAttribute : PropertyAttribute {}
+
+ /// <summary>Property field is a Tag.</summary>
+ public sealed class TagFieldAttribute : PropertyAttribute {}
+
+ /// <summary>Property field is a NoiseSettings asset.</summary>
+ public sealed class NoiseSettingsPropertyAttribute : PropertyAttribute {}
+
+ /// <summary>
+ /// Used for custom drawing in the inspector.
+ /// </summary>
+ public sealed class CinemachineEmbeddedAssetPropertyAttribute : PropertyAttribute
+ {
+ public bool WarnIfNull;
+ public CinemachineEmbeddedAssetPropertyAttribute(bool warnIfNull = false)
+ {
+ WarnIfNull = warnIfNull;
+ }
+ }
+
+ /// <summary>
+ /// Atrtribute to control the automatic generation of documentation.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.Undoc)]
+ public sealed class DocumentationSortingAttribute : System.Attribute
+ {
+ /// <summary>Refinement level of the documentation</summary>
+ public enum Level
+ {
+ /// <summary>Type is excluded from documentation</summary>
+ Undoc,
+ /// <summary>Type is documented in the API reference</summary>
+ API,
+ /// <summary>Type is documented in the highly-refined User Manual</summary>
+ UserRef
+ };
+ /// <summary>Refinement level of the documentation. The more refined, the more is excluded.</summary>
+ public Level Category { get; private set; }
+
+ /// <summary>Contructor with specific values</summary>
+ public DocumentationSortingAttribute(Level category)
+ {
+ Category = category;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 2c760cb7073c57e44959f36cbed8ed39
+timeCreated: 1486510400
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine;
+using UnityEngine;
+
+/// <summary>
+/// This is an add-on behaviour that globally maps the touch control
+/// to standard input channels, such as mouse X and mouse Y.
+/// Drop it on any game object in your scene.
+/// </summary>
+public class CinemachineTouchInputMapper : MonoBehaviour
+{
+ public float TouchSensitivityX = 10f;
+ public float TouchSensitivityY = 10f;
+
+ public string TouchXInputMapTo = "Mouse X";
+ public string TouchYInputMapTo = "Mouse Y";
+
+ void Start()
+ {
+ CinemachineCore.GetInputAxis = GetInputAxis;
+ }
+
+ private float GetInputAxis(string axisName)
+ {
+ if (Input.touchCount > 0)
+ {
+ if (axisName == TouchXInputMapTo)
+ return Input.touches[0].deltaPosition.x / TouchSensitivityX;
+ if (axisName == TouchYInputMapTo)
+ return Input.touches[0].deltaPosition.y / TouchSensitivityY;
+ }
+ return Input.GetAxis(axisName);
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 2adf148a19499274795e418631d7db45
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Base class for a Monobehaviour that represents a Virtual Camera within the Unity scene.
+ ///
+ /// This is intended to be attached to an empty Transform GameObject.
+ /// Inherited classes can be either standalone virtual cameras such
+ /// as CinemachineVirtualCamera, or meta-cameras such as
+ /// CinemachineClearShot or CinemachineFreeLook.
+ ///
+ /// A CinemachineVirtualCameraBase exposes a Priority property. When the behaviour is
+ /// enabled in the game, the Virtual Camera is automatically placed in a queue
+ /// maintained by the static CinemachineCore singleton.
+ /// The queue is sorted by priority. When a Unity camera is equipped with a
+ /// CinemachineBrain behaviour, the brain will choose the camera
+ /// at the head of the queue. If you have multiple Unity cameras with CinemachineBrain
+ /// behaviours (say in a split-screen context), then you can filter the queue by
+ /// setting the culling flags on the virtual cameras. The culling mask of the
+ /// Unity Camera will then act as a filter for the brain. Apart from this,
+ /// there is nothing that prevents a virtual camera from controlling multiple
+ /// Unity cameras simultaneously.
+ /// </summary>
+ [SaveDuringPlay]
+ public abstract class CinemachineVirtualCameraBase : MonoBehaviour, ICinemachineCamera
+ {
+ /// <summary>Inspector control - Use for hiding sections of the Inspector UI.</summary>
+ [HideInInspector, SerializeField, NoSaveDuringPlay]
+ public string[] m_ExcludedPropertiesInInspector = new string[] { "m_Script" };
+
+ /// <summary>Inspector control - Use for enabling sections of the Inspector UI.</summary>
+ [HideInInspector, SerializeField, NoSaveDuringPlay]
+ public CinemachineCore.Stage[] m_LockStageInInspector;
+
+ /// <summary>Version that was last streamed, for upgrading legacy</summary>
+ public int ValidatingStreamVersion
+ {
+ get { return m_OnValidateCalled ? m_ValidatingStreamVersion : CinemachineCore.kStreamingVersion; }
+ private set { m_ValidatingStreamVersion = value; }
+ }
+ private int m_ValidatingStreamVersion = 0;
+ private bool m_OnValidateCalled = false;
+
+ [HideInInspector, SerializeField, NoSaveDuringPlay]
+ private int m_StreamingVersion;
+
+ /// <summary>The priority will determine which camera becomes active based on the
+ /// state of other cameras and this camera. Higher numbers have greater priority.
+ /// </summary>
+ [NoSaveDuringPlay]
+ [Tooltip("The priority will determine which camera becomes active based on the state of other cameras and this camera. Higher numbers have greater priority.")]
+ public int m_Priority = 10;
+
+ /// <summary>
+ /// How often to update a virtual camera when it is in Standby mode
+ /// </summary>
+ public enum StandbyUpdateMode
+ {
+ /// <summary>Only update if the virtual camera is Live</summary>
+ Never,
+ /// <summary>Update the virtual camera every frame, even when it is not Live</summary>
+ Always,
+ /// <summary>Update the virtual camera occasionally, the exact frequency depends
+ /// on how many other virtual cameras are in Standby</summary>
+ RoundRobin
+ };
+
+ /// <summary>When the virtual camera is not live, this is how often the virtual camera will
+ /// be updated. Set this to tune for performance. Most of the time Never is fine, unless
+ /// the virtual camera is doing shot evaluation.
+ /// </summary>
+ [Tooltip("When the virtual camera is not live, this is how often the virtual camera will be updated. "
+ + "Set this to tune for performance. Most of the time Never is fine, "
+ + "unless the virtual camera is doing shot evaluation.")]
+ public StandbyUpdateMode m_StandbyUpdate = StandbyUpdateMode.RoundRobin;
+
+ /// <summary>
+ /// A delegate to hook into the state calculation pipeline.
+ /// This will be called after each pipeline stage, to allow others to hook into the pipeline.
+ /// See CinemachineCore.Stage.
+ /// </summary>
+ /// <param name="extension">The extension to add.</param>
+ public virtual void AddExtension(CinemachineExtension extension)
+ {
+ if (mExtensions == null)
+ mExtensions = new List<CinemachineExtension>();
+ else
+ mExtensions.Remove(extension);
+ mExtensions.Add(extension);
+ }
+
+ /// <summary>Remove a Pipeline stage hook callback.</summary>
+ /// <param name="extension">The extension to remove.</param>
+ public virtual void RemoveExtension(CinemachineExtension extension)
+ {
+ if (mExtensions != null)
+ mExtensions.Remove(extension);
+ }
+
+ /// <summary> THe extensions connected to this vcam</summary>
+ List<CinemachineExtension> mExtensions;
+
+ /// <summary>
+ /// Invokes the PostPipelineStageDelegate for this camera, and up the hierarchy for all
+ /// parent cameras (if any).
+ /// Implementaion must be sure to call this after each pipeline stage, to allow
+ /// other services to hook into the pipeline.
+ /// See CinemachineCore.Stage.
+ /// </summary>
+ protected void InvokePostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam, CinemachineCore.Stage stage,
+ ref CameraState newState, float deltaTime)
+ {
+ if (mExtensions != null)
+ {
+ for (int i = 0; i < mExtensions.Count; ++i)
+ {
+ var e = mExtensions[i];
+ if (e == null)
+ {
+ // Object was deleted (possibly because of Undo in the editor)
+ mExtensions.RemoveAt(i);
+ --i;
+ }
+ else if (e.enabled)
+ e.InvokePostPipelineStageCallback(vcam, stage, ref newState, deltaTime);
+ }
+ }
+ CinemachineVirtualCameraBase parent = ParentCamera as CinemachineVirtualCameraBase;
+ if (parent != null)
+ parent.InvokePostPipelineStageCallback(vcam, stage, ref newState, deltaTime);
+ }
+
+ /// <summary>Get the name of the Virtual Camera. Base implementation
+ /// returns the owner GameObject's name.</summary>
+ public string Name { get { return name; } }
+
+ /// <summary>Gets a brief debug description of this virtual camera, for use when displayiong debug info</summary>
+ public virtual string Description { get { return ""; }}
+
+ /// <summary>Get the Priority of the virtual camera. This determines its placement
+ /// in the CinemachineCore's queue of eligible shots.</summary>
+ public int Priority { get { return m_Priority; } set { m_Priority = value; } }
+
+ /// <summary>Hint for blending to and from this virtual camera</summary>
+ public enum BlendHint
+ {
+ /// <summary>Standard linear position and aim blend</summary>
+ None,
+ /// <summary>Spherical blend about LookAt target position if there is a LookAt target, linear blend between LookAt targets</summary>
+ SphericalPosition,
+ /// <summary>Cylindrical blend about LookAt target position if there is a LookAt target (vertical co-ordinate is linearly interpolated), linear blend between LookAt targets</summary>
+ CylindricalPosition,
+ /// <summary>Standard linear position blend, radial blend between LookAt targets</summary>
+ ScreenSpaceAimWhenTargetsDiffer
+ }
+
+ /// <summary>Applies a position blend hint to the camera state</summary>
+ protected void ApplyPositionBlendMethod(ref CameraState state, BlendHint hint)
+ {
+ switch (hint)
+ {
+ default:
+ break;
+ case BlendHint.SphericalPosition:
+ state.BlendHint |= CameraState.BlendHintValue.SphericalPositionBlend;
+ break;
+ case BlendHint.CylindricalPosition:
+ state.BlendHint |= CameraState.BlendHintValue.CylindricalPositionBlend;
+ break;
+ case BlendHint.ScreenSpaceAimWhenTargetsDiffer:
+ state.BlendHint |= CameraState.BlendHintValue.RadialAimBlend;
+ break;
+ }
+ }
+
+ /// <summary>The GameObject owner of the Virtual Camera behaviour.</summary>
+ public GameObject VirtualCameraGameObject
+ {
+ get
+ {
+ if (this == null)
+ return null; // object deleted
+ return gameObject;
+ }
+ }
+
+ public bool IsValid { get { return !(this == null); } }
+
+ /// <summary>The CameraState object holds all of the information
+ /// necessary to position the Unity camera. It is the output of this class.</summary>
+ public abstract CameraState State { get; }
+
+ /// <summary>Support for meta-virtual-cameras. This is the situation where a
+ /// virtual camera is in fact the public face of a private army of virtual cameras, which
+ /// it manages on its own. This method gets the VirtualCamera owner, if any.
+ /// Private armies are implemented as Transform children of the parent vcam.</summary>
+ public ICinemachineCamera ParentCamera
+ {
+ get
+ {
+ if (!mSlaveStatusUpdated || !Application.isPlaying)
+ UpdateSlaveStatus();
+ return m_parentVcam;
+ }
+ }
+
+ /// <summary>Check whether the vcam a live child of this camera.
+ /// This base class implementation always returns false.</summary>
+ /// <param name="vcam">The Virtual Camera to check</param>
+ /// <param name="dominantChildOnly">If truw, will only return true if this vcam is the dominat live child</param>
+ /// <returns>True if the vcam is currently actively influencing the state of this vcam</returns>
+ public virtual bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false) { return false; }
+
+ /// <summary>Get the LookAt target for the Aim component in the Cinemachine pipeline.</summary>
+ public abstract Transform LookAt { get; set; }
+
+ /// <summary>Get the Follow target for the Body component in the Cinemachine pipeline.</summary>
+ public abstract Transform Follow { get; set; }
+
+ /// <summary>Set this to force the next update to ignore deltaTime and reset itself</summary>
+ public bool PreviousStateIsValid
+ {
+ get
+ {
+ if (LookAt != m_previousLookAtTarget)
+ {
+ m_previousLookAtTarget = LookAt;
+ m_previousStateIsValid = false;
+ }
+ if (Follow != m_previousFollowTarget)
+ {
+ m_previousFollowTarget = Follow;
+ m_previousStateIsValid = false;
+ }
+ return m_previousStateIsValid;
+ }
+ set
+ {
+ m_previousStateIsValid = value;
+ }
+ }
+ private bool m_previousStateIsValid;
+ private Transform m_previousLookAtTarget;
+ private Transform m_previousFollowTarget;
+
+ /// <summary>
+ /// Update the camera's state.
+ /// The implementation must guarantee against multiple calls per frame, and should
+ /// use CinemachineCore.UpdateVirtualCamera(ICinemachineCamera, Vector3, float), which
+ /// has protection against multiple calls per frame.
+ /// </summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ public void UpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ CinemachineCore.Instance.UpdateVirtualCamera(this, worldUp, deltaTime);
+ }
+
+ /// <summary>Internal use only. Do not call this method.
+ /// Called by CinemachineCore at designated update time
+ /// so the vcam can position itself and track its targets.
+ /// Do not call this method. Let the framework do it at the appropriate time</summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ public abstract void InternalUpdateCameraState(Vector3 worldUp, float deltaTime);
+
+ /// <summary> Collection of parameters that influence how this virtual camera transitions from
+ /// other virtual cameras </summary>
+ [Serializable]
+ public struct TransitionParams
+ {
+ /// <summary>Hint for blending positions to and from this virtual camera</summary>
+ [Tooltip("Hint for blending positions to and from this virtual camera")]
+ [FormerlySerializedAs("m_PositionBlending")]
+ public BlendHint m_BlendHint;
+
+ /// <summary>When this virtual camera goes Live, attempt to force the position to be the same as the current position of the Unity Camera</summary>
+ [Tooltip("When this virtual camera goes Live, attempt to force the position to be the same as the current position of the Unity Camera")]
+ public bool m_InheritPosition;
+
+ /// <summary>This event fires when the virtual camera goes Live</summary>
+ [Tooltip("This event fires when the virtual camera goes Live")]
+ public CinemachineBrain.VcamActivatedEvent m_OnCameraLive;
+ }
+
+ /// <summary>Notification that this virtual camera is going live.
+ /// Base class implementation must be called by any overridden method.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public virtual void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ if (!gameObject.activeInHierarchy)
+ PreviousStateIsValid = false;
+ }
+
+ /// <summary>Maintains the global vcam registry. Always call the base class implementation.</summary>
+ protected virtual void OnDestroy()
+ {
+ CinemachineCore.Instance.RemoveActiveCamera(this);
+ }
+
+ /// <summary>Base class implementation makes sure the priority queue remains up-to-date.</summary>
+ protected virtual void OnTransformParentChanged()
+ {
+ CinemachineCore.Instance.CameraDestroyed(this);
+ CinemachineCore.Instance.CameraAwakened(this);
+ UpdateSlaveStatus();
+ UpdateVcamPoolStatus();
+ }
+
+ /// <summary>Base class implementation does nothing.</summary>
+ protected virtual void Start()
+ {
+ }
+
+ /// <summary>Enforce bounds for fields, when changed in inspector.
+ /// Call base class implementation at the beginning of overridden method.
+ /// After base method is called, ValidatingStreamVersion will be valid.</summary>
+ protected virtual void OnValidate()
+ {
+ m_OnValidateCalled = true;
+ ValidatingStreamVersion = m_StreamingVersion;
+ m_StreamingVersion = CinemachineCore.kStreamingVersion;
+ }
+
+ /// <summary>Base class implementation adds the virtual camera from the priority queue.</summary>
+ protected virtual void OnEnable()
+ {
+ // Sanity check - if another vcam component is enabled, shut down
+ var vcamComponents = GetComponents<CinemachineVirtualCameraBase>();
+ for (int i = 0; i < vcamComponents.Length; ++i)
+ {
+ if (vcamComponents[i].enabled && vcamComponents[i] != this)
+ {
+ Debug.LogError(Name
+ + " has multiple CinemachineVirtualCameraBase-derived components. Disabling "
+ + GetType().Name + ".");
+ enabled = false;
+ }
+ }
+ UpdateSlaveStatus();
+ UpdateVcamPoolStatus(); // Add to queue
+ if (!CinemachineCore.Instance.IsLive(this))
+ PreviousStateIsValid = false;
+ CinemachineCore.Instance.CameraAwakened(this);
+ }
+
+ /// <summary>Base class implementation makes sure the priority queue remains up-to-date.</summary>
+ protected virtual void OnDisable()
+ {
+ UpdateVcamPoolStatus(); // Remove from queue
+ CinemachineCore.Instance.CameraDestroyed(this);
+ }
+
+ /// <summary>Base class implementation makes sure the priority queue remains up-to-date.</summary>
+ protected virtual void Update()
+ {
+ if (m_Priority != m_QueuePriority)
+ UpdateVcamPoolStatus();
+ }
+
+ private bool mSlaveStatusUpdated = false;
+ private CinemachineVirtualCameraBase m_parentVcam = null;
+
+ private void UpdateSlaveStatus()
+ {
+ mSlaveStatusUpdated = true;
+ m_parentVcam = null;
+ Transform p = transform.parent;
+ if (p != null)
+ m_parentVcam = p.GetComponent<CinemachineVirtualCameraBase>();
+ }
+
+ /// <summary>Returns this vcam's LookAt target, or if that is null, will retrun
+ /// the parent vcam's LookAt target.</summary>
+ /// <param name="localLookAt">This vcam's LookAt value.</param>
+ /// <returns>The same value, or the parent's if null and a parent exists.</returns>
+ protected Transform ResolveLookAt(Transform localLookAt)
+ {
+ Transform lookAt = localLookAt;
+ if (lookAt == null && ParentCamera != null)
+ lookAt = ParentCamera.LookAt; // Parent provides default
+ return lookAt;
+ }
+
+ /// <summary>Returns this vcam's Follow target, or if that is null, will retrun
+ /// the parent vcam's Follow target.</summary>
+ /// <param name="localFollow">This vcam's Follow value.</param>
+ /// <returns>The same value, or the parent's if null and a parent exists.</returns>
+ protected Transform ResolveFollow(Transform localFollow)
+ {
+ Transform follow = localFollow;
+ if (follow == null && ParentCamera != null)
+ follow = ParentCamera.Follow; // Parent provides default
+ return follow;
+ }
+
+ private int m_QueuePriority = int.MaxValue;
+ private void UpdateVcamPoolStatus()
+ {
+ CinemachineCore.Instance.RemoveActiveCamera(this);
+ if (m_parentVcam == null && isActiveAndEnabled)
+ CinemachineCore.Instance.AddActiveCamera(this);
+ m_QueuePriority = m_Priority;
+ }
+
+ /// <summary>When multiple virtual cameras have the highest priority, there is
+ /// sometimes the need to push one to the top, making it the current Live camera if
+ /// it shares the highest priority in the queue with its peers.
+ ///
+ /// This happens automatically when a
+ /// new vcam is enabled: the most recent one goes to the top of the priority subqueue.
+ /// Use this method to push a vcam to the top of its priority peers.
+ /// If it and its peers share the highest priority, then this vcam will become Live.</summary>
+ public void MoveToTopOfPrioritySubqueue()
+ {
+ UpdateVcamPoolStatus();
+ }
+
+ /// <summary>This is called to notify the component that a target got warped,
+ /// so that the component can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public virtual void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ // inform the extensions
+ if (mExtensions != null)
+ {
+ for (int i = 0; i < mExtensions.Count; ++i)
+ mExtensions[i].OnTargetObjectWarped(target, positionDelta);
+ }
+ }
+
+ /// <summary>Create a blend between 2 virtual cameras, taking into account
+ /// any existing active blend.</summary>
+ protected CinemachineBlend CreateBlend(
+ ICinemachineCamera camA, ICinemachineCamera camB,
+ CinemachineBlendDefinition blendDef,
+ CinemachineBlend activeBlend)
+ {
+ if (blendDef.BlendCurve == null || blendDef.m_Time <= 0 || (camA == null && camB == null))
+ return null;
+ if (activeBlend != null)
+ {
+ // Special case: if backing out of a blend-in-progress
+ // with the same blend in reverse, adjust the belnd time
+ if (activeBlend.CamA == camB
+ && activeBlend.CamB == camA
+ && activeBlend.Duration <= blendDef.m_Time)
+ {
+ blendDef.m_Time = activeBlend.TimeInBlend;
+ }
+ camA = new BlendSourceVirtualCamera(activeBlend);
+ }
+ else if (camA == null)
+ camA = new StaticPointVirtualCamera(State, "(none)");
+ return new CinemachineBlend(
+ camA, camB, blendDef.BlendCurve, blendDef.m_Time, 0);
+ }
+
+ /// <summary>
+ /// Create a camera state based on the current transform of this vcam
+ /// </summary>
+ /// <param name="worldUp">Current World Up direction, as provided by the brain</param>
+ /// <param name="lens">Lens settings to serve as base, will be combined with lens from brain, if any</param>
+ /// <returns></returns>
+ protected CameraState PullStateFromVirtualCamera(Vector3 worldUp, ref LensSettings lens)
+ {
+ CameraState state = CameraState.Default;
+ state.RawPosition = transform.position;
+ state.RawOrientation = transform.rotation;
+ state.ReferenceUp = worldUp;
+
+ CinemachineBrain brain = CinemachineCore.Instance.FindPotentialTargetBrain(this);
+ if (brain != null)
+ lens.SnapshotCameraReadOnlyProperties(brain.OutputCamera);
+
+ state.Lens = lens;
+ return state;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 15ebf04de67923d41a36c21e1fc63718
+timeCreated: 1488314898
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using UnityEngine;
+
+namespace Cinemachine.Utility
+{
+ internal abstract class GaussianWindow1d<T>
+ {
+ protected T[] mData;
+ protected float[] mKernel;
+ protected float mKernelSum;
+ protected int mCurrentPos = -1;
+
+ public float Sigma { get; private set; } // Filter strength: bigger numbers are stronger. 0.5 is minimal.
+ public int KernelSize { get { return mKernel.Length; } }
+
+ void GenerateKernel(float sigma, int maxKernelRadius)
+ {
+ // Weight is close to 0 at a distance of sigma*3, so let's just cut it off a little early
+ int kernelRadius = Math.Min(maxKernelRadius, Mathf.FloorToInt(Mathf.Abs(sigma) * 2.5f));
+ mKernel = new float[2 * kernelRadius + 1];
+ mKernelSum = 0;
+ if (kernelRadius == 0)
+ mKernelSum = mKernel[0] = 1;
+ else for (int i = -kernelRadius; i <= kernelRadius; ++i)
+ {
+ mKernel[i + kernelRadius]
+ = (float)(Math.Exp(-(i * i) / (2 * sigma * sigma)) / Math.Sqrt(2.0 * Math.PI * sigma));
+ mKernelSum += mKernel[i + kernelRadius];
+ }
+ Sigma = sigma;
+ }
+
+ protected abstract T Compute(int windowPos);
+
+ public GaussianWindow1d(float sigma, int maxKernelRadius = 10)
+ {
+ GenerateKernel(sigma, maxKernelRadius);
+ mData = new T[KernelSize];
+ mCurrentPos = -1;
+ }
+
+ public void Reset() { mCurrentPos = -1; }
+
+ public bool IsEmpty() { return mCurrentPos < 0; }
+
+ public void AddValue(T v)
+ {
+ if (mCurrentPos < 0)
+ {
+ for (int i = 0; i < KernelSize; ++i)
+ mData[i] = v;
+ mCurrentPos = Mathf.Min(1, KernelSize-1);
+ }
+ mData[mCurrentPos] = v;
+ if (++mCurrentPos == KernelSize)
+ mCurrentPos = 0;
+ }
+
+ public T Filter(T v)
+ {
+ if (KernelSize < 3)
+ return v;
+ AddValue(v);
+ return Value();
+ }
+
+ /// Returned value will be kernelRadius old
+ public T Value() { return Compute(mCurrentPos); }
+
+ // Direct buffer access
+ public int BufferLength { get { return mData.Length; } }
+ public void SetBufferValue(int index, T value) { mData[index] = value; }
+ public T GetBufferValue(int index) { return mData[index]; }
+ }
+
+ internal class GaussianWindow1D_Vector3 : GaussianWindow1d<Vector3>
+ {
+ public GaussianWindow1D_Vector3(float sigma, int maxKernelRadius = 10)
+ : base(sigma, maxKernelRadius) {}
+
+ protected override Vector3 Compute(int windowPos)
+ {
+ Vector3 sum = Vector3.zero;
+ for (int i = 0; i < KernelSize; ++i)
+ {
+ sum += mData[windowPos] * mKernel[i];
+ if (++windowPos == KernelSize)
+ windowPos = 0;
+ }
+ return sum / mKernelSum;
+ }
+ }
+
+ internal class GaussianWindow1D_Quaternion : GaussianWindow1d<Quaternion>
+ {
+ public GaussianWindow1D_Quaternion(float sigma, int maxKernelRadius = 10)
+ : base(sigma, maxKernelRadius) {}
+ protected override Quaternion Compute(int windowPos)
+ {
+ Quaternion sum = new Quaternion(0, 0, 0, 0);
+ Quaternion q = mData[mCurrentPos];
+ Quaternion qInverse = Quaternion.Inverse(q);
+ for (int i = 0; i < KernelSize; ++i)
+ {
+ // Make sure the quaternion is in the same hemisphere, or averaging won't work
+ float scale = mKernel[i];
+ Quaternion q2 = qInverse * mData[windowPos];
+ if (Quaternion.Dot(Quaternion.identity, q2) < 0)
+ scale = -scale;
+ sum.x += q2.x * scale;
+ sum.y += q2.y * scale;
+ sum.z += q2.z * scale;
+ sum.w += q2.w * scale;
+
+ if (++windowPos == KernelSize)
+ windowPos = 0;
+ }
+ return q * sum;
+ }
+ }
+
+ internal class GaussianWindow1D_CameraRotation : GaussianWindow1d<Vector2>
+ {
+ public GaussianWindow1D_CameraRotation(float sigma, int maxKernelRadius = 10)
+ : base(sigma, maxKernelRadius) {}
+
+ protected override Vector2 Compute(int windowPos)
+ {
+ Vector2 sum = Vector2.zero;
+ Vector2 v = mData[mCurrentPos];
+ for (int i = 0; i < KernelSize; ++i)
+ {
+ Vector2 v2 = mData[windowPos] - v;
+ if (v2.y > 180f)
+ v2.y -= 360f;
+ if (v2.y < -180f)
+ v2.y += 360f;
+ sum += v2 * mKernel[i];
+ if (++windowPos == KernelSize)
+ windowPos = 0;
+ }
+ return v + (sum / mKernelSum);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 68839a4bf8790cd449d4043f5efb5aec
+timeCreated: 1490719908
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// An abstract representation of a virtual camera which lives within the Unity scene
+ /// </summary>
+ public interface ICinemachineCamera
+ {
+ /// <summary>
+ /// Gets the name of this virtual camera. For use when deciding how to blend
+ /// to or from this camera
+ /// </summary>
+ string Name { get; }
+
+ /// <summary>
+ /// Gets a brief debug description of this virtual camera, for use when displayiong debug info
+ /// </summary>
+ string Description { get; }
+
+ /// <summary>
+ /// Gets the priority of this <c>ICinemachineCamera</c>. The virtual camera
+ /// will be inserted into the global priority stack based on this value.
+ /// </summary>
+ int Priority { get; set; }
+
+ /// <summary>
+ /// The thing the camera wants to look at (aim). May be null.
+ /// </summary>
+ Transform LookAt { get; set; }
+
+ /// <summary>
+ /// The thing the camera wants to follow (moving camera). May be null.
+ /// </summary>
+ Transform Follow { get; set; }
+
+ /// <summary>
+ /// Camera state at the current time.
+ /// </summary>
+ CameraState State { get; }
+
+ /// <summary>
+ /// Gets the virtual camera game attached to this class.
+ /// </summary>
+ GameObject VirtualCameraGameObject { get; }
+
+ /// <summary>
+ /// Will return false if this references a deleted object
+ /// </summary>
+ bool IsValid { get; }
+
+ /// <summary>
+ /// For cameras that implement child cameras, returns the parent vcam, otherwise null.
+ /// </summary>
+ ICinemachineCamera ParentCamera { get; }
+
+ /// <summary>Check whether the vcam is a live child of this camera.</summary>
+ /// <param name="vcam">The Virtual Camera to check</param>
+ /// <param name="dominantChildOnly">If truw, will only return true if this vcam is the dominat live child</param>
+ /// <returns>True if the vcam is currently actively influencing the state of this vcam</returns>
+ bool IsLiveChild(ICinemachineCamera vcam, bool dominantChildOnly = false);
+
+ /// <summary>
+ /// Update the camera's state.
+ /// The implementation must guarantee against multiple calls per frame, and should
+ /// use CinemachineCore.UpdateVirtualCamera(ICinemachineCamera, Vector3, mfloat), which
+ /// has protection against multiple calls per frame.
+ /// </summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ void UpdateCameraState(Vector3 worldUp, float deltaTime);
+
+ /// <summary>
+ /// Updates this Cinemachine Camera. For an active camera this should be
+ /// called once and only once each frame. To guarantee this, you should never
+ /// call this method directly. Always use
+ /// CinemachineCore.UpdateVirtualCamera(ICinemachineCamera, Vector3, float), which
+ /// has protection against multiple calls per frame.
+ /// </summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ void InternalUpdateCameraState(Vector3 worldUp, float deltaTime);
+
+ /// <summary>
+ /// Notification that a new camera is being activated. This is sent to the
+ /// currently active camera. Both may be active simultaneously for a while, if blending.
+ /// </summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ void OnTransitionFromCamera(ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime);
+
+ /// <summary>This is called to notify the component that a target got warped,
+ /// so that the component can update its internal state to make the camera
+ /// also warp seamlessy. Base class implementation does nothing.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ void OnTargetObjectWarped(Transform target, Vector3 positionDelta);
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 2643ac9881a89594a80c242b565b34ec
+timeCreated: 1484407000
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+// This file is intentionally blank.
+// If you were implementing ICinemachineComponent interface, please refactor to
+// inherit from CinemachineComponentBase instead.
--- /dev/null
+fileFormatVersion: 2
+guid: 9a53087ba28aaf145a184ea363108831
+timeCreated: 1510078351
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Describes the FOV and clip planes for a camera. This generally mirrors the Unity Camera's
+ /// lens settings, and will be used to drive the Unity camera when the vcam is active.
+ /// </summary>
+ [Serializable]
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public struct LensSettings
+ {
+ /// <summary>Default Lens Settings</summary>
+ public static LensSettings Default = new LensSettings(40f, 10f, 0.1f, 5000f, 0);
+
+ /// <summary>
+ /// This is the camera view in vertical degrees. For cinematic people, a 50mm lens
+ /// on a super-35mm sensor would equal a 19.6 degree FOV
+ /// </summary>
+ [Range(1f, 179f)]
+ [Tooltip("This is the camera view in vertical degrees. For cinematic people, a 50mm lens on a super-35mm sensor would equal a 19.6 degree FOV")]
+ public float FieldOfView;
+
+ /// <summary>
+ /// When using an orthographic camera, this defines the height, in world
+ /// co-ordinates, of the camera view.
+ /// </summary>
+ [Tooltip("When using an orthographic camera, this defines the half-height, in world coordinates, of the camera view.")]
+ public float OrthographicSize;
+
+ /// <summary>
+ /// The near clip plane for this LensSettings
+ /// </summary>
+ [Tooltip("This defines the near region in the renderable range of the camera frustum. Raising this value will stop the game from drawing things near the camera, which can sometimes come in handy. Larger values will also increase your shadow resolution.")]
+ public float NearClipPlane;
+
+ /// <summary>
+ /// The far clip plane for this LensSettings
+ /// </summary>
+ [Tooltip("This defines the far region of the renderable range of the camera frustum. Typically you want to set this value as low as possible without cutting off desired distant objects")]
+ public float FarClipPlane;
+
+ /// <summary>
+ /// The dutch (tilt) to be applied to the camera. In degrees
+ /// </summary>
+ [Range(-180f, 180f)]
+ [Tooltip("Camera Z roll, or tilt, in degrees.")]
+ public float Dutch;
+
+ /// <summary>
+ /// This is set every frame by the virtual camera, based on the value found in the
+ /// currently associated Unity camera
+ /// </summary>
+ public bool Orthographic { get; set; }
+
+ /// <summary>
+ /// This is set every frame by the virtual camera, based on the value
+ /// found in the currently associated Unity camera
+ /// </summary>
+ public bool IsPhysicalCamera { get; set; }
+
+ /// <summary>
+ /// This is set every frame by the virtual camera, based on the value
+ /// found in the currently associated Unity camera
+ /// </summary>
+ public Vector2 SensorSize { get; set; }
+
+ /// <summary>
+ /// Sensor aspect, not screen aspect. For nonphysical cameras, this is the same thing.
+ /// </summary>
+ public float Aspect { get { return SensorSize.y == 0 ? 1f : (SensorSize.x / SensorSize.y); } }
+
+ /// <summary>For physical cameras only: position of the gate relative to the film back</summary>
+ public Vector2 LensShift;
+
+ /// <summary>
+ /// Creates a new LensSettings, copying the values from the
+ /// supplied Camera
+ /// </summary>
+ /// <param name="fromCamera">The Camera from which the FoV, near
+ /// and far clip planes will be copied.</param>
+ public static LensSettings FromCamera(Camera fromCamera)
+ {
+ LensSettings lens = Default;
+ if (fromCamera != null)
+ {
+ lens.FieldOfView = fromCamera.fieldOfView;
+ lens.OrthographicSize = fromCamera.orthographicSize;
+ lens.NearClipPlane = fromCamera.nearClipPlane;
+ lens.FarClipPlane = fromCamera.farClipPlane;
+#if UNITY_2018_2_OR_NEWER
+ lens.LensShift = fromCamera.lensShift;
+#endif
+ lens.SnapshotCameraReadOnlyProperties(fromCamera);
+ }
+ return lens;
+ }
+
+ /// <summary>
+ /// Snapshot the properties that are read-only in the Camera
+ /// </summary>
+ /// <param name="camera">The Camera from which we will take the info</param>
+ public void SnapshotCameraReadOnlyProperties(Camera camera)
+ {
+ if (camera != null)
+ {
+ Orthographic = camera.orthographic;
+ SensorSize = new Vector2(camera.aspect, 1f);
+#if UNITY_2018_2_OR_NEWER
+ IsPhysicalCamera = camera.usePhysicalProperties;
+ if (IsPhysicalCamera)
+ SensorSize = camera.sensorSize;
+ else
+ LensShift = Vector2.zero;
+#endif
+ }
+ }
+
+ /// <summary>
+ /// Snapshot the properties that are read-only in the Camera
+ /// </summary>
+ /// <param name="lens">The LensSettings from which we will take the info</param>
+ public void SnapshotCameraReadOnlyProperties(ref LensSettings lens)
+ {
+ Orthographic = lens.Orthographic;
+ SensorSize = lens.SensorSize;
+#if UNITY_2018_2_OR_NEWER
+ IsPhysicalCamera = lens.IsPhysicalCamera;
+ if (!IsPhysicalCamera)
+ LensShift = Vector2.zero;
+#endif
+ }
+
+ /// <summary>
+ /// Explicit constructor for this LensSettings
+ /// </summary>
+ /// <param name="fov">The Vertical field of view</param>
+ /// <param name="orthographicSize">If orthographic, this is the half-height of the screen</param>
+ /// <param name="nearClip">The near clip plane</param>
+ /// <param name="farClip">The far clip plane</param>
+ /// <param name="dutch">Camera roll, in degrees. This is applied at the end
+ /// after shot composition.</param>
+ public LensSettings(
+ float fov, float orthographicSize,
+ float nearClip, float farClip, float dutch) : this()
+ {
+ FieldOfView = fov;
+ OrthographicSize = orthographicSize;
+ NearClipPlane = nearClip;
+ FarClipPlane = farClip;
+ Dutch = dutch;
+ }
+
+ /// <summary>
+ /// Linearly blends the fields of two LensSettings and returns the result
+ /// </summary>
+ /// <param name="lensA">The LensSettings to blend from</param>
+ /// <param name="lensB">The LensSettings to blend to</param>
+ /// <param name="t">The interpolation value. Internally clamped to the range [0,1]</param>
+ /// <returns>Interpolated settings</returns>
+ public static LensSettings Lerp(LensSettings lensA, LensSettings lensB, float t)
+ {
+ t = Mathf.Clamp01(t);
+ LensSettings blendedLens = new LensSettings();
+ blendedLens.FarClipPlane = Mathf.Lerp(lensA.FarClipPlane, lensB.FarClipPlane, t);
+ blendedLens.NearClipPlane = Mathf.Lerp(lensA.NearClipPlane, lensB.NearClipPlane, t);
+ blendedLens.FieldOfView = Mathf.Lerp(lensA.FieldOfView, lensB.FieldOfView, t);
+ blendedLens.OrthographicSize = Mathf.Lerp(lensA.OrthographicSize, lensB.OrthographicSize, t);
+ blendedLens.Dutch = Mathf.Lerp(lensA.Dutch, lensB.Dutch, t);
+ blendedLens.Orthographic = lensA.Orthographic && lensB.Orthographic;
+ blendedLens.IsPhysicalCamera = lensA.IsPhysicalCamera || lensB.IsPhysicalCamera;
+ blendedLens.SensorSize = Vector2.Lerp(lensA.SensorSize, lensB.SensorSize, t);
+ blendedLens.LensShift = Vector2.Lerp(lensA.LensShift, lensB.LensShift, t);
+ return blendedLens;
+ }
+
+ /// <summary>Make sure lens settings are sane. Call this from OnValidate().</summary>
+ public void Validate()
+ {
+ NearClipPlane = Mathf.Max(NearClipPlane, Orthographic ? 0 : 0.01f);
+ FarClipPlane = Mathf.Max(FarClipPlane, NearClipPlane + 0.01f);
+ FieldOfView = Mathf.Clamp(FieldOfView, 0.1f, 179f);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 5778d22ca832d9f47b5e73a8c5fe78a2
+timeCreated: 1481654955
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using System;
+using UnityEngine.Serialization;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// This is an asset that defines a noise profile. A noise profile is the
+ /// shape of the noise signal as a function of time. You can build arbitrarily complex shapes by
+ /// combining different base perlin noise frequencies at different amplitudes.
+ ///
+ /// The frequencies and amplitudes should be chosen with care, to ensure an interesting
+ /// noise quality that is not obviously repetitive.
+ ///
+ /// As a mathematical side-note, any arbitrary periodic curve can be broken down into a
+ /// series of fixed-amplitude sine-waves added together. This is called fourier decomposition,
+ /// and is the basis of much signal processing. It doesn't really have much to do with this
+ /// asset, but it's super interesting!
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public sealed class NoiseSettings : SignalSourceAsset
+ {
+ /// <summary>Describes the behaviour for a channel of noise</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct NoiseParams
+ {
+ /// <summary>The frequency of noise for this channel. Higher magnitudes vibrate faster</summary>
+ [Tooltip("The frequency of noise for this channel. Higher magnitudes vibrate faster.")]
+ public float Frequency;
+
+ /// <summary>The amplitude of the noise for this channel. Larger numbers vibrate higher</summary>
+ [Tooltip("The amplitude of the noise for this channel. Larger numbers vibrate higher.")]
+ public float Amplitude;
+
+ /// <summary>If checked, then the amplitude and frequency will not be randomized</summary>
+ [Tooltip("If checked, then the amplitude and frequency will not be randomized.")]
+ public bool Constant;
+
+ /// <summary>Get the signal value at a given time, offset by a given amount</summary>
+ public float GetValueAt(float time, float timeOffset)
+ {
+ float t = (Frequency * time) + timeOffset;
+ if (Constant)
+ return Mathf.Cos(t * 2 * Mathf.PI) * Amplitude * 0.5f;
+ return (Mathf.PerlinNoise(t, 0f) - 0.5f) * Amplitude;
+ }
+ }
+
+ /// <summary>
+ /// Contains the behaviour of noise for the noise module for all 3 cardinal axes of the camera
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [Serializable]
+ public struct TransformNoiseParams
+ {
+ /// <summary>Noise definition for X-axis</summary>
+ [Tooltip("Noise definition for X-axis")]
+ public NoiseParams X;
+ /// <summary>Noise definition for Y-axis</summary>
+ [Tooltip("Noise definition for Y-axis")]
+ public NoiseParams Y;
+ /// <summary>Noise definition for Z-axis</summary>
+ [Tooltip("Noise definition for Z-axis")]
+ public NoiseParams Z;
+
+ /// <summary>Get the signal value at a given time, offset by a given amount</summary>
+ public Vector3 GetValueAt(float time, Vector3 timeOffsets)
+ {
+ return new Vector3(
+ X.GetValueAt(time, timeOffsets.x),
+ Y.GetValueAt(time, timeOffsets.y),
+ Z.GetValueAt(time, timeOffsets.z));
+ }
+ }
+
+ /// <summary>The array of positional noise channels for this <c>NoiseSettings</c></summary>
+ [Tooltip("These are the noise channels for the virtual camera's position. Convincing noise setups typically mix low, medium and high frequencies together, so start with a size of 3")]
+ [FormerlySerializedAs("m_Position")]
+ public TransformNoiseParams[] PositionNoise = new TransformNoiseParams[0];
+
+ /// <summary>The array of orientation noise channels for this <c>NoiseSettings</c></summary>
+ [Tooltip("These are the noise channels for the virtual camera's orientation. Convincing noise setups typically mix low, medium and high frequencies together, so start with a size of 3")]
+ [FormerlySerializedAs("m_Orientation")]
+ public TransformNoiseParams[] OrientationNoise = new TransformNoiseParams[0];
+
+ /// <summary>Get the noise signal value at a specific time</summary>
+ /// <param name="noiseParams">The parameters that define the noise function</param>
+ /// <param name="time">The time at which to sample the noise function</param>
+ /// <param name="timeOffsets">Start time offset for each channel</param>
+ /// <returns>The 3-channel noise signal value at the specified time</returns>
+ public static Vector3 GetCombinedFilterResults(
+ TransformNoiseParams[] noiseParams, float time, Vector3 timeOffsets)
+ {
+ Vector3 pos = Vector3.zero;
+ if (noiseParams != null)
+ {
+ for (int i = 0; i < noiseParams.Length; ++i)
+ pos += noiseParams[i].GetValueAt(time, timeOffsets);
+ }
+ return pos;
+ }
+
+ /// <summary>
+ /// Returns the total length in seconds of the signal.
+ /// Returns 0 for signals of indeterminate length.
+ /// </summary>
+ public override float SignalDuration { get { return 0; } }
+
+ /// <summary>Interface for raw signal provider</summary>
+ /// <param name="pos">The position impulse signal</param>
+ /// <param name="rot">The rotation impulse signal</param>
+ public override void GetSignal(float timeSinceSignalStart, out Vector3 pos, out Quaternion rot)
+ {
+ pos = GetCombinedFilterResults(PositionNoise, timeSinceSignalStart, Vector3.zero);
+ rot = Quaternion.Euler(GetCombinedFilterResults(OrientationNoise, timeSinceSignalStart, Vector3.zero));
+ }
+
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: b7f59e54f2bfd184b9dd451a678d089b
+timeCreated: 1481654957
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace Cinemachine.Utility
+{
+ public class PositionPredictor
+ {
+ Vector3 m_Position;
+
+ GaussianWindow1D_Vector3 m_Velocity = new GaussianWindow1D_Vector3(kSmoothingDefault);
+ GaussianWindow1D_Vector3 m_Accel = new GaussianWindow1D_Vector3(kSmoothingDefault);
+
+ float mLastVelAddedTime = 0;
+
+ const float kSmoothingDefault = 10;
+ float mSmoothing = kSmoothingDefault;
+ public float Smoothing
+ {
+ get { return mSmoothing; }
+ set
+ {
+ if (value != mSmoothing)
+ {
+ mSmoothing = value;
+ int maxRadius = Mathf.Max(10, Mathf.FloorToInt(value * 1.5f));
+ m_Velocity = new GaussianWindow1D_Vector3(mSmoothing, maxRadius);
+ m_Accel = new GaussianWindow1D_Vector3(mSmoothing, maxRadius);
+ }
+ }
+ }
+ public bool IsEmpty { get { return m_Velocity.IsEmpty(); } }
+
+ public void ApplyTransformDelta(Vector3 positionDelta)
+ {
+ m_Position += positionDelta;
+ }
+
+ public void Reset()
+ {
+ m_Velocity.Reset();
+ m_Accel.Reset();
+ }
+
+ public void AddPosition(Vector3 pos, float deltaTime, float lookaheadTime)
+ {
+ if (deltaTime < UnityVectorExtensions.Epsilon)
+ Reset();
+ else if (IsEmpty)
+ m_Velocity.AddValue(Vector3.zero);
+ else
+ {
+ Vector3 vel = (pos - m_Position) / deltaTime;
+ if (vel.sqrMagnitude > UnityVectorExtensions.Epsilon)
+ {
+ Vector3 vel0 = m_Velocity.Value();
+ float now = Time.time;
+ if (vel.sqrMagnitude >= vel0.sqrMagnitude
+ || Vector3.Angle(vel, vel0) > 10
+ || now > mLastVelAddedTime + lookaheadTime)
+ {
+ m_Velocity.AddValue(vel);
+ m_Accel.AddValue(vel - vel0);
+ mLastVelAddedTime = now;
+ }
+ }
+ }
+ m_Position = pos;
+ }
+
+ public Vector3 PredictPositionDelta(float lookaheadTime)
+ {
+ Vector3 vel = m_Velocity.IsEmpty() ? Vector3.zero : m_Velocity.Value();
+ Vector3 accel = m_Accel.IsEmpty() ? Vector3.zero : m_Accel.Value();
+ Vector3 delta = vel * lookaheadTime;
+ delta += accel * lookaheadTime * lookaheadTime * 0.5f;
+ return delta;
+ }
+
+ public Vector3 PredictPosition(float lookaheadTime)
+ {
+ return m_Position + PredictPositionDelta(lookaheadTime);
+ }
+ }
+
+ /// <summary>Utility to perform realistic damping of float or Vector3 values.
+ /// The algorithm is based on exponentially decaying the delta until only
+ /// a negligible amount remains.</summary>
+ public static class Damper
+ {
+ const float Epsilon = UnityVectorExtensions.Epsilon;
+
+ // Get the decay constant that would leave a given residual after a given time
+ static float DecayConstant(float time, float residual)
+ {
+ return Mathf.Log(1f / residual) / time;
+ }
+
+ // Exponential decay: decay a given quantity opver a period of time
+ static float DecayedRemainder(float initial, float decayConstant, float deltaTime)
+ {
+ return initial / Mathf.Exp(decayConstant * deltaTime);
+ }
+
+ /// <summary>Standard residual</summary>
+ public const float kNegligibleResidual = 0.01f;
+ const float kLogNegligibleResidual = -4.605170186f; // == math.Log(kNegligibleResidual=0.01f);
+
+ /// <summary>Get a damped version of a quantity. This is the portion of the
+ /// quantity that will take effect over the given time.</summary>
+ /// <param name="initial">The amount that will be damped</param>
+ /// <param name="dampTime">The rate of damping. This is the time it would
+ /// take to reduce the original amount to a negligible percentage</param>
+ /// <param name="deltaTime">The time over which to damp</param>
+ /// <returns>The damped amount. This will be the original amount scaled by
+ /// a value between 0 and 1.</returns>
+ public static float Damp(float initial, float dampTime, float deltaTime)
+ {
+ if (dampTime < Epsilon || Mathf.Abs(initial) < Epsilon)
+ return initial;
+ if (deltaTime < Epsilon)
+ return 0;
+ float k = -kLogNegligibleResidual / dampTime; //DecayConstant(dampTime, kNegligibleResidual);
+
+#if CINEMACHINE_EXPERIMENTAL_DAMPING
+ // Try to reduce damage caused by frametime variability
+ float step = Time.fixedDeltaTime;
+ if (deltaTime != step)
+ step /= 5;
+ int numSteps = Mathf.FloorToInt(deltaTime / step);
+ float vel = initial * step / deltaTime;
+ float decayConstant = Mathf.Exp(-k * step);
+ float r = 0;
+ for (int i = 0; i < numSteps; ++i)
+ r = (r + vel) * decayConstant;
+ float d = deltaTime - (step * numSteps);
+ if (d > Epsilon)
+ r = Mathf.Lerp(r, (r + vel) * decayConstant, d / step);
+ return initial - r;
+#else
+ return initial * (1 - Mathf.Exp(-k * deltaTime));
+#endif
+ }
+
+ /// <summary>Get a damped version of a quantity. This is the portion of the
+ /// quantity that will take effect over the given time.</summary>
+ /// <param name="initial">The amount that will be damped</param>
+ /// <param name="dampTime">The rate of damping. This is the time it would
+ /// take to reduce the original amount to a negligible percentage</param>
+ /// <param name="deltaTime">The time over which to damp</param>
+ /// <returns>The damped amount. This will be the original amount scaled by
+ /// a value between 0 and 1.</returns>
+ public static Vector3 Damp(Vector3 initial, Vector3 dampTime, float deltaTime)
+ {
+ for (int i = 0; i < 3; ++i)
+ initial[i] = Damp(initial[i], dampTime[i], deltaTime);
+ return initial;
+ }
+
+ /// <summary>Get a damped version of a quantity. This is the portion of the
+ /// quantity that will take effect over the given time.</summary>
+ /// <param name="initial">The amount that will be damped</param>
+ /// <param name="dampTime">The rate of damping. This is the time it would
+ /// take to reduce the original amount to a negligible percentage</param>
+ /// <param name="deltaTime">The time over which to damp</param>
+ /// <returns>The damped amount. This will be the original amount scaled by
+ /// a value between 0 and 1.</returns>
+ public static Vector3 Damp(Vector3 initial, float dampTime, float deltaTime)
+ {
+ for (int i = 0; i < 3; ++i)
+ initial[i] = Damp(initial[i], dampTime, deltaTime);
+ return initial;
+ }
+ }
+
+ /// <summary>Tracks an object's velocity with a filter to determine a reasonably
+ /// steady direction for the object's current trajectory.</summary>
+ public class HeadingTracker
+ {
+ struct Item
+ {
+ public Vector3 velocity;
+ public float weight;
+ public float time;
+ };
+ Item[] mHistory;
+ int mTop;
+ int mBottom;
+ int mCount;
+
+ Vector3 mHeadingSum;
+ float mWeightSum = 0;
+ float mWeightTime = 0;
+
+ Vector3 mLastGoodHeading = Vector3.zero;
+
+ /// <summary>Construct a heading tracker with a given filter size</summary>
+ /// <param name="filterSize">The size of the filter. The larger the filter, the
+ /// more constanct (and laggy) is the heading. 30 is pretty big.</param>
+ public HeadingTracker(int filterSize)
+ {
+ mHistory = new Item[filterSize];
+ float historyHalfLife = filterSize / 5f; // somewhat arbitrarily
+ mDecayExponent = -Mathf.Log(2f) / historyHalfLife;
+ ClearHistory();
+ }
+
+ /// <summary>Get the current filter size</summary>
+ public int FilterSize { get { return mHistory.Length; } }
+
+ void ClearHistory()
+ {
+ mTop = mBottom = mCount = 0;
+ mWeightSum = 0;
+ mHeadingSum = Vector3.zero;
+ }
+
+ static float mDecayExponent;
+ static float Decay(float time) { return Mathf.Exp(time * mDecayExponent); }
+
+ /// <summary>Add a new velocity frame. This should be called once per frame,
+ /// unless the velocity is zero</summary>
+ /// <param name="velocity">The object's velocity this frame</param>
+ public void Add(Vector3 velocity)
+ {
+ if (FilterSize == 0)
+ {
+ mLastGoodHeading = velocity;
+ return;
+ }
+ float weight = velocity.magnitude;
+ if (weight > UnityVectorExtensions.Epsilon)
+ {
+ Item item = new Item();
+ item.velocity = velocity;
+ item.weight = weight;
+ item.time = Time.time;
+ if (mCount == FilterSize)
+ PopBottom();
+ ++mCount;
+ mHistory[mTop] = item;
+ if (++mTop == FilterSize)
+ mTop = 0;
+
+ mWeightSum *= Decay(item.time - mWeightTime);
+ mWeightTime = item.time;
+ mWeightSum += weight;
+ mHeadingSum += item.velocity;
+ }
+ }
+
+ void PopBottom()
+ {
+ if (mCount > 0)
+ {
+ float time = Time.time;
+ Item item = mHistory[mBottom];
+ if (++mBottom == FilterSize)
+ mBottom = 0;
+ --mCount;
+
+ float decay = Decay(time - item.time);
+ mWeightSum -= item.weight * decay;
+ mHeadingSum -= item.velocity * decay;
+ if (mWeightSum <= UnityVectorExtensions.Epsilon || mCount == 0)
+ ClearHistory();
+ }
+ }
+
+ /// <summary>Decay the history. This should be called every frame.</summary>
+ public void DecayHistory()
+ {
+ float time = Time.time;
+ float decay = Decay(time - mWeightTime);
+ mWeightSum *= decay;
+ mWeightTime = time;
+ if (mWeightSum < UnityVectorExtensions.Epsilon)
+ ClearHistory();
+ else
+ mHeadingSum = mHeadingSum * decay;
+ }
+
+ /// <summary>Get the filtered heading.</summary>
+ /// <returns>The filtered direction of motion</returns>
+ public Vector3 GetReliableHeading()
+ {
+ // Update Last Good Heading
+ if (mWeightSum > UnityVectorExtensions.Epsilon
+ && (mCount == mHistory.Length || mLastGoodHeading.AlmostZero()))
+ {
+ Vector3 h = mHeadingSum / mWeightSum;
+ if (!h.AlmostZero())
+ mLastGoodHeading = h.normalized;
+ }
+ return mLastGoodHeading;
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 6cef82e891a45884fb2b70604b0f8c29
+timeCreated: 1505225008
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>An ad-hoc collection of helpers, used by Cinemachine
+ /// or its editor tools in various places</summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.Undoc)]
+ public static class RuntimeUtility
+ {
+ /// <summary>Convenience to destroy an object, using the appropriate method depending
+ /// on whether the game is playing</summary>
+ /// <param name="obj">The object to destroy</param>
+ public static void DestroyObject(UnityEngine.Object obj)
+ {
+ if (obj != null)
+ {
+#if UNITY_EDITOR
+ if (Application.isPlaying)
+ UnityEngine.Object.Destroy(obj);
+ else
+ UnityEngine.Object.DestroyImmediate(obj);
+#else
+ UnityEngine.Object.Destroy(obj);
+#endif
+ }
+ }
+ }
+}
+
--- /dev/null
+fileFormatVersion: 2
+guid: b567991935cb6844d9bb65eda22b628f
+timeCreated: 1517952341
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>Interface for raw signal provider</summary>
+ public interface ISignalSource6D
+ {
+ /// <summary>
+ /// Returns the length on seconds of the signal.
+ /// Returns 0 for signals of indeterminate length.
+ /// </summary>
+ float SignalDuration { get; }
+
+ /// <summary>Get the signal value at a given time relative to signal start</summary>
+ /// <param name="timeSinceSignalStart">Time since signal start. Always >= 0</param>
+ /// <param name="pos">output for position component of the signal</param>
+ /// <param name="rot">output for rotation component of the signal. Use Quaternion.identity if none.</param>
+ void GetSignal(float timeSinceSignalStart, out Vector3 pos, out Quaternion rot);
+ }
+
+ /// <summary>
+ /// This is an asset that defines a 6D signal that can be retrieved in a random-access fashion.
+ /// This is used by the Cinemachine Impulse module.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.API)]
+ public abstract class SignalSourceAsset : ScriptableObject, ISignalSource6D
+ {
+ /// <summary>
+ /// Returns the length on seconds of the signal.
+ /// Returns 0 for signals of indeterminate length.
+ /// </summary>
+ public abstract float SignalDuration { get; }
+
+ /// <summary>Get the signal value at a given time relative to signal start</summary>
+ /// <param name="timeSinceSignalStart">Time since signal start. Always >= 0</param>
+ /// <param name="pos">output for position component of the signal</param>
+ /// <param name="rot">output for rotation component of the signal. Use Quaternion.identity if none.</param>
+ public abstract void GetSignal(
+ float timeSinceSignalStart, out Vector3 pos, out Quaternion rot);
+ }
+
+}
\ No newline at end of file
--- /dev/null
+fileFormatVersion: 2
+guid: cebc3fe47a919524eb4a977f726a484e
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine.Utility
+{
+ public static class SplineHelpers
+ {
+ public static Vector3 Bezier3(
+ float t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3)
+ {
+ t = Mathf.Clamp01(t);
+ float d = 1f - t;
+ return d * d * d * p0 + 3f * d * d * t * p1
+ + 3f * d * t * t * p2 + t * t * t * p3;
+ }
+
+ public static Vector3 BezierTangent3(
+ float t, Vector3 p0, Vector3 p1, Vector3 p2, Vector3 p3)
+ {
+ t = Mathf.Clamp01(t);
+ return (-3f * p0 + 9f * p1 - 9f * p2 + 3f * p3) * t * t
+ + (6f * p0 - 12f * p1 + 6f * p2) * t
+ - 3f * p0 + 3f * p1;
+ }
+
+ public static float Bezier1(float t, float p0, float p1, float p2, float p3)
+ {
+ t = Mathf.Clamp01(t);
+ float d = 1f - t;
+ return d * d * d * p0 + 3f * d * d * t * p1
+ + 3f * d * t * t * p2 + t * t * t * p3;
+ }
+
+ public static float BezierTangent1(
+ float t, float p0, float p1, float p2, float p3)
+ {
+ t = Mathf.Clamp01(t);
+ return (-3f * p0 + 9f * p1 - 9f * p2 + 3f * p3) * t * t
+ + (6f * p0 - 12f * p1 + 6f * p2) * t
+ - 3f * p0 + 3f * p1;
+ }
+
+ public static void ComputeSmoothControlPoints(
+ ref Vector4[] knot, ref Vector4[] ctrl1, ref Vector4[] ctrl2)
+ {
+ int numPoints = knot.Length;
+ if (numPoints <= 2)
+ {
+ if (numPoints == 2)
+ {
+ ctrl1[0] = Vector4.Lerp(knot[0], knot[1], 0.33333f);
+ ctrl2[0] = Vector4.Lerp(knot[0], knot[1], 0.66666f);
+ }
+ else if (numPoints == 1)
+ ctrl1[0] = ctrl2[0] = knot[0];
+ return;
+ }
+
+ var a = new float[numPoints];
+ var b = new float[numPoints];
+ var c = new float[numPoints];
+ var r = new float[numPoints];
+ for (int axis = 0; axis < 4; ++axis)
+ {
+ int n = numPoints - 1;
+
+ // Linear into the first segment
+ a[0] = 0;
+ b[0] = 2;
+ c[0] = 1;
+ r[0] = knot[0][axis] + 2 * knot[1][axis];
+
+ // Internal segments
+ for (int i = 1; i < n - 1; ++i)
+ {
+ a[i] = 1;
+ b[i] = 4;
+ c[i] = 1;
+ r[i] = 4 * knot[i][axis] + 2 * knot[i+1][axis];
+ }
+
+ // Linear out of the last segment
+ a[n - 1] = 2;
+ b[n - 1] = 7;
+ c[n - 1] = 0;
+ r[n - 1] = 8 * knot[n - 1][axis] + knot[n][axis];
+
+ // Solve with Thomas algorithm
+ for (int i = 1; i < n; ++i)
+ {
+ float m = a[i] / b[i-1];
+ b[i] = b[i] - m * c[i-1];
+ r[i] = r[i] - m * r[i-1];
+ }
+
+ // Compute ctrl1
+ ctrl1[n-1][axis] = r[n-1] / b[n-1];
+ for (int i = n - 2; i >= 0; --i)
+ ctrl1[i][axis] = (r[i] - c[i] * ctrl1[i + 1][axis]) / b[i];
+
+ // Compute ctrl2 from ctrl1
+ for (int i = 0; i < n; i++)
+ ctrl2[i][axis] = 2 * knot[i + 1][axis] - ctrl1[i + 1][axis];
+ ctrl2[n - 1][axis] = 0.5f * (knot[n][axis] + ctrl1[n - 1][axis]);
+ }
+ }
+
+ public static void ComputeSmoothControlPointsLooped(
+ ref Vector4[] knot, ref Vector4[] ctrl1, ref Vector4[] ctrl2)
+ {
+ int numPoints = knot.Length;
+ if (numPoints < 2)
+ {
+ if (numPoints == 1)
+ ctrl1[0] = ctrl2[0] = knot[0];
+ return;
+ }
+
+ int margin = Mathf.Min(4, numPoints-1);
+ Vector4[] knotLooped = new Vector4[numPoints + 2 * margin];
+ Vector4[] ctrl1Looped = new Vector4[numPoints + 2 * margin];
+ Vector4[] ctrl2Looped = new Vector4[numPoints + 2 * margin];
+ for (int i = 0; i < margin; ++i)
+ {
+ knotLooped[i] = knot[numPoints-(margin-i)];
+ knotLooped[numPoints+margin+i] = knot[i];
+ }
+ for (int i = 0; i < numPoints; ++i)
+ knotLooped[i + margin] = knot[i];
+ ComputeSmoothControlPoints(ref knotLooped, ref ctrl1Looped, ref ctrl2Looped);
+ for (int i = 0; i < numPoints; ++i)
+ {
+ ctrl1[i] = ctrl1Looped[i + margin];
+ ctrl2[i] = ctrl2Looped[i + margin];
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: fca2bf25139920d4f9bf86711457992e
+timeCreated: 1505844077
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine.Utility
+{
+ /// <summary>Extensions to the Vector3 class, used by Cinemachine</summary>
+ public static class UnityVectorExtensions
+ {
+ /// <summary>A useful Epsilon</summary>
+ public const float Epsilon = 0.0001f;
+
+ /// <summary>
+ /// Get the closest point on a line segment.
+ /// </summary>
+ /// <param name="p">A point in space</param>
+ /// <param name="s0">Start of line segment</param>
+ /// <param name="s1">End of line segment</param>
+ /// <returns>The interpolation parameter representing the point on the segment, with 0==s0, and 1==s1</returns>
+ public static float ClosestPointOnSegment(this Vector3 p, Vector3 s0, Vector3 s1)
+ {
+ Vector3 s = s1 - s0;
+ float len2 = Vector3.SqrMagnitude(s);
+ if (len2 < Epsilon)
+ return 0; // degenrate segment
+ return Mathf.Clamp01(Vector3.Dot(p - s0, s) / len2);
+ }
+
+ /// <summary>
+ /// Get the closest point on a line segment.
+ /// </summary>
+ /// <param name="p">A point in space</param>
+ /// <param name="s0">Start of line segment</param>
+ /// <param name="s1">End of line segment</param>
+ /// <returns>The interpolation parameter representing the point on the segment, with 0==s0, and 1==s1</returns>
+ public static float ClosestPointOnSegment(this Vector2 p, Vector2 s0, Vector2 s1)
+ {
+ Vector2 s = s1 - s0;
+ float len2 = Vector2.SqrMagnitude(s);
+ if (len2 < Epsilon)
+ return 0; // degenrate segment
+ return Mathf.Clamp01(Vector2.Dot(p - s0, s) / len2);
+ }
+
+ /// <summary>
+ /// Returns a non-normalized projection of the supplied vector onto a plane
+ /// as described by its normal
+ /// </summary>
+ /// <param name="vector"></param>
+ /// <param name="planeNormal">The normal that defines the plane. Must have a length of 1.</param>
+ /// <returns>The component of the vector that lies in the plane</returns>
+ public static Vector3 ProjectOntoPlane(this Vector3 vector, Vector3 planeNormal)
+ {
+ return (vector - Vector3.Dot(vector, planeNormal) * planeNormal);
+ }
+
+ /// <summary>
+ /// Component-wise absolute value
+ /// </summary>
+ /// <param name="v"></param>
+ /// <returns></returns>
+ public static Vector3 Abs(this Vector3 v)
+ {
+ return new Vector3(Mathf.Abs(v.x), Mathf.Abs(v.y), Mathf.Abs(v.z));
+ }
+
+ /// <summary>Is the vector within Epsilon of zero length?</summary>
+ /// <param name="v"></param>
+ /// <returns>True if the square magnitude of the vector is within Epsilon of zero</returns>
+ public static bool AlmostZero(this Vector3 v)
+ {
+ return v.sqrMagnitude < (Epsilon * Epsilon);
+ }
+
+ /// <summary>Much more stable for small angles than Unity's native implementation</summary>
+ public static float Angle(Vector3 v1, Vector3 v2)
+ {
+#if false // Maybe this version is better? to test....
+ float a = v1.magnitude;
+ v1 *= v2.magnitude;
+ v2 *= a;
+ return Mathf.Atan2((v1 - v2).magnitude, (v1 + v2).magnitude) * Mathf.Rad2Deg * 2;
+#else
+ v1.Normalize();
+ v2.Normalize();
+ return Mathf.Atan2((v1 - v2).magnitude, (v1 + v2).magnitude) * Mathf.Rad2Deg * 2;
+#endif
+ }
+
+ /// <summary>Much more stable for small angles than Unity's native implementation</summary>
+ public static float SignedAngle(Vector3 v1, Vector3 v2, Vector3 up)
+ {
+ float angle = Angle(v1, v2);
+ if (Mathf.Sign(Vector3.Dot(up, Vector3.Cross(v1, v2))) < 0)
+ return -angle;
+ return angle;
+ }
+
+ /// <summary>This is a slerp that mimics a camera operator's movement in that
+ /// it chooses a path that avoids the lower hemisphere, as defined by
+ /// the up param</summary>
+ /// <param name="vA">First direction</param>
+ /// <param name="vB">Second direction</param>
+ /// <param name="t">Interpolation amoun t</param>
+ /// <param name="up">Defines the up direction</param>
+ public static Vector3 SlerpWithReferenceUp(
+ Vector3 vA, Vector3 vB, float t, Vector3 up)
+ {
+ float dA = vA.magnitude;
+ float dB = vB.magnitude;
+ if (dA < Epsilon || dB < Epsilon)
+ return Vector3.Lerp(vA, vB, t);
+
+ Vector3 dirA = vA / dA;
+ Vector3 dirB = vB / dB;
+ Quaternion qA = Quaternion.LookRotation(dirA, up);
+ Quaternion qB = Quaternion.LookRotation(dirB, up);
+ Quaternion q = UnityQuaternionExtensions.SlerpWithReferenceUp(qA, qB, t, up);
+ Vector3 dir = q * Vector3.forward;
+ return dir * Mathf.Lerp(dA, dB, t);
+ }
+ }
+
+ /// <summary>Extensions to the Quaternion class, usen in various places by Cinemachine</summary>
+ public static class UnityQuaternionExtensions
+ {
+ /// <summary>This is a slerp that mimics a camera operator's movement in that
+ /// it chooses a path that avoids the lower hemisphere, as defined by
+ /// the up param</summary>
+ /// <param name="qA">First direction</param>
+ /// <param name="qB">Second direction</param>
+ /// <param name="t">Interpolation amoun t</param>
+ /// <param name="up">Defines the up direction. Must have a length of 1.</param>
+ public static Quaternion SlerpWithReferenceUp(
+ Quaternion qA, Quaternion qB, float t, Vector3 up)
+ {
+ Vector3 dirA = (qA * Vector3.forward).ProjectOntoPlane(up);
+ Vector3 dirB = (qB * Vector3.forward).ProjectOntoPlane(up);
+ if (dirA.AlmostZero() || dirB.AlmostZero())
+ return Quaternion.Slerp(qA, qB, t);
+
+ // Work on the plane, in eulers
+ Quaternion qBase = Quaternion.LookRotation(dirA, up);
+ Quaternion qA1 = Quaternion.Inverse(qBase) * qA;
+ Quaternion qB1 = Quaternion.Inverse(qBase) * qB;
+ Vector3 eA = qA1.eulerAngles;
+ Vector3 eB = qB1.eulerAngles;
+ return qBase * Quaternion.Euler(
+ Mathf.LerpAngle(eA.x, eB.x, t),
+ Mathf.LerpAngle(eA.y, eB.y, t),
+ Mathf.LerpAngle(eA.z, eB.z, t));
+ }
+
+ /// <summary>Normalize a quaternion</summary>
+ /// <param name="q"></param>
+ /// <returns>The normalized quaternion. Unit length is 1.</returns>
+ public static Quaternion Normalized(this Quaternion q)
+ {
+ Vector4 v = new Vector4(q.x, q.y, q.z, q.w).normalized;
+ return new Quaternion(v.x, v.y, v.z, v.w);
+ }
+
+ /// <summary>
+ /// Get the rotations, first about world up, then about (travelling) local right,
+ /// necessary to align the quaternion's forward with the target direction.
+ /// This represents the tripod head movement needed to look at the target.
+ /// This formulation makes it easy to interpolate without introducing spurious roll.
+ /// </summary>
+ /// <param name="orient"></param>
+ /// <param name="lookAtDir">The worldspace target direction in which we want to look</param>
+ /// <param name="worldUp">Which way is up. Must have a length of 1.</param>
+ /// <returns>Vector2.y is rotation about worldUp, and Vector2.x is second rotation,
+ /// about local right.</returns>
+ public static Vector2 GetCameraRotationToTarget(
+ this Quaternion orient, Vector3 lookAtDir, Vector3 worldUp)
+ {
+ if (lookAtDir.AlmostZero())
+ return Vector2.zero; // degenerate
+
+ // Work in local space
+ Quaternion toLocal = Quaternion.Inverse(orient);
+ Vector3 up = toLocal * worldUp;
+ lookAtDir = toLocal * lookAtDir;
+
+ // Align yaw based on world up
+ float angleH = 0;
+ {
+ Vector3 targetDirH = lookAtDir.ProjectOntoPlane(up);
+ if (!targetDirH.AlmostZero())
+ {
+ Vector3 currentDirH = Vector3.forward.ProjectOntoPlane(up);
+ if (currentDirH.AlmostZero())
+ {
+ // We're looking at the north or south pole
+ if (Vector3.Dot(currentDirH, up) > 0)
+ currentDirH = Vector3.down.ProjectOntoPlane(up);
+ else
+ currentDirH = Vector3.up.ProjectOntoPlane(up);
+ }
+ angleH = UnityVectorExtensions.SignedAngle(currentDirH, targetDirH, up);
+ }
+ }
+ Quaternion q = Quaternion.AngleAxis(angleH, up);
+
+ // Get local vertical angle
+ float angleV = UnityVectorExtensions.SignedAngle(
+ q * Vector3.forward, lookAtDir, q * Vector3.right);
+
+ return new Vector2(angleV, angleH);
+ }
+
+ /// <summary>
+ /// Apply rotations, first about world up, then about (travelling) local right.
+ /// rot.y is rotation about worldUp, and rot.x is second rotation, about local right.
+ /// </summary>
+ /// <param name="orient"></param>
+ /// <param name="rot">Vector2.y is rotation about worldUp, and Vector2.x is second rotation,
+ /// about local right.</param>
+ /// <param name="worldUp">Which way is up</param>
+ public static Quaternion ApplyCameraRotation(
+ this Quaternion orient, Vector2 rot, Vector3 worldUp)
+ {
+ Quaternion q = Quaternion.AngleAxis(rot.x, Vector3.right);
+ return (Quaternion.AngleAxis(rot.y, worldUp) * orient) * q;
+ }
+ }
+
+ /// <summary>Ad-hoc xxtentions to the Rect structure, used by Cinemachine</summary>
+ public static class UnityRectExtensions
+ {
+ /// <summary>Inflate a rect</summary>
+ /// <param name="r"></param>
+ /// <param name="delta">x and y are added/subtracted fto/from the edges of
+ /// the rect, inflating it in all directions</param>
+ /// <returns>The inflated rect</returns>
+ public static Rect Inflated(this Rect r, Vector2 delta)
+ {
+ return new Rect(
+ r.xMin - delta.x, r.yMin - delta.y,
+ r.width + delta.x * 2, r.height + delta.y * 2);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 6a0472cd31396f741969b8c1af8dd5a0
+timeCreated: 1481654955
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+//#define DEBUG_LOG_NAME
+
+using UnityEngine;
+using System.Collections.Generic;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Attempt to track on what clock transforms get updated
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.Undoc)]
+ internal class UpdateTracker
+ {
+ public enum UpdateClock { Fixed, Late }
+
+ class UpdateStatus
+ {
+ const int kWindowSize = 30;
+ int windowStart;
+ int numWindowLateUpdateMoves;
+ int numWindowFixedUpdateMoves;
+ int numWindows;
+ int lastFrameUpdated;
+ Matrix4x4 lastPos;
+#if DEBUG_LOG_NAME
+ string name;
+#endif
+ public UpdateClock PreferredUpdate { get; private set; }
+
+#if DEBUG_LOG_NAME
+ public UpdateStatus(string targetName, int currentFrame, Matrix4x4 pos)
+ {
+ name = targetName;
+#else
+ public UpdateStatus(int currentFrame, Matrix4x4 pos)
+ {
+#endif
+ windowStart = currentFrame;
+ lastFrameUpdated = Time.frameCount;
+ PreferredUpdate = UpdateClock.Late;
+ lastPos = pos;
+ }
+
+ public void OnUpdate(int currentFrame, UpdateClock currentClock, Matrix4x4 pos)
+ {
+ if (lastPos == pos)
+ return;
+
+ if (currentClock == UpdateClock.Late)
+ ++numWindowLateUpdateMoves;
+ else if (lastFrameUpdated != currentFrame) // only count 1 per rendered frame
+ ++numWindowFixedUpdateMoves;
+ lastPos = pos;
+
+ UpdateClock choice;
+ if (numWindowFixedUpdateMoves > 3 && numWindowLateUpdateMoves < numWindowFixedUpdateMoves / 3)
+ choice = UpdateClock.Fixed;
+ else
+ choice = UpdateClock.Late;
+ if (numWindows == 0)
+ PreferredUpdate = choice;
+
+ if (windowStart + kWindowSize <= currentFrame)
+ {
+#if DEBUG_LOG_NAME
+ Debug.Log(name + ": Window " + numWindows + ": Late=" + numWindowLateUpdateMoves + ", Fixed=" + numWindowFixedUpdateMoves);
+#endif
+ PreferredUpdate = choice;
+ ++numWindows;
+ windowStart = currentFrame;
+ numWindowLateUpdateMoves = (PreferredUpdate == UpdateClock.Late) ? 1 : 0;
+ numWindowFixedUpdateMoves = (PreferredUpdate == UpdateClock.Fixed) ? 1 : 0;
+ }
+ }
+ }
+ static Dictionary<Transform, UpdateStatus> mUpdateStatus
+ = new Dictionary<Transform, UpdateStatus>();
+
+ [RuntimeInitializeOnLoadMethod]
+ static void InitializeModule() { mUpdateStatus.Clear(); }
+
+ static List<Transform> sToDelete = new List<Transform>();
+ static void UpdateTargets(UpdateClock currentClock)
+ {
+ // Update the registry for all known targets
+ int now = Time.frameCount;
+ var iter = mUpdateStatus.GetEnumerator();
+ while (iter.MoveNext())
+ {
+ var current = iter.Current;
+ if (current.Key == null)
+ sToDelete.Add(current.Key); // target was deleted
+ else
+ current.Value.OnUpdate(now, currentClock, current.Key.localToWorldMatrix);
+ }
+ for (int i = sToDelete.Count-1; i >= 0; --i)
+ mUpdateStatus.Remove(sToDelete[i]);
+ sToDelete.Clear();
+ }
+
+ public static UpdateClock GetPreferredUpdate(Transform target)
+ {
+ if (Application.isPlaying && target != null)
+ {
+ UpdateStatus status;
+ if (mUpdateStatus.TryGetValue(target, out status))
+ return status.PreferredUpdate;
+
+ // Add the target to the registry
+#if DEBUG_LOG_NAME
+ status = new UpdateStatus(target.name, Time.frameCount, target.localToWorldMatrix);
+#else
+ status = new UpdateStatus(Time.frameCount, target.localToWorldMatrix);
+#endif
+ mUpdateStatus.Add(target, status);
+ }
+ return UpdateClock.Late;
+ }
+
+ static float mLastUpdateTime;
+ public static void OnUpdate(UpdateClock currentClock)
+ {
+ // Do something only if we are the first controller processing this frame
+ float now = Time.time;
+ if (now != mLastUpdateTime)
+ {
+ mLastUpdateTime = now;
+ UpdateTargets(currentClock);
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 41a7beeb0ec57584382c8170981d8ac1
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 924d241f19612fa45bd388dc28955fad
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS || CINEMACHINE_PHYSICS_2D
+
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+using UnityEngine.Playables;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// A multi-purpose script which causes an action to occur when
+ /// a trigger collider is entered and exited.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [SaveDuringPlay]
+ public class CinemachineTriggerAction : MonoBehaviour
+ {
+ /// <summary>Only triggers generated by objects on these layers will be considered.</summary>
+ [Header("Trigger Object Filter")]
+ [Tooltip("Only triggers generated by objects on these layers will be considered")]
+ public LayerMask m_LayerMask = 1;
+
+ /// <summary>If set, only triggers generated by objects with this tag will be considered</summary>
+ [TagField]
+ [Tooltip("If set, only triggers generated by objects with this tag will be considered")]
+ public string m_WithTag = string.Empty;
+
+ /// <summary>Triggers generated by objects with this tag will be ignored</summary>
+ [TagField]
+ [Tooltip("Triggers generated by objects with this tag will be ignored")]
+ public string m_WithoutTag = string.Empty;
+
+ /// <summary>Skip this many trigger entries before taking action</summary>
+ [NoSaveDuringPlay]
+ [Tooltip("Skip this many trigger entries before taking action")]
+ public int m_SkipFirst = 0;
+
+ /// <summary>Repeat the action for all subsequent trigger entries</summary>
+ [Tooltip("Repeat the action for all subsequent trigger entries")]
+ public bool m_Repeating = true;
+
+ /// <summary>Defines what action to take on trigger enter/exit</summary>
+ [Serializable]
+ public struct ActionSettings
+ {
+ /// <summary>What action to take</summary>
+ public enum Mode
+ {
+ /// <summary>Use the event only</summary>
+ Custom,
+ /// <summary>Boost priority of virtual camera target</summary>
+ PriorityBoost,
+ /// <summary>Activate the target GameObject</summary>
+ Activate,
+ /// <summary>Decativate target GameObject</summary>
+ Deactivate,
+ /// <summary>Enable a component</summary>
+ Enable,
+ /// <summary>Disable a component</summary>
+ Disable,
+ /// <summary>Start animation on target</summary>
+ Play,
+ /// <summary>Stop animation on target</summary>
+ Stop
+ }
+
+ /// <summary>Serializable parameterless game event</summary>
+ [Serializable] public class TriggerEvent : UnityEvent {}
+
+ /// <summary>What action to take</summary>
+ [Tooltip("What action to take")]
+ public Mode m_Action;
+
+ /// <summary>The target object on which to operate. If null, then the current behaviour/GameObject will be used</summary>
+ [Tooltip("The target object on which to operate. If null, then the current behaviour/GameObject will be used")]
+ public UnityEngine.Object m_Target;
+
+ /// <summary>If PriorityBoost, this amount will be added to the virtual camera's priority</summary>
+ [Tooltip("If PriorityBoost, this amount will be added to the virtual camera's priority")]
+ public int m_BoostAmount;
+
+ /// <summary>If playing a timeline, start at this time</summary>
+ [Tooltip("If playing a timeline, start at this time")]
+ public float m_StartTime;
+
+ /// <summary>How to interpret the start time</summary>
+ public enum TimeMode { FromStart, FromEnd, BeforeNow, AfterNow };
+
+ /// <summary>How to interpret the start time</summary>
+ [Tooltip("How to interpret the start time")]
+ public TimeMode m_Mode;
+
+ /// <summary>This event will be invoked</summary>
+ [Tooltip("This event will be invoked")]
+ public TriggerEvent m_Event;
+
+ /// <summary>Constructor</summary>
+ public ActionSettings(Mode action)
+ {
+ m_Action = action;
+ m_Target = null;
+ m_BoostAmount = 0;
+ m_StartTime = 0;
+ m_Mode = TimeMode.FromStart;
+ m_Event = new TriggerEvent();
+ }
+
+ /// <summary>Invoke the action. Depending on the mode, different action will
+ /// be performed. The embedded event will always be invoked, in addition to the
+ /// action specified by the Mode.</summary>
+ public void Invoke()
+ {
+ UnityEngine.Object currentTarget = m_Target;
+ if (currentTarget != null)
+ {
+ GameObject targetGameObject = currentTarget as GameObject;
+ Behaviour targetBehaviour = currentTarget as Behaviour;
+ if (targetBehaviour != null)
+ targetGameObject = targetBehaviour.gameObject;
+
+ switch (m_Action)
+ {
+ case Mode.Custom:
+ break;
+ case Mode.PriorityBoost:
+ {
+ CinemachineVirtualCameraBase vcam
+ = targetGameObject.GetComponent<CinemachineVirtualCameraBase>();
+ if (vcam != null)
+ {
+ vcam.Priority += m_BoostAmount;
+ vcam.MoveToTopOfPrioritySubqueue();
+ }
+ break;
+ }
+ case Mode.Activate:
+ if (targetGameObject != null)
+ {
+ targetGameObject.SetActive(true);
+ CinemachineVirtualCameraBase vcam
+ = targetGameObject.GetComponent<CinemachineVirtualCameraBase>();
+ if (vcam != null)
+ vcam.MoveToTopOfPrioritySubqueue();
+ }
+ break;
+ case Mode.Deactivate:
+ if (targetGameObject != null)
+ targetGameObject.SetActive(false);
+ break;
+ case Mode.Enable:
+ {
+ if (targetBehaviour != null)
+ targetBehaviour.enabled = true;
+ break;
+ }
+ case Mode.Disable:
+ {
+ if (targetBehaviour != null)
+ targetBehaviour.enabled = false;
+ break;
+ }
+ case Mode.Play:
+ {
+ PlayableDirector playable
+ = targetGameObject.GetComponent<PlayableDirector>();
+ if (playable != null)
+ {
+ double startTime = 0;
+ double duration = playable.duration;
+ double current = playable.time;
+ switch (m_Mode)
+ {
+ default:
+ case TimeMode.FromStart:
+ startTime += m_StartTime;
+ break;
+ case TimeMode.FromEnd:
+ startTime = duration - m_StartTime;
+ break;
+ case TimeMode.BeforeNow:
+ startTime = current - m_StartTime;
+ break;
+ case TimeMode.AfterNow:
+ startTime = current + m_StartTime;
+ break;
+ }
+ playable.time = startTime;
+ playable.Play();
+ }
+ else
+ {
+ Animation ani = targetGameObject.GetComponent<Animation>();
+ if (ani != null)
+ ani.Play();
+ }
+ break;
+ }
+ case Mode.Stop:
+ {
+ PlayableDirector playable
+ = targetGameObject.GetComponent<PlayableDirector>();
+ if (playable != null)
+ playable.Stop();
+ else
+ {
+ Animation ani = targetGameObject.GetComponent<Animation>();
+ if (ani != null)
+ ani.Stop();
+ }
+ break;
+ }
+ }
+ }
+ m_Event.Invoke();
+ }
+ }
+
+ /// <summary>What action to take when an eligible object enters the collider or trigger zone</summary>
+ public ActionSettings m_OnObjectEnter = new ActionSettings(ActionSettings.Mode.Custom);
+
+ /// <summary>What action to take when an eligible object exits the collider or trigger zone</summary>
+ public ActionSettings m_OnObjectExit = new ActionSettings(ActionSettings.Mode.Custom);
+
+ HashSet<GameObject> m_ActiveTriggerObjects = new HashSet<GameObject>();
+
+ private bool Filter(GameObject other)
+ {
+ if (!enabled)
+ return false;
+ if (((1 << other.layer) & m_LayerMask) == 0)
+ return false;
+ if (m_WithTag.Length != 0 && !other.CompareTag(m_WithTag))
+ return false;
+ if (m_WithoutTag.Length != 0 && other.CompareTag(m_WithoutTag))
+ return false;
+
+ return true;
+ }
+
+ void InternalDoTriggerEnter(GameObject other)
+ {
+ if (!Filter(other))
+ return;
+ --m_SkipFirst;
+ if (m_SkipFirst > -1)
+ return;
+ if (!m_Repeating && m_SkipFirst != -1)
+ return;
+
+ m_ActiveTriggerObjects.Add(other);
+ m_OnObjectEnter.Invoke();
+ }
+
+ void InternalDoTriggerExit(GameObject other)
+ {
+ if (!m_ActiveTriggerObjects.Contains(other))
+ return;
+ m_ActiveTriggerObjects.Remove(other);
+ if (enabled)
+ m_OnObjectExit.Invoke();
+ }
+
+#if CINEMACHINE_PHYSICS
+ void OnTriggerEnter(Collider other) { InternalDoTriggerEnter(other.gameObject); }
+ void OnTriggerExit(Collider other) { InternalDoTriggerExit(other.gameObject); }
+ void OnCollisionEnter(Collision other) { InternalDoTriggerEnter(other.gameObject); }
+ void OnCollisionExit(Collision other) { InternalDoTriggerExit(other.gameObject); }
+#endif
+#if CINEMACHINE_PHYSICS_2D
+ void OnTriggerEnter2D(Collider2D other) { InternalDoTriggerEnter(other.gameObject); }
+ void OnTriggerExit2D(Collider2D other) { InternalDoTriggerExit(other.gameObject); }
+ void OnCollisionEnter2D(Collision2D other) { InternalDoTriggerEnter(other.gameObject); }
+ void OnCollisionExit2D(Collision2D other) { InternalDoTriggerExit(other.gameObject); }
+#endif
+ void OnEnable() {} // For the Enabled checkbox
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: e46ac8d61dc065848bd5a1aa7cd8c006
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 382e34fa2b7177e4589888b9fb25567e
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_EXPERIMENTAL_VCAM
+using UnityEngine;
+using Cinemachine.Utility;
+using System;
+
+namespace Cinemachine
+{
+ /// <summary>
+ ///
+ /// NOTE: THIS CLASS IS EXPERIMENTAL, AND NOT FOR PUBLIC USE
+ ///
+ /// Lighter-weight version of the CinemachineFreeLook, with extra radial axis.
+ ///
+ /// A Cinemachine Camera geared towards a 3rd person camera experience.
+ /// The camera orbits around its subject with three separate camera rigs defining
+ /// rings around the target. Each rig has its own radius, height offset, composer,
+ /// and lens settings.
+ /// Depending on the camera's position along the spline connecting these three rigs,
+ /// these settings are interpolated to give the final camera position and state.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineNewFreeLook")]
+ [SaveDuringPlay]
+ public class CinemachineNewFreeLook : CinemachineNewVirtualCamera
+ {
+ /// <summary>The Vertical axis. Value is 0..1. Chooses how to blend the child rigs</summary>
+ [Tooltip("The Vertical axis. Value is 0..1. 0.5 is the middle rig. Chooses how to blend the child rigs")]
+ [AxisStateProperty]
+ public AxisState m_VerticalAxis = new AxisState(0, 1, false, true, 2f, 0.2f, 0.1f, "Mouse Y", false);
+
+ [Tooltip("The Radial axis. Value is the base radius of the orbits")]
+ [AxisStateProperty]
+ public AxisState m_RadialAxis = new AxisState(1, 1, false, false, 100, 0f, 0f, "Mouse ScrollWheel", false);
+
+ /// <summary>Defines the height and radius for an orbit</summary>
+ [Serializable]
+ public struct Orbit
+ {
+ /// <summary>Height relative to target</summary>
+ public float m_Height;
+
+ /// <summary>Radius of orbit</summary>
+ public float m_Radius;
+ }
+
+ /// <summary>Order is Top, Middle, Bottom</summary>
+ public Orbit[] m_Orbits = new Orbit[3];
+
+ /// <summary></summary>
+ [Tooltip("Controls how taut is the line that connects the rigs' orbits, which determines final placement on the Y axis")]
+ [Range(0f, 1f)]
+ public float m_SplineCurvature;
+
+ /// <summary>Identifiers for accessing override settings for top and bottom rigs</summary>
+ public enum RigID { Top, Bottom };
+
+ /// <summary>Override settings for top and bottom rigs</summary>
+ [Serializable]
+ public class Rig
+ {
+ public bool m_CustomLens;
+ public LensSettings m_Lens;
+ public bool m_CustomBody;
+ public TransposerSettings m_Body;
+ public bool m_CustomAim;
+ public ComposerSettings m_Aim;
+ public bool m_CustomNoise;
+ public PerlinNoiseSettings m_Noise;
+
+ public void Validate()
+ {
+ if (m_Lens.FieldOfView == 0)
+ m_Lens = LensSettings.Default;
+ m_Lens.Validate();
+ }
+
+ /// <summary>Blendable settings for Transposer Transposer</summary>
+ [Serializable] public class TransposerSettings
+ {
+ [Range(0f, 20f)] public float m_XDamping;
+ [Range(0f, 20f)] public float m_YDamping;
+ [Range(0f, 20f)] public float m_ZDamping;
+ [Range(0f, 20f)] public float m_PitchDamping;
+ [Range(0f, 20f)] public float m_YawDamping;
+ [Range(0f, 20f)] public float m_RollDamping;
+
+ internal void Lerp(CinemachineTransposer o, float t)
+ {
+ o.m_XDamping = Mathf.Lerp(o.m_XDamping, m_XDamping, t);
+ o.m_YDamping = Mathf.Lerp(o.m_YDamping, m_YDamping, t);
+ o.m_ZDamping = Mathf.Lerp(o.m_ZDamping, m_ZDamping, t);
+ o.m_PitchDamping = Mathf.Lerp(o.m_PitchDamping, m_PitchDamping, t);
+ o.m_YawDamping = Mathf.Lerp(o.m_YawDamping, m_YawDamping, t);
+ o.m_RollDamping = Mathf.Lerp(o.m_RollDamping, m_RollDamping, t);
+ }
+
+ internal void PullFrom(CinemachineTransposer o)
+ {
+ m_XDamping = o.m_XDamping;
+ m_YDamping = o.m_YDamping;
+ m_ZDamping = o.m_ZDamping;
+ m_PitchDamping = o.m_PitchDamping;
+ m_YawDamping = o.m_YawDamping;
+ m_RollDamping = o.m_RollDamping;
+ }
+
+ internal void PushTo(CinemachineTransposer o)
+ {
+ o.m_XDamping = m_XDamping;
+ o.m_YDamping = m_YDamping;
+ o.m_ZDamping = m_ZDamping;
+ o.m_PitchDamping =m_PitchDamping;
+ o.m_YawDamping = m_YawDamping;
+ o.m_RollDamping = m_RollDamping;
+ }
+ }
+
+ /// <summary>Blendable settings for Composer</summary>
+ [Serializable] public class ComposerSettings
+ {
+ public Vector3 m_LookAtOffset;
+ [Space]
+ [Range(0f, 20)] public float m_HorizontalDamping;
+ [Range(0f, 20)] public float m_VerticalDamping;
+ [Space]
+ [Range(0f, 1f)] public float m_ScreenX;
+ [Range(0f, 1f)] public float m_ScreenY;
+ [Range(0f, 1f)] public float m_DeadZoneWidth;
+ [Range(0f, 1f)] public float m_DeadZoneHeight;
+ [Range(0f, 2f)] public float m_SoftZoneWidth;
+ [Range(0f, 2f)] public float m_SoftZoneHeight;
+ [Range(-0.5f, 0.5f)] public float m_BiasX;
+ [Range(-0.5f, 0.5f)] public float m_BiasY;
+
+ internal void Lerp(CinemachineComposer c, float t)
+ {
+ c.m_TrackedObjectOffset = Vector3.Lerp(c.m_TrackedObjectOffset, m_LookAtOffset, t);
+ c.m_HorizontalDamping = Mathf.Lerp(c.m_HorizontalDamping, m_HorizontalDamping, t);
+ c.m_VerticalDamping = Mathf.Lerp(c.m_VerticalDamping, m_VerticalDamping, t);
+ c.m_ScreenX = Mathf.Lerp(c.m_ScreenX, m_ScreenX, t);
+ c.m_ScreenY = Mathf.Lerp(c.m_ScreenY, m_ScreenY, t);
+ c.m_DeadZoneWidth = Mathf.Lerp(c.m_DeadZoneWidth, m_DeadZoneWidth, t);
+ c.m_DeadZoneHeight = Mathf.Lerp(c.m_DeadZoneHeight, m_DeadZoneHeight, t);
+ c.m_SoftZoneWidth = Mathf.Lerp(c.m_SoftZoneWidth, m_SoftZoneWidth, t);
+ c.m_SoftZoneHeight = Mathf.Lerp(c.m_SoftZoneHeight, m_SoftZoneHeight, t);
+ c.m_BiasX = Mathf.Lerp(c.m_BiasX, m_BiasX, t);
+ c.m_BiasY = Mathf.Lerp(c.m_BiasY, m_BiasY, t);
+ }
+
+ internal void PullFrom(CinemachineComposer c)
+ {
+ m_LookAtOffset = c.m_TrackedObjectOffset;
+ m_HorizontalDamping = c.m_HorizontalDamping;
+ m_VerticalDamping = c.m_VerticalDamping;
+ m_ScreenX = c.m_ScreenX;
+ m_ScreenY = c.m_ScreenY;
+ m_DeadZoneWidth = c.m_DeadZoneWidth;
+ m_DeadZoneHeight = c.m_DeadZoneHeight;
+ m_SoftZoneWidth = c.m_SoftZoneWidth;
+ m_SoftZoneHeight = c.m_SoftZoneHeight;
+ m_BiasX = c.m_BiasX;
+ m_BiasY = c.m_BiasY;
+ }
+
+ internal void PushTo(CinemachineComposer c)
+ {
+ c.m_TrackedObjectOffset = m_LookAtOffset;
+ c.m_HorizontalDamping = m_HorizontalDamping;
+ c.m_VerticalDamping = m_VerticalDamping;
+ c.m_ScreenX = m_ScreenX;
+ c.m_ScreenY = m_ScreenY;
+ c.m_DeadZoneWidth = m_DeadZoneWidth;
+ c.m_DeadZoneHeight = m_DeadZoneHeight;
+ c.m_SoftZoneWidth = m_SoftZoneWidth;
+ c.m_SoftZoneHeight = m_SoftZoneHeight;
+ c.m_BiasX = m_BiasX;
+ c.m_BiasY = m_BiasY;
+ }
+ }
+
+ /// <summary>Blendable settings for CinemachineBasicMultiChannelPerlin</summary>
+ [Serializable] public class PerlinNoiseSettings
+ {
+ public float m_AmplitudeGain;
+ public float m_FrequencyGain;
+
+ internal void Lerp(CinemachineBasicMultiChannelPerlin p, float t)
+ {
+ p.m_AmplitudeGain = Mathf.Lerp(p.m_AmplitudeGain, m_AmplitudeGain, t);
+ p.m_FrequencyGain =Mathf.Lerp(p.m_FrequencyGain, m_FrequencyGain, t);
+ }
+
+ internal void PullFrom(CinemachineBasicMultiChannelPerlin p)
+ {
+ m_AmplitudeGain = p.m_AmplitudeGain;
+ m_FrequencyGain = p.m_FrequencyGain;
+ }
+
+ internal void PushTo(CinemachineBasicMultiChannelPerlin p)
+ {
+ p.m_AmplitudeGain = m_AmplitudeGain;
+ p.m_FrequencyGain = m_FrequencyGain;
+ }
+ }
+ }
+
+ [SerializeField]
+ internal Rig[] m_Rigs = new Rig[2] { new Rig(), new Rig() };
+
+ /// <summary>Accessor for rig override settings</summary>
+ public Rig RigSettings(RigID rig) { return m_Rigs[(int)rig]; }
+
+ /// Easy access to the transposer (may be null)
+ CinemachineTransposer Transposer
+ {
+ get { return ComponentCache[(int)CinemachineCore.Stage.Body] as CinemachineTransposer; }
+ }
+
+ /// <summary>Enforce bounds for fields, when changed in inspector.</summary>
+ protected override void OnValidate()
+ {
+ base.OnValidate();
+ for (int i = 0; i < m_Rigs.Length; ++i)
+ m_Rigs[i].Validate();
+ }
+
+ private void Awake()
+ {
+ m_VerticalAxis.HasRecentering = true;
+ m_RadialAxis.HasRecentering = false;
+ }
+
+ void Reset()
+ {
+ DestroyComponents();
+#if UNITY_EDITOR
+ var orbital = UnityEditor.Undo.AddComponent<CinemachineOrbitalTransposer>(gameObject);
+ UnityEditor.Undo.AddComponent<CinemachineComposer>(gameObject);
+#else
+ var orbital = gameObject.AddComponent<CinemachineOrbitalTransposer>();
+ gameObject.AddComponent<CinemachineComposer>();
+#endif
+ orbital.HideOffsetInInspector = true;
+ orbital.m_BindingMode = CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp;
+
+ InvalidateComponentCache();
+ m_Rigs = new Rig[2] { new Rig(), new Rig() };
+
+ // Default orbits
+ m_Orbits = new Orbit[3];
+ m_Orbits[0].m_Height = 10; m_Orbits[0].m_Radius = 4;
+ m_Orbits[1].m_Height = 2.5f; m_Orbits[1].m_Radius = 8;
+ m_Orbits[2].m_Height = -0.5f; m_Orbits[2].m_Radius = 5;
+
+ m_SplineCurvature = 0.5f;
+ }
+
+ /// <summary>If we are transitioning from another FreeLook, grab the axis values from it.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ if (fromCam != null && m_Transitions.m_InheritPosition)
+ {
+ // Note: horizontal axis already taken care of by base class
+ var cameraPos = fromCam.State.RawPosition;
+
+ // Special handling for FreeLook: get an undamped outgoing position
+ if (fromCam is CinemachineNewFreeLook)
+ {
+ var orbital = (fromCam as CinemachineNewFreeLook).Transposer;
+ if (orbital != null)
+ cameraPos = orbital.GetTargetCameraPosition(worldUp);
+ }
+ m_VerticalAxis.Value = GetYAxisClosestValue(cameraPos, worldUp);
+ }
+ }
+
+ float GetYAxisClosestValue(Vector3 cameraPos, Vector3 up)
+ {
+ if (Follow != null)
+ {
+ // Rotate the camera pos to the back
+ Quaternion q = Quaternion.FromToRotation(up, Vector3.up);
+ Vector3 dir = q * (cameraPos - Follow.position);
+ Vector3 flatDir = dir; flatDir.y = 0;
+ if (!flatDir.AlmostZero())
+ {
+ float angle = Vector3.SignedAngle(flatDir, Vector3.back, Vector3.up);
+ dir = Quaternion.AngleAxis(angle, Vector3.up) * dir;
+ }
+ dir.x = 0;
+
+ // Sample the spline in a few places, find the 2 closest, and lerp
+ int i0 = 0, i1 = 0;
+ float a0 = 0, a1 = 0;
+ const int NumSamples = 13;
+ float step = 1f / (NumSamples-1);
+ for (int i = 0; i < NumSamples; ++i)
+ {
+ float a = Vector3.SignedAngle(
+ dir, GetLocalPositionForCameraFromInput(i * step), Vector3.right);
+ if (i == 0)
+ a0 = a1 = a;
+ else
+ {
+ if (Mathf.Abs(a) < Mathf.Abs(a0))
+ {
+ a1 = a0;
+ i1 = i0;
+ a0 = a;
+ i0 = i;
+ }
+ else if (Mathf.Abs(a) < Mathf.Abs(a1))
+ {
+ a1 = a;
+ i1 = i;
+ }
+ }
+ }
+ if (Mathf.Sign(a0) == Mathf.Sign(a1))
+ return i0 * step;
+ float t = Mathf.Abs(a0) / (Mathf.Abs(a0) + Mathf.Abs(a1));
+ return Mathf.Lerp(i0 * step, i1 * step, t);
+ }
+ return m_VerticalAxis.Value; // stay conservative
+ }
+
+ /// <summary>Internal use only. Called by CinemachineCore at designated update time
+ /// so the vcam can position itself and track its targets. All 3 child rigs are updated,
+ /// and a blend calculated, depending on the value of the Y axis.</summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ override public void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ if (!PreviousStateIsValid)
+ deltaTime = -1;
+
+ // Initialize the camera state, in case the game object got moved in the editor
+ m_State = PullStateFromVirtualCamera(worldUp, ref m_Lens);
+ m_Rigs[(int)RigID.Top].m_Lens.SnapshotCameraReadOnlyProperties(ref m_Lens);
+ m_Rigs[(int)RigID.Bottom].m_Lens.SnapshotCameraReadOnlyProperties(ref m_Lens);
+
+ // Update our axes
+ bool activeCam = (deltaTime >= 0) || CinemachineCore.Instance.IsLive(this);
+ if (activeCam)
+ {
+ if (m_VerticalAxis.Update(deltaTime))
+ m_VerticalAxis.m_Recentering.CancelRecentering();
+ m_RadialAxis.Update(deltaTime);
+ }
+ m_VerticalAxis.m_Recentering.DoRecentering(ref m_VerticalAxis, deltaTime, 0.5f);
+
+ // Blend the components
+ if (mBlender == null)
+ mBlender = new ComponentBlender(this);
+ mBlender.Blend(GetVerticalAxisValue());
+
+ // Blend the lens
+ if (m_Rigs[mBlender.OtherRig].m_CustomLens)
+ m_State.Lens = LensSettings.Lerp(
+ m_State.Lens, m_Rigs[mBlender.OtherRig].m_Lens, mBlender.BlendAmount);
+
+ // Do our stuff
+ SetReferenceLookAtTargetInState(ref m_State);
+ InvokeComponentPipeline(ref m_State, worldUp, deltaTime);
+ ApplyPositionBlendMethod(ref m_State, m_Transitions.m_BlendHint);
+
+ // Restore the components
+ mBlender.Restore();
+
+ // Push the raw position back to the game object's transform, so it
+ // moves along with the camera.
+ if (!UserIsDragging)
+ {
+ if (Follow != null)
+ transform.position = State.RawPosition;
+ if (LookAt != null)
+ transform.rotation = State.RawOrientation;
+ }
+ // Signal that it's all done
+ InvokePostPipelineStageCallback(this, CinemachineCore.Stage.Finalize, ref m_State, deltaTime);
+ PreviousStateIsValid = true;
+ }
+
+ ComponentBlender mBlender;
+
+ protected override void OnComponentCacheUpdated()
+ {
+ var transposer = Transposer;
+ if (transposer != null)
+ {
+ transposer.HideOffsetInInspector = true;
+ transposer.m_FollowOffset = new Vector3(
+ 0, m_Orbits[1].m_Height, -m_Orbits[1].m_Radius);
+ }
+ }
+
+ private float GetVerticalAxisValue()
+ {
+ float range = m_VerticalAxis.m_MaxValue - m_VerticalAxis.m_MinValue;
+ return (range > UnityVectorExtensions.Epsilon) ? m_VerticalAxis.Value / range : 0.5f;
+ }
+
+ /// <summary>
+ /// Returns the local position of the camera along the spline used to connect the
+ /// three camera rigs. Does not take into account the current heading of the
+ /// camera (or its target)
+ /// </summary>
+ /// <param name="t">The t-value for the camera on its spline. Internally clamped to
+ /// the value [0,1]</param>
+ /// <returns>The local offset (back + up) of the camera WRT its target based on the
+ /// supplied t-value</returns>
+ public Vector3 GetLocalPositionForCameraFromInput(float t)
+ {
+ UpdateCachedSpline();
+ int n = 1;
+ if (t > 0.5f)
+ {
+ t -= 0.5f;
+ n = 2;
+ }
+ Vector3 pos = SplineHelpers.Bezier3(
+ t * 2f, m_CachedKnots[n], m_CachedCtrl1[n], m_CachedCtrl2[n], m_CachedKnots[n+1]);
+ pos *= Mathf.Max(0, m_RadialAxis.Value);
+ return pos;
+ }
+
+ Vector2[] m_CachedOrbits;
+ float m_CachedTension;
+ Vector4[] m_CachedKnots;
+ Vector4[] m_CachedCtrl1;
+ Vector4[] m_CachedCtrl2;
+ void UpdateCachedSpline()
+ {
+ bool cacheIsValid = (m_CachedOrbits != null && m_CachedTension == m_SplineCurvature);
+ for (int i = 0; i < 3 && cacheIsValid; ++i)
+ cacheIsValid = (m_CachedOrbits[i].y == m_Orbits[i].m_Height
+ && m_CachedOrbits[i].x == m_Orbits[i].m_Radius);
+ if (!cacheIsValid)
+ {
+ float t = m_SplineCurvature;
+ m_CachedKnots = new Vector4[5];
+ m_CachedCtrl1 = new Vector4[5];
+ m_CachedCtrl2 = new Vector4[5];
+ m_CachedKnots[1] = new Vector4(0, m_Orbits[2].m_Height, -m_Orbits[2].m_Radius, 0);
+ m_CachedKnots[2] = new Vector4(0, m_Orbits[1].m_Height, -m_Orbits[1].m_Radius, 0);
+ m_CachedKnots[3] = new Vector4(0, m_Orbits[0].m_Height, -m_Orbits[0].m_Radius, 0);
+ m_CachedKnots[0] = Vector4.Lerp(m_CachedKnots[0], Vector4.zero, t);
+ m_CachedKnots[4] = Vector4.Lerp(m_CachedKnots[3], Vector4.zero, t);
+ SplineHelpers.ComputeSmoothControlPoints(
+ ref m_CachedKnots, ref m_CachedCtrl1, ref m_CachedCtrl2);
+ m_CachedOrbits = new Vector2[3];
+ for (int i = 0; i < 3; ++i)
+ m_CachedOrbits[i] = new Vector2(m_Orbits[i].m_Radius, m_Orbits[i].m_Height);
+ m_CachedTension = m_SplineCurvature;
+ }
+ }
+
+ // Crazy damn thing for blending components at the source level
+ internal class ComponentBlender
+ {
+ Rig.TransposerSettings orbitalSaved = new Rig.TransposerSettings();
+ Rig.ComposerSettings composerSaved = new Rig.ComposerSettings();
+ Rig.PerlinNoiseSettings noiseSaved = new Rig.PerlinNoiseSettings();
+
+ public int OtherRig { get; set; }
+ public float BlendAmount { get; set; }
+ CinemachineNewFreeLook mFreeLook;
+
+ public ComponentBlender(CinemachineNewFreeLook freeLook) { mFreeLook = freeLook; }
+
+ public void Blend(float y)
+ {
+ if (y < 0.5f)
+ {
+ BlendAmount = 1 - (y * 2);
+ OtherRig = (int)RigID.Bottom;
+ }
+ else
+ {
+ BlendAmount = (y - 0.5f) * 2f;
+ OtherRig = (int)RigID.Top;
+ }
+
+ var orbital = mFreeLook.Transposer;
+ if (orbital != null && mFreeLook.m_Rigs[OtherRig].m_CustomBody)
+ {
+ orbitalSaved.PullFrom(orbital);
+ mFreeLook.m_Rigs[OtherRig].m_Body.Lerp(orbital, BlendAmount);
+ }
+ if (orbital != null)
+ orbital.m_FollowOffset = mFreeLook.GetLocalPositionForCameraFromInput(y);
+
+ var components = mFreeLook.ComponentCache;
+ var composer = components[(int)CinemachineCore.Stage.Aim] as CinemachineComposer;
+ if (composer != null && mFreeLook.m_Rigs[OtherRig].m_CustomAim)
+ {
+ composerSaved.PullFrom(composer);
+ mFreeLook.m_Rigs[OtherRig].m_Aim.Lerp(composer, BlendAmount);
+ }
+
+ var noise = components[(int)CinemachineCore.Stage.Noise] as CinemachineBasicMultiChannelPerlin;
+ if (noise != null && mFreeLook.m_Rigs[OtherRig].m_CustomNoise)
+ {
+ noiseSaved.PullFrom(noise);
+ mFreeLook.m_Rigs[OtherRig].m_Noise.Lerp(noise, BlendAmount);
+ }
+ }
+
+ public void Restore()
+ {
+ var orbital = mFreeLook.Transposer;
+ if (orbital != null && mFreeLook.m_Rigs[OtherRig].m_CustomBody)
+ orbitalSaved.PushTo(orbital);
+ if (orbital != null)
+ orbital.m_FollowOffset = new Vector3(
+ 0, mFreeLook.m_Orbits[1].m_Height, -mFreeLook.m_Orbits[1].m_Radius);
+ var components = mFreeLook.ComponentCache;
+ var composer = components[(int)CinemachineCore.Stage.Aim] as CinemachineComposer;
+ if (composer != null && mFreeLook.m_Rigs[OtherRig].m_CustomAim)
+ composerSaved.PushTo(composer);
+
+ var noise = components[(int)CinemachineCore.Stage.Noise] as CinemachineBasicMultiChannelPerlin;
+ if (noise != null && mFreeLook.m_Rigs[OtherRig].m_CustomNoise)
+ noiseSaved.PushTo(noise);
+ }
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: bd920fe83f1086148a2b401f3e66528f
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: b8ba3923a6094cd48b85425f47fd7450, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_EXPERIMENTAL_VCAM
+using UnityEngine;
+using System;
+
+namespace Cinemachine
+{
+ /// <summary>
+ ///
+ /// NOTE: THIS CLASS IS EXPERIMENTAL, AND NOT FOR PUBLIC USE
+ ///
+ /// Lighter-weight version of the CinemachineVirtualCamera.
+ ///
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [DisallowMultipleComponent]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("Cinemachine/CinemachineNewVirtualCamera")]
+ public class CinemachineNewVirtualCamera : CinemachineVirtualCameraBase
+ {
+ /// <summary>Object for the camera children to look at (the aim target)</summary>
+ [Tooltip("Object for the camera children to look at (the aim target).")]
+ [NoSaveDuringPlay]
+ public Transform m_LookAt = null;
+
+ /// <summary>Object for the camera children wants to move with (the body target)</summary>
+ [Tooltip("Object for the camera children wants to move with (the body target).")]
+ [NoSaveDuringPlay]
+ public Transform m_Follow = null;
+
+ /// <summary>Specifies the LensSettings of this Virtual Camera.
+ /// These settings will be transferred to the Unity camera when the vcam is live.</summary>
+ [Tooltip("Specifies the lens properties of this Virtual Camera. This generally mirrors the Unity Camera's lens settings, and will be used to drive the Unity camera when the vcam is active.")]
+ [LensSettingsProperty]
+ public LensSettings m_Lens = LensSettings.Default;
+
+ /// <summary> Collection of parameters that influence how this virtual camera transitions from
+ /// other virtual cameras </summary>
+ public TransitionParams m_Transitions;
+
+ /// <summary>API for the editor, to make the dragging of position handles behave better.</summary>
+ public bool UserIsDragging { get; set; }
+
+ /// <summary>Updates the child rig cache</summary>
+ protected override void OnEnable()
+ {
+ base.OnEnable();
+ InvalidateComponentCache();
+ }
+
+ void Reset()
+ {
+ DestroyComponents();
+ }
+
+ /// <summary>The camera state, which will be a blend of the child rig states</summary>
+ override public CameraState State { get { return m_State; } }
+
+ /// <summary>The camera state, which will be a blend of the child rig states</summary>
+ protected CameraState m_State = CameraState.Default;
+
+ /// <summary>Get the current LookAt target. Returns parent's LookAt if parent
+ /// is non-null and no specific LookAt defined for this camera</summary>
+ override public Transform LookAt
+ {
+ get { return ResolveLookAt(m_LookAt); }
+ set { m_LookAt = value; }
+ }
+
+ /// <summary>Get the current Follow target. Returns parent's Follow if parent
+ /// is non-null and no specific Follow defined for this camera</summary>
+ override public Transform Follow
+ {
+ get { return ResolveFollow(m_Follow); }
+ set { m_Follow = value; }
+ }
+
+ /// <summary>This is called to notify the vcam that a target got warped,
+ /// so that the vcam can update its internal state to make the camera
+ /// also warp seamlessy.</summary>
+ /// <param name="target">The object that was warped</param>
+ /// <param name="positionDelta">The amount the target's position changed</param>
+ public override void OnTargetObjectWarped(Transform target, Vector3 positionDelta)
+ {
+ if (target == Follow)
+ {
+ transform.position += positionDelta;
+ m_State.RawPosition += positionDelta;
+ }
+ UpdateComponentCache();
+ for (int i = 0; i < m_Components.Length; ++i)
+ {
+ if (m_Components[i] != null)
+ m_Components[i].OnTargetObjectWarped(target, positionDelta);
+ }
+ base.OnTargetObjectWarped(target, positionDelta);
+ }
+
+ /// <summary>If we are transitioning from another FreeLook, grab the axis values from it.</summary>
+ /// <param name="fromCam">The camera being deactivated. May be null.</param>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than or equal to 0)</param>
+ public override void OnTransitionFromCamera(
+ ICinemachineCamera fromCam, Vector3 worldUp, float deltaTime)
+ {
+ base.OnTransitionFromCamera(fromCam, worldUp, deltaTime);
+ bool forceUpdate = false;
+ if (m_Transitions.m_InheritPosition && fromCam != null)
+ {
+ transform.position = fromCam.State.RawPosition;
+ //transform.rotation = fromCam.State.RawOrientation;
+ PreviousStateIsValid = false;
+ forceUpdate = true;
+ }
+ UpdateComponentCache();
+ for (int i = 0; i < m_Components.Length; ++i)
+ {
+ if (m_Components[i] != null
+ && m_Components[i].OnTransitionFromCamera(
+ fromCam, worldUp, deltaTime, ref m_Transitions))
+ forceUpdate = true;
+ }
+ if (forceUpdate)
+ InternalUpdateCameraState(worldUp, deltaTime);
+ else
+ UpdateCameraState(worldUp, deltaTime);
+ if (m_Transitions.m_OnCameraLive != null)
+ m_Transitions.m_OnCameraLive.Invoke(this, fromCam);
+ }
+
+ /// <summary>Internal use only. Called by CinemachineCore at designated update time
+ /// so the vcam can position itself and track its targets. All 3 child rigs are updated,
+ /// and a blend calculated, depending on the value of the Y axis.</summary>
+ /// <param name="worldUp">Default world Up, set by the CinemachineBrain</param>
+ /// <param name="deltaTime">Delta time for time-based effects (ignore if less than 0)</param>
+ override public void InternalUpdateCameraState(Vector3 worldUp, float deltaTime)
+ {
+ if (!PreviousStateIsValid)
+ deltaTime = -1;
+
+ // Initialize the camera state, in case the game object got moved in the editor
+ m_State = PullStateFromVirtualCamera(worldUp, ref m_Lens);
+
+ // Do our stuff
+ SetReferenceLookAtTargetInState(ref m_State);
+ InvokeComponentPipeline(ref m_State, worldUp, deltaTime);
+ ApplyPositionBlendMethod(ref m_State, m_Transitions.m_BlendHint);
+
+ // Push the raw position back to the game object's transform, so it
+ // moves along with the camera.
+ if (!UserIsDragging)
+ {
+ if (Follow != null)
+ transform.position = State.RawPosition;
+ if (LookAt != null)
+ transform.rotation = State.RawOrientation;
+ }
+ // Signal that it's all done
+ InvokePostPipelineStageCallback(this, CinemachineCore.Stage.Finalize, ref m_State, deltaTime);
+ PreviousStateIsValid = true;
+ }
+
+ private Transform mCachedLookAtTarget;
+ private CinemachineVirtualCameraBase mCachedLookAtTargetVcam;
+
+ /// <summary>Set the state's refeenceLookAt target to our lookAt, with some smarts
+ /// in case our LookAt points to a vcam</summary>
+ protected void SetReferenceLookAtTargetInState(ref CameraState state)
+ {
+ Transform lookAtTarget = LookAt;
+ if (lookAtTarget != mCachedLookAtTarget)
+ {
+ mCachedLookAtTarget = lookAtTarget;
+ mCachedLookAtTargetVcam = null;
+ if (lookAtTarget != null)
+ mCachedLookAtTargetVcam = lookAtTarget.GetComponent<CinemachineVirtualCameraBase>();
+ }
+ if (lookAtTarget != null)
+ {
+ if (mCachedLookAtTargetVcam != null)
+ state.ReferenceLookAt = mCachedLookAtTargetVcam.State.FinalPosition;
+ else
+ state.ReferenceLookAt = lookAtTarget.position;
+ }
+ }
+
+ protected CameraState InvokeComponentPipeline(
+ ref CameraState state, Vector3 worldUp, float deltaTime)
+ {
+ UpdateComponentCache();
+
+ // Apply the component pipeline
+ for (CinemachineCore.Stage stage = CinemachineCore.Stage.Body;
+ stage < CinemachineCore.Stage.Finalize; ++stage)
+ {
+ var c = m_Components[(int)stage];
+ if (c != null)
+ c.PrePipelineMutateCameraState(ref state, deltaTime);
+ }
+ for (CinemachineCore.Stage stage = CinemachineCore.Stage.Body;
+ stage < CinemachineCore.Stage.Finalize; ++stage)
+ {
+ var c = m_Components[(int)stage];
+ if (c != null)
+ c.MutateCameraState(ref state, deltaTime);
+ else if (stage == CinemachineCore.Stage.Aim)
+ state.BlendHint |= CameraState.BlendHintValue.IgnoreLookAtTarget; // no aim
+ InvokePostPipelineStageCallback(this, stage, ref state, deltaTime);
+ }
+
+ return state;
+ }
+
+ // Component Cache - serialized only for copy/paste
+ [SerializeField, HideInInspector, NoSaveDuringPlay]
+ CinemachineComponentBase[] m_Components;
+
+ /// For inspector
+ internal CinemachineComponentBase[] ComponentCache
+ {
+ get
+ {
+ UpdateComponentCache();
+ return m_Components;
+ }
+ }
+
+ /// <summary>Call this when CinemachineCompponentBase compponents are added
+ /// or removed. If you don't call this, you may get null reference errors.</summary>
+ public void InvalidateComponentCache()
+ {
+ m_Components = null;
+ }
+
+ /// <summary>Bring the component cache up to date if needed</summary>
+ protected void UpdateComponentCache()
+ {
+#if UNITY_EDITOR
+ // Special case: if we have serialized in with some other game object's
+ // components, then we have just been pasted so we should clone them
+ for (int i = 0; m_Components != null && i < m_Components.Length; ++i)
+ {
+ if (m_Components[i] != null && m_Components[i].gameObject != gameObject)
+ {
+ var copyFrom = m_Components;
+ DestroyComponents();
+ CopyComponents(copyFrom);
+ break;
+ }
+ }
+#endif
+ if (m_Components != null && m_Components.Length == (int)CinemachineCore.Stage.Finalize)
+ return; // up to date
+
+ m_Components = new CinemachineComponentBase[(int)CinemachineCore.Stage.Finalize];
+ var existing = GetComponents<CinemachineComponentBase>();
+ for (int i = 0; existing != null && i < existing.Length; ++i)
+ m_Components[(int)existing[i].Stage] = existing[i];
+
+ for (int i = 0; i < m_Components.Length; ++i)
+ {
+ if (m_Components[i] != null)
+ {
+ if (CinemachineCore.sShowHiddenObjects)
+ m_Components[i].hideFlags &= ~HideFlags.HideInInspector;
+ else
+ m_Components[i].hideFlags |= HideFlags.HideInInspector;
+ }
+ }
+ OnComponentCacheUpdated();
+ }
+
+ /// <summary>Notification that the component cache has just been update,
+ /// in case a subclass needs to do something extra</summary>
+ protected virtual void OnComponentCacheUpdated() {}
+
+ /// <summary>Destroy all the CinmachineComponentBase components</summary>
+ protected void DestroyComponents()
+ {
+ var existing = GetComponents<CinemachineComponentBase>();
+ for (int i = 0; i < existing.Length; ++i)
+ {
+#if UNITY_EDITOR
+ UnityEditor.Undo.DestroyObjectImmediate(existing[i]);
+#else
+ UnityEngine.Object.Destroy(existing[i]);
+#endif
+ }
+ InvalidateComponentCache();
+ }
+
+#if UNITY_EDITOR
+ // This gets called when user pastes component values
+ void CopyComponents(CinemachineComponentBase[] copyFrom)
+ {
+ foreach (CinemachineComponentBase c in copyFrom)
+ {
+ if (c != null)
+ {
+ Type type = c.GetType();
+ var copy = UnityEditor.Undo.AddComponent(gameObject, type);
+ UnityEditor.Undo.RecordObject(copy, "copying pipeline");
+
+ System.Reflection.BindingFlags bindingAttr
+ = System.Reflection.BindingFlags.Public
+ | System.Reflection.BindingFlags.NonPublic
+ | System.Reflection.BindingFlags.Instance;
+
+ System.Reflection.FieldInfo[] fields = type.GetFields(bindingAttr);
+ for (int i = 0; i < fields.Length; ++i)
+ if (!fields[i].IsStatic)
+ fields[i].SetValue(copy, fields[i].GetValue(c));
+ }
+ }
+ }
+#endif
+
+ /// Legacy support for an old API. GML todo: deprecate these methods
+
+ /// <summary>Get the component set for a specific stage.</summary>
+ /// <param name="stage">The stage for which we want the component</param>
+ /// <returns>The Cinemachine component for that stage, or null if not defined</returns>
+ public CinemachineComponentBase GetCinemachineComponent(CinemachineCore.Stage stage)
+ {
+ return ComponentCache[(int)stage];
+ }
+
+ /// <summary>Get an existing component of a specific type from the cinemachine pipeline.</summary>
+ public T GetCinemachineComponent<T>() where T : CinemachineComponentBase
+ {
+ var components = ComponentCache;
+ foreach (var c in components)
+ if (c is T)
+ return c as T;
+ return null;
+ }
+
+ /// <summary>Add a component to the cinemachine pipeline.</summary>
+ public T AddCinemachineComponent<T>() where T : CinemachineComponentBase
+ {
+ T c = gameObject.AddComponent<T>();
+ var components = ComponentCache;
+ var oldC = components[(int)c.Stage];
+ if (oldC != null)
+ {
+ oldC.enabled = false;
+ RuntimeUtility.DestroyObject(oldC);
+ }
+ InvalidateComponentCache();
+ return c;
+ }
+
+ /// <summary>Remove a component from the cinemachine pipeline.</summary>
+ public void DestroyCinemachineComponent<T>() where T : CinemachineComponentBase
+ {
+ var components = ComponentCache;
+ foreach (var c in components)
+ {
+ if (c is T)
+ {
+ c.enabled = false;
+ RuntimeUtility.DestroyObject(c);
+ InvalidateComponentCache();
+ return;
+ }
+ }
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: be817a1286f201845b5c36ae9afe9e35
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: b8ba3923a6094cd48b85425f47fd7450, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: e2408873163918f4da4afc37c51b1586
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#define CINEMACHINE_PHYSICS
+#define CINEMACHINE_PHYSICS_2D
+
+#if CINEMACHINE_PHYSICS || CINEMACHINE_PHYSICS_2D
+
+using Cinemachine.Utility;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Generate an Impulse Event this object's Collider collides with something
+ /// or its trigger zone is entered.
+ ///
+ /// This component should be attached to a GameObject with a Collider or a Collider2D.
+ /// Objects colliding with this (or entering its trigger zone if it's a trigger) will be
+ /// filtered according to the layer and tag settings defined here, and if they
+ /// pass the filter, they will cause an impulse event to be generated.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [SaveDuringPlay]
+ public class CinemachineCollisionImpulseSource : CinemachineImpulseSource
+ {
+ /// <summary>Only collisions with objects on these layers will generate Impulse events.</summary>
+ [Header("Trigger Object Filter")]
+ [Tooltip("Only collisions with objects on these layers will generate Impulse events")]
+ public LayerMask m_LayerMask = 1;
+
+ /// <summary>No Impulse evemts will be generated for collisions with objects having these tags</summary>
+ [TagField]
+ [Tooltip("No Impulse evemts will be generated for collisions with objects having these tags")]
+ public string m_IgnoreTag = string.Empty;
+
+ /// <summary>If checked, signal direction will be affected by the direction of impact</summary>
+ [Header("How To Generate The Impulse")]
+ [Tooltip("If checked, signal direction will be affected by the direction of impact")]
+ public bool m_UseImpactDirection = false;
+
+ /// <summary>If checked, signal amplitude will be multiplied by the mass of the impacting object</summary>
+ [Tooltip("If checked, signal amplitude will be multiplied by the mass of the impacting object")]
+ public bool m_ScaleImpactWithMass = false;
+
+ /// <summary>If checked, signal amplitude will be multiplied by the speed of the impacting object</summary>
+ [Tooltip("If checked, signal amplitude will be multiplied by the speed of the impacting object")]
+ public bool m_ScaleImpactWithSpeed = false;
+
+#if CINEMACHINE_PHYSICS
+ Rigidbody mRigidBody;
+#endif
+#if CINEMACHINE_PHYSICS_2D
+ Rigidbody2D mRigidBody2D;
+#endif
+
+ private void Start()
+ {
+#if CINEMACHINE_PHYSICS
+ mRigidBody = GetComponent<Rigidbody>();
+#endif
+#if CINEMACHINE_PHYSICS_2D
+ mRigidBody2D = GetComponent<Rigidbody2D>();
+#endif
+ }
+
+ private void OnEnable() {} // For the Enabled checkbox
+
+#if CINEMACHINE_PHYSICS
+ private void OnCollisionEnter(Collision c)
+ {
+ GenerateImpactEvent(c.collider, c.relativeVelocity);
+ }
+
+ private void OnTriggerEnter(Collider c)
+ {
+ GenerateImpactEvent(c, Vector3.zero);
+ }
+
+ private float GetMassAndVelocity(Collider other, ref Vector3 vel)
+ {
+ bool getVelocity = vel == Vector3.zero;
+ float mass = 1;
+ if (m_ScaleImpactWithMass || m_ScaleImpactWithSpeed || m_UseImpactDirection)
+ {
+ if (mRigidBody != null)
+ {
+ if (m_ScaleImpactWithMass)
+ mass *= mRigidBody.mass;
+ if (getVelocity)
+ vel = -mRigidBody.velocity;
+ }
+ var rb = other != null ? other.attachedRigidbody : null;
+ if (rb != null)
+ {
+ if (m_ScaleImpactWithMass)
+ mass *= rb.mass;
+ if (getVelocity)
+ vel += rb.velocity;
+ }
+ }
+ return mass;
+ }
+
+ private void GenerateImpactEvent(Collider other, Vector3 vel)
+ {
+ // Check the filters
+ if (!enabled)
+ return;
+
+ if (other != null)
+ {
+ int layer = other.gameObject.layer;
+ if (((1 << layer) & m_LayerMask) == 0)
+ return;
+ if (m_IgnoreTag.Length != 0 && other.CompareTag(m_IgnoreTag))
+ return;
+ }
+
+ // Calculate the signal direction and magnitude
+ float mass = GetMassAndVelocity(other, ref vel);
+ if (m_ScaleImpactWithSpeed)
+ mass *= vel.magnitude;
+ Vector3 dir = Vector3.down;
+ if (m_UseImpactDirection && !vel.AlmostZero())
+ dir = -vel.normalized;
+
+ // Fire it off!
+ GenerateImpulse(dir * mass);
+ }
+#endif
+
+#if CINEMACHINE_PHYSICS_2D
+ private void OnCollisionEnter2D(Collision2D c)
+ {
+ GenerateImpactEvent2D(c.collider, c.relativeVelocity);
+ }
+
+ private void OnTriggerEnter2D(Collider2D c)
+ {
+ GenerateImpactEvent2D(c, Vector3.zero);
+ }
+
+ private float GetMassAndVelocity2D(Collider2D other2d, ref Vector3 vel)
+ {
+ bool getVelocity = vel == Vector3.zero;
+ float mass = 1;
+ if (m_ScaleImpactWithMass || m_ScaleImpactWithSpeed || m_UseImpactDirection)
+ {
+ if (mRigidBody2D != null)
+ {
+ if (m_ScaleImpactWithMass)
+ mass *= mRigidBody2D.mass;
+ if (getVelocity)
+ vel = -mRigidBody2D.velocity;
+ }
+
+ var rb2d = other2d != null ? other2d.attachedRigidbody : null;
+ if (rb2d != null)
+ {
+ if (m_ScaleImpactWithMass)
+ mass *= rb2d.mass;
+ if (getVelocity)
+ {
+ Vector3 v = rb2d.velocity;
+ vel += v;
+ }
+ }
+ }
+ return mass;
+ }
+
+ private void GenerateImpactEvent2D(Collider2D other2d, Vector3 vel)
+ {
+ // Check the filters
+ if (!enabled)
+ return;
+
+ if (other2d != null)
+ {
+ int layer = other2d.gameObject.layer;
+ if (((1 << layer) & m_LayerMask) == 0)
+ return;
+ if (m_IgnoreTag.Length != 0 && other2d.CompareTag(m_IgnoreTag))
+ return;
+ }
+
+ // Calculate the signal direction and magnitude
+ float mass = GetMassAndVelocity2D(other2d, ref vel);
+ if (m_ScaleImpactWithSpeed)
+ mass *= vel.magnitude;
+ Vector3 dir = Vector3.down;
+ if (m_UseImpactDirection && !vel.AlmostZero())
+ dir = -vel.normalized;
+
+ // Fire it off!
+ GenerateImpulse(dir * mass);
+ }
+#endif
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: cd438dd108a0f284aa931a2da434f1d3
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// A definition of an impulse signal that gets propagated to listeners
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ public class CinemachineFixedSignal : SignalSourceAsset
+ {
+ /// <summary>The raw signal shape along the X axis</summary>
+ [Tooltip("The raw signal shape along the X axis")]
+ public AnimationCurve m_XCurve;
+
+ /// <summary>The raw signal shape along the Y axis</summary>
+ [Tooltip("The raw signal shape along the Y axis")]
+ public AnimationCurve m_YCurve;
+
+ /// <summary>The raw signal shape along the Z axis</summary>
+ [Tooltip("The raw signal shape along the Z axis")]
+ public AnimationCurve m_ZCurve;
+
+ /// <summary>
+ /// Returns the length on seconds of the signal.
+ /// Returns 0 for signals of indeterminate length.
+ /// </summary>
+ public override float SignalDuration
+ {
+ get
+ {
+ return Mathf.Max(
+ AxisDuration(m_XCurve),
+ Mathf.Max(AxisDuration(m_YCurve), AxisDuration(m_ZCurve)));
+ }
+ }
+
+ float AxisDuration(AnimationCurve axis)
+ {
+ float duration = 0;
+ if (axis != null && axis.length > 1)
+ {
+ float start = axis[0].time;
+ duration = axis[axis.length-1].time - start;
+ }
+ return duration;
+ }
+
+ /// <summary>Get the raw signal at this time</summary>
+ /// <param name="timeSinceSignalStart">The time since in seconds since the start of the signal</param>
+ /// <param name="pos">The position impulse signal</param>
+ /// <param name="rot">The rotation impulse signal</param>
+ public override void GetSignal(float timeSinceSignalStart, out Vector3 pos, out Quaternion rot)
+ {
+ rot = Quaternion.identity;
+ pos = new Vector3(
+ AxisValue(m_XCurve, timeSinceSignalStart),
+ AxisValue(m_YCurve, timeSinceSignalStart),
+ AxisValue(m_ZCurve, timeSinceSignalStart));
+ }
+
+ float AxisValue(AnimationCurve axis, float time)
+ {
+ if (axis == null || axis.length == 0)
+ return 0;
+ return axis.Evaluate(time);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: a5969901aa40942499363f92e3787110
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using Cinemachine.Utility;
+using System;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Property applied to CinemachineImpulseManager Channels.
+ /// Used for custom drawing in the inspector.
+ /// </summary>
+ public sealed class CinemachineImpulseDefinitionPropertyAttribute : PropertyAttribute {}
+
+ /// <summary>
+ /// Definition of an impulse signal that gets propagated to listeners.
+ ///
+ /// Here you provide a Raw Signal source, and define an envelope for time-scaling
+ /// it to craft the complete Impulse signal shape. Also, you provide here parameters
+ /// that define how the signal dissipates with spatial distance from the source location.
+ /// Finally, you specify the Impulse Channel on which the signal will be sent.
+ ///
+ /// An API method is provided here to take these parameters, create an Impulse Event,
+ /// and broadcast it on the channel.
+ ///
+ /// When creating a custom Impulse Source class, you will have an instance of this class
+ /// as a field in your custom class. Be sure also to include the
+ /// [CinemachineImpulseDefinition] attribute on the field, to get the right
+ /// property drawer for it.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.API)]
+ [Serializable]
+ public class CinemachineImpulseDefinition
+ {
+ /// <summary>
+ /// Impulse events generated here will appear on the channels included in the mask.
+ /// </summary>
+ [CinemachineImpulseChannelProperty]
+ [Tooltip("Impulse events generated here will appear on the channels included in the mask.")]
+ public int m_ImpulseChannel = 1;
+
+ /// <summary>
+ /// Defines the signal that will be generated.
+ /// </summary>
+ [Header("Signal Shape")]
+ [Tooltip("Defines the signal that will be generated.")]
+ [CinemachineEmbeddedAssetProperty(true)]
+ public SignalSourceAsset m_RawSignal = null;
+
+ /// <summary>
+ /// Gain to apply to the amplitudes defined in the signal source asset.
+ /// </summary>
+ [Tooltip("Gain to apply to the amplitudes defined in the signal source. 1 is normal. Setting this to 0 completely mutes the signal.")]
+ public float m_AmplitudeGain = 1f;
+
+ /// <summary>
+ /// Scale factor to apply to the time axis.
+ /// </summary>
+ [Tooltip("Scale factor to apply to the time axis. 1 is normal. Larger magnitudes will make the signal progress more rapidly.")]
+ public float m_FrequencyGain = 1f;
+
+ /// <summary>How to fit the signal into the envelope time</summary>
+ public enum RepeatMode
+ {
+ /// <summary>Time-stretch the signal to fit the envelope</summary>
+ Stretch,
+ /// <summary>Loop the signal in time to fill the envelope</summary>
+ Loop
+ }
+ /// <summary>How to fit the signal into the envelope time</summary>
+ [Tooltip("How to fit the signal into the envelope time")]
+ public RepeatMode m_RepeatMode = RepeatMode.Stretch;
+
+ /// <summary>Randomize the signal start time</summary>
+ [Tooltip("Randomize the signal start time")]
+ public bool m_Randomize = true;
+
+ /// <summary>
+ /// This defines the time-envelope of the signal.
+ /// The raw signal will be time-scaled to fit in the envelope.
+ /// </summary>
+ [Tooltip("This defines the time-envelope of the signal. The raw signal will be time-scaled to fit in the envelope.")]
+ [CinemachineImpulseEnvelopeProperty]
+ public CinemachineImpulseManager.EnvelopeDefinition m_TimeEnvelope
+ = CinemachineImpulseManager.EnvelopeDefinition.Default();
+
+ /// <summary>
+ /// The signal will have full amplitude in this radius surrounding the impact point.
+ /// Beyond that it will dissipate with distance.
+ /// </summary>
+ [Header("Spatial Range")]
+ [Tooltip("The signal will have full amplitude in this radius surrounding the impact point. Beyond that it will dissipate with distance.")]
+ public float m_ImpactRadius = 100;
+
+ /// <summary>How the signal direction behaves as the listener moves away from the origin.</summary>
+ [Tooltip("How the signal direction behaves as the listener moves away from the origin.")]
+ public CinemachineImpulseManager.ImpulseEvent.DirectionMode m_DirectionMode
+ = CinemachineImpulseManager.ImpulseEvent.DirectionMode.Fixed;
+
+ /// <summary>
+ /// This defines how the signal will dissipate with distance beyond the impact radius.
+ /// </summary>
+ [Tooltip("This defines how the signal will dissipate with distance beyond the impact radius.")]
+ public CinemachineImpulseManager.ImpulseEvent.DissipationMode m_DissipationMode
+ = CinemachineImpulseManager.ImpulseEvent.DissipationMode.ExponentialDecay;
+
+ /// <summary>
+ /// At this distance beyond the impact radius, the signal will have dissipated to zero.
+ /// </summary>
+ [Tooltip("At this distance beyond the impact radius, the signal will have dissipated to zero.")]
+ public float m_DissipationDistance = 1000;
+
+ /// <summary>Call this from your behaviour's OnValidate to validate the fields here</summary>
+ public void OnValidate()
+ {
+ m_ImpactRadius = Mathf.Max(0, m_ImpactRadius);
+ m_DissipationDistance = Mathf.Max(0, m_DissipationDistance);
+ m_TimeEnvelope.Validate();
+ }
+
+ /// <summary>Generate an impulse event at a location in space,
+ /// and broadcast it on the appropriate impulse channel</summary>
+ public void CreateEvent(Vector3 position, Vector3 velocity)
+ {
+ if (m_RawSignal == null || Mathf.Abs(m_TimeEnvelope.Duration) < UnityVectorExtensions.Epsilon)
+ return;
+
+ CinemachineImpulseManager.ImpulseEvent e
+ = CinemachineImpulseManager.Instance.NewImpulseEvent();
+ e.m_Envelope = m_TimeEnvelope;
+
+ // Scale the time-envelope decay as the root of the amplitude scale
+ e.m_Envelope = m_TimeEnvelope;
+ if (m_TimeEnvelope.m_ScaleWithImpact)
+ e.m_Envelope.m_DecayTime *= Mathf.Sqrt(velocity.magnitude);
+
+ e.m_SignalSource = new SignalSource(this, velocity);
+ e.m_Position = position;
+ e.m_Radius = m_ImpactRadius;
+ e.m_Channel = m_ImpulseChannel;
+ e.m_DirectionMode = m_DirectionMode;
+ e.m_DissipationMode = m_DissipationMode;
+ e.m_DissipationDistance = m_DissipationDistance;
+ CinemachineImpulseManager.Instance.AddImpulseEvent(e);
+ }
+
+ // Wrap the raw signal to handle gain, RepeatMode, randomization, and velocity
+ class SignalSource : ISignalSource6D
+ {
+ CinemachineImpulseDefinition m_Def;
+ Vector3 m_Velocity;
+ float m_StartTimeOffset = 0;
+
+ public SignalSource(CinemachineImpulseDefinition def, Vector3 velocity)
+ {
+ m_Def = def;
+ m_Velocity = velocity;
+ if (m_Def.m_Randomize && m_Def.m_RawSignal.SignalDuration <= 0)
+ m_StartTimeOffset = UnityEngine.Random.Range(-1000f, 1000f);
+ }
+
+ public float SignalDuration { get { return m_Def.m_RawSignal.SignalDuration; } }
+
+ public void GetSignal(float timeSinceSignalStart, out Vector3 pos, out Quaternion rot)
+ {
+ float time = m_StartTimeOffset + timeSinceSignalStart * m_Def.m_FrequencyGain;
+
+ // Do we have to fit the signal into the envelope?
+ float signalDuration = SignalDuration;
+ if (signalDuration > 0)
+ {
+ if (m_Def.m_RepeatMode == RepeatMode.Loop)
+ time %= signalDuration;
+ else if (m_Def.m_TimeEnvelope.Duration > UnityVectorExtensions.Epsilon)
+ time *= m_Def.m_TimeEnvelope.Duration / signalDuration; // stretch
+ }
+
+ m_Def.m_RawSignal.GetSignal(time, out pos, out rot);
+ float gain = m_Velocity.magnitude;
+ Vector3 dir = m_Velocity.normalized;
+ gain *= m_Def.m_AmplitudeGain;
+ pos *= gain;
+ pos = Quaternion.FromToRotation(Vector3.down, m_Velocity) * pos;
+ rot = Quaternion.SlerpUnclamped(Quaternion.identity, rot, gain);
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 829b8a241d4653446a2cb2436c262305
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// An extension for Cinemachine Virtual Camera which post-processes
+ /// the final position of the virtual camera. It listens for CinemachineImpulse
+ /// signals on the specified channels, and moves the camera in response to them.
+ /// </summary>
+ [SaveDuringPlay]
+ [AddComponentMenu("")] // Hide in menu
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ public class CinemachineImpulseListener : CinemachineExtension
+ {
+ /// <summary>
+ /// Impulse events on channels not included in the mask will be ignored.
+ /// </summary>
+ [Tooltip("Impulse events on channels not included in the mask will be ignored.")]
+ [CinemachineImpulseChannelProperty]
+ public int m_ChannelMask = 1;
+
+ /// <summary>
+ /// Gain to apply to the Impulse signal.
+ /// </summary>
+ [Tooltip("Gain to apply to the Impulse signal. 1 is normal strength. Setting this to 0 completely mutes the signal.")]
+ public float m_Gain = 1;
+
+ /// <summary>
+ /// Enable this to perform distance calculation in 2D (ignore Z).
+ /// </summary>
+ [Tooltip("Enable this to perform distance calculation in 2D (ignore Z)")]
+ public bool m_Use2DDistance = false;
+
+ // GML todo: add reaction configuration params here
+
+ protected override void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
+ {
+ if (stage == CinemachineCore.Stage.Aim)
+ {
+ Vector3 impulsePos = Vector3.zero;
+ Quaternion impulseRot = Quaternion.identity;
+ if (CinemachineImpulseManager.Instance.GetImpulseAt(
+ state.FinalPosition, m_Use2DDistance, m_ChannelMask, out impulsePos, out impulseRot))
+ {
+ state.PositionCorrection += impulsePos * -m_Gain;
+ impulseRot = Quaternion.SlerpUnclamped(Quaternion.identity, impulseRot, -m_Gain);
+ state.OrientationCorrection = state.OrientationCorrection * impulseRot;
+ }
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 00b2d199b96b516448144ab30fb26aed
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using System;
+using System.Collections.Generic;
+using Cinemachine.Utility;
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// Property applied to CinemachineImpulseManager.EnvelopeDefinition.
+ /// Used for custom drawing in the inspector.
+ /// </summary>
+ public sealed class CinemachineImpulseEnvelopePropertyAttribute : PropertyAttribute {}
+
+ /// <summary>
+ /// Property applied to CinemachineImpulseManager Channels.
+ /// Used for custom drawing in the inspector.
+ /// </summary>
+ public sealed class CinemachineImpulseChannelPropertyAttribute : PropertyAttribute {}
+
+ /// <summary>
+ /// This is a singleton object that manages all Impulse Events generated by the Cinemachine
+ /// Impulse module. This singleton owns and manages all ImpulseEvent objectss.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.API)]
+ public class CinemachineImpulseManager
+ {
+ private CinemachineImpulseManager() {}
+ private static CinemachineImpulseManager sInstance = null;
+
+ /// <summary>Get the singleton instance</summary>
+ public static CinemachineImpulseManager Instance
+ {
+ get
+ {
+ if (sInstance == null)
+ sInstance = new CinemachineImpulseManager();
+ return sInstance;
+ }
+ }
+
+ const float Epsilon = UnityVectorExtensions.Epsilon;
+
+ /// <summary>This defines the time-envelope of the signal.
+ /// Thie raw signal will be scaled to fit inside the envelope.</summary>
+ [Serializable]
+ public struct EnvelopeDefinition
+ {
+ /// <summary>Normalized curve defining the shape of the start of the envelope.</summary>
+ [Tooltip("Normalized curve defining the shape of the start of the envelope. If blank a default curve will be used")]
+ public AnimationCurve m_AttackShape;
+
+ /// <summary>Normalized curve defining the shape of the end of the envelope.</summary>
+ [Tooltip("Normalized curve defining the shape of the end of the envelope. If blank a default curve will be used")]
+ public AnimationCurve m_DecayShape;
+
+ /// <summary>Duration in seconds of the attack. Attack curve will be scaled to fit. Must be >= 0</summary>
+ [Tooltip("Duration in seconds of the attack. Attack curve will be scaled to fit. Must be >= 0.")]
+ public float m_AttackTime; // Must be >= 0
+
+ /// <summary>Duration in seconds of the central fully-scaled part of the envelope. Must be >= 0.</summary>
+ [Tooltip("Duration in seconds of the central fully-scaled part of the envelope. Must be >= 0.")]
+ public float m_SustainTime; // Must be >= 0
+
+ /// <summary>Duration in seconds of the decay. Decay curve will be scaled to fit. Must be >= 0.</summary>
+ [Tooltip("Duration in seconds of the decay. Decay curve will be scaled to fit. Must be >= 0.")]
+ public float m_DecayTime; // Must be >= 0
+
+ /// <summary>If checked, signal amplitude scaling will also be applied to the time envelope of the signal. Bigger signals will last longer</summary>
+ [Tooltip("If checked, signal amplitude scaling will also be applied to the time envelope of the signal. Stronger signals will last longer.")]
+ public bool m_ScaleWithImpact;
+
+ /// <summary>If true, then duration is infinite.</summary>
+ [Tooltip("If true, then duration is infinite.")]
+ public bool m_HoldForever;
+
+ /// <summary>Get an envelope with default values.</summary>
+ public static EnvelopeDefinition Default()
+ {
+ return new EnvelopeDefinition { m_DecayTime = 0.7f, m_SustainTime = 0.2f, m_ScaleWithImpact = true };
+ }
+
+ /// <summary>Duration of the envelope, in seconds. If negative, then duration is infinite.</summary>
+ public float Duration
+ {
+ get
+ {
+ if (m_HoldForever)
+ return -1;
+ return m_AttackTime + m_SustainTime + m_DecayTime;
+ }
+ }
+
+ /// <summary>
+ /// Get the value of the tenvelope at a given time relative to the envelope start.
+ /// </summary>
+ /// <param name="offset">Time in seconds fromt he envelope start</param>
+ /// <returns>Envelope amplitude. This will range from 0...1</returns>
+ public float GetValueAt(float offset)
+ {
+ if (offset >= 0)
+ {
+ if (offset < m_AttackTime && m_AttackTime > Epsilon)
+ {
+ if (m_AttackShape == null || m_AttackShape.length < 2)
+ return Damper.Damp(1, m_AttackTime, offset);
+ return m_AttackShape.Evaluate(offset / m_AttackTime);
+ }
+ offset -= m_AttackTime;
+ if (m_HoldForever || offset < m_SustainTime)
+ return 1;
+ offset -= m_SustainTime;
+ if (offset < m_DecayTime && m_DecayTime > Epsilon)
+ {
+ if (m_DecayShape == null || m_DecayShape.length < 2)
+ return 1 - Damper.Damp(1, m_DecayTime, offset);
+ return m_DecayShape.Evaluate(offset / m_DecayTime);
+ }
+ }
+ return 0;
+ }
+
+ /// <summary>
+ /// Change the envelope so that it stops at a specific offset from its start time.
+ /// Use this to extend or cut short an existing envelope, while respecting the
+ /// attack and decay as much as possible.
+ /// </summary>
+ /// <param name="offset">When to stop the envelope</param>
+ /// <param name="forceNoDecay">If true, enevlope will not decay, but cut off instantly</param>
+ public void ChangeStopTime(float offset, bool forceNoDecay)
+ {
+ if (offset < 0)
+ offset = 0;
+ if (offset < m_AttackTime)
+ m_AttackTime = 0; // How to prevent pop? GML
+ m_SustainTime = offset - m_AttackTime;
+ if (forceNoDecay)
+ m_DecayTime = 0;
+ }
+
+ /// <summary>
+ /// Set the envelop times to 0 and the shapes to default.
+ /// </summary>
+ public void Clear()
+ {
+ m_AttackShape = m_DecayShape = null;
+ m_AttackTime = m_SustainTime = m_DecayTime = 0;
+ }
+
+ /// <summary>
+ /// Call from OnValidate to ensure that envelope values are sane
+ /// </summary>
+ public void Validate()
+ {
+ m_AttackTime = Mathf.Max(0, m_AttackTime);
+ m_DecayTime = Mathf.Max(0, m_DecayTime);
+ m_SustainTime = Mathf.Max(0, m_SustainTime);
+ }
+ }
+
+ /// <summary>Describes an event that generates an impulse signal on one or more channels.
+ /// The event has a location in space, a start time, a duration, and a signal. The signal
+ /// will dissipate as the distance from the event location increases.</summary>
+ public class ImpulseEvent
+ {
+ /// <summary>Start time of the event.</summary>
+ [Tooltip("Start time of the event.")]
+ public float m_StartTime;
+
+ /// <summary>Time-envelope of the signal.</summary>
+ [Tooltip("Time-envelope of the signal.")]
+ public EnvelopeDefinition m_Envelope;
+
+ /// <summary>Raw signal source. The ouput of this will be scaled to fit in the envelope.</summary>
+ [Tooltip("Raw signal source. The ouput of this will be scaled to fit in the envelope.")]
+ public ISignalSource6D m_SignalSource;
+
+ /// <summary>Worldspace origin of the signal.</summary>
+ [Tooltip("Worldspace origin of the signal.")]
+ public Vector3 m_Position;
+
+ /// <summary>Radius around the signal origin that has full signal value. Distance dissipation begins after this distance.</summary>
+ [Tooltip("Radius around the signal origin that has full signal value. Distance dissipation begins after this distance.")]
+ public float m_Radius;
+
+ /// <summary>How the signal behaves as the listener moves away from the origin.</summary>
+ public enum DirectionMode
+ {
+ /// <summary>Signal direction remains constant everywhere.</summary>
+ Fixed,
+ /// <summary>Signal is rotated in the direction of the source.</summary>
+ RotateTowardSource
+ }
+ /// <summary>How the signal direction behaves as the listener moves away from the source.</summary>
+ [Tooltip("How the signal direction behaves as the listener moves away from the source.")]
+ public DirectionMode m_DirectionMode = DirectionMode.Fixed;
+
+ /// <summary>Channels on which this event will broadcast its signal.</summary>
+ [Tooltip("Channels on which this event will broadcast its signal.")]
+ public int m_Channel;
+
+ /// <summary>How the signal dissipates with distance.</summary>
+ public enum DissipationMode
+ {
+ /// <summary>Simple linear interpolation to zero over the dissipation distance.</summary>
+ LinearDecay,
+ /// <summary>Ease-in-ease-out dissipation over the dissipation distance.</summary>
+ SoftDecay,
+ /// <summary>Half-life decay, hard out from full and ease into 0 over the dissipation distance.</summary>
+ ExponentialDecay
+ }
+
+ /// <summary>How the signal dissipates with distance.</summary>
+ [Tooltip("How the signal dissipates with distance.")]
+ public DissipationMode m_DissipationMode;
+
+ /// <summary>Distance over which the dissipation occurs. Must be >= 0.</summary>
+ [Tooltip("Distance over which the dissipation occurs. Must be >= 0.")]
+ public float m_DissipationDistance;
+
+ /// <summary>Returns true if the event is no longer generating a signal because its time has expired</summary>
+ public bool Expired
+ {
+ get
+ {
+ var d = m_Envelope.Duration;
+ return d > 0 && m_StartTime + d <= Time.time;
+ }
+ }
+
+ /// <summary>Cancel the event at the supplied time</summary>
+ /// <param name="time">The time at which to cancel the event</param>
+ /// <param name="forceNoDecay">If true, event will be cut immediately at the time,
+ /// otherwise its envelope's decay curve will begin at the cancel time</param>
+ public void Cancel(float time, bool forceNoDecay)
+ {
+ m_Envelope.ChangeStopTime(time - m_StartTime, forceNoDecay);
+ }
+
+ /// <summary>Calculate the the decay applicable at a given distance from the impact point</summary>
+ /// <returns>Scale factor 0...1</returns>
+ public float DistanceDecay(float distance)
+ {
+ float radius = Mathf.Max(m_Radius, 0);
+ if (distance < radius)
+ return 1;
+ distance -= radius;
+ if (distance >= m_DissipationDistance)
+ return 0;
+ switch (m_DissipationMode)
+ {
+ default:
+ case DissipationMode.LinearDecay:
+ return Mathf.Lerp(1, 0, distance / m_DissipationDistance);
+ case DissipationMode.SoftDecay:
+ return 0.5f * (1 + Mathf.Cos(Mathf.PI * (distance / m_DissipationDistance)));
+ case DissipationMode.ExponentialDecay:
+ return 1 - Damper.Damp(1, m_DissipationDistance, distance);
+ }
+ }
+
+ /// <summary>Get the signal that a listener at a given position would perceive</summary>
+ /// <param name="listenerPosition">The listener's position in world space</param>
+ /// <param name="use2D">True if distance calculation should ignore Z</param>
+ /// <param name="pos">The position impulse signal</param>
+ /// <param name="rot">The rotation impulse signal</param>
+ /// <returns>true if non-trivial signal is returned</returns>
+ public bool GetDecayedSignal(Vector3 listenerPosition, bool use2D, out Vector3 pos, out Quaternion rot)
+ {
+ if (m_SignalSource != null)
+ {
+ float time = Time.time - m_StartTime;
+ float distance = use2D ? Vector2.Distance(listenerPosition, m_Position)
+ : Vector3.Distance(listenerPosition, m_Position);
+ float scale = m_Envelope.GetValueAt(time) * DistanceDecay(distance);
+ m_SignalSource.GetSignal(time, out pos, out rot);
+ pos *= scale;
+ rot = Quaternion.SlerpUnclamped(Quaternion.identity, rot, scale);
+ if (m_DirectionMode == DirectionMode.RotateTowardSource && distance > Epsilon)
+ {
+ Quaternion q = Quaternion.FromToRotation(Vector3.up, listenerPosition - m_Position);
+ if (m_Radius > Epsilon)
+ {
+ float t = Mathf.Clamp01(distance / m_Radius);
+ q = Quaternion.Slerp(
+ q, Quaternion.identity, Mathf.Cos(Mathf.PI * t / 2));
+ }
+ pos = q * pos;
+ rot = Quaternion.Inverse(q) * rot * q;
+ }
+ return true;
+ }
+ pos = Vector3.zero;
+ rot = Quaternion.identity;
+ return false;
+ }
+
+ /// <summary>Reset the event to a default state</summary>
+ public void Clear()
+ {
+ m_Envelope.Clear();
+ m_StartTime = 0;
+ m_SignalSource = null;
+ m_Position = Vector3.zero;
+ m_Channel = 0;
+ m_Radius = 0;
+ m_DissipationDistance = 100;
+ m_DissipationMode = DissipationMode.ExponentialDecay;
+ }
+
+ /// <summary>Don't create them yourself. Use CinemachineImpulseManager.NewImpulseEvent().</summary>
+ internal ImpulseEvent() {}
+ }
+
+ List<ImpulseEvent> m_ExpiredEvents;
+ List<ImpulseEvent> m_ActiveEvents;
+
+ /// <summary>Get the signal perceived by a listener at a geven location</summary>
+ /// <param name="listenerLocation">Where the listener is, in world coords</param>
+ /// <param name="distance2D">True if distance calculation should ignore Z</param>
+ /// <param name="channelMask">Only Impulse signals on channels in this mask will be considered</param>
+ /// <param name="pos">The combined position impulse signal resulting from all signals active on the specified channels</param>
+ /// <param name="rot">The combined rotation impulse signal resulting from all signals active on the specified channels</param>
+ /// <returns>true if non-trivial signal is returned</returns>
+ public bool GetImpulseAt(
+ Vector3 listenerLocation, bool distance2D, int channelMask,
+ out Vector3 pos, out Quaternion rot)
+ {
+ bool nontrivialResult = false;
+ pos = Vector3.zero;
+ rot = Quaternion.identity;
+ if (m_ActiveEvents != null)
+ {
+ for (int i = m_ActiveEvents.Count - 1; i >= 0; --i)
+ {
+ ImpulseEvent e = m_ActiveEvents[i];
+ // Prune invalid or expired events
+ if (e == null || e.Expired)
+ {
+ m_ActiveEvents.RemoveAt(i);
+ if (e != null)
+ {
+ // Recycle it
+ if (m_ExpiredEvents == null)
+ m_ExpiredEvents = new List<ImpulseEvent>();
+ e.Clear();
+ m_ExpiredEvents.Add(e);
+ }
+ }
+ else if ((e.m_Channel & channelMask) != 0)
+ {
+ Vector3 pos0 = Vector3.zero;
+ Quaternion rot0 = Quaternion.identity;
+ if (e.GetDecayedSignal(listenerLocation, distance2D, out pos0, out rot0))
+ {
+ nontrivialResult = true;
+ pos += pos0;
+ rot *= rot0;
+ }
+ }
+ }
+ }
+ return nontrivialResult;
+ }
+
+ /// <summary>Get a new ImpulseEvent</summary>
+ public ImpulseEvent NewImpulseEvent()
+ {
+ ImpulseEvent e;
+ if (m_ExpiredEvents == null || m_ExpiredEvents.Count == 0)
+ return new ImpulseEvent();
+ e = m_ExpiredEvents[m_ExpiredEvents.Count-1];
+ m_ExpiredEvents.RemoveAt(m_ExpiredEvents.Count-1);
+ return e;
+ }
+
+ /// <summary>Activate an impulse event, so that it may begin broadcasting its signal</summary>
+ /// Events will be automatically removed after they expire.
+ /// You can tweak the ImpulseEvent fields dynamically if you keep a pointer to it.
+ public void AddImpulseEvent(ImpulseEvent e)
+ {
+ if (m_ActiveEvents == null)
+ m_ActiveEvents = new List<ImpulseEvent>();
+ if (e != null)
+ {
+ e.m_StartTime = Time.time;
+ m_ActiveEvents.Add(e);
+ }
+ }
+
+ /// <summary>Immediately terminate all active impulse signals</summary>
+ public void Clear()
+ {
+ if (m_ActiveEvents != null)
+ {
+ for (int i = 0; i < m_ActiveEvents.Count; ++i)
+ m_ActiveEvents[i].Clear();
+ m_ActiveEvents.Clear();
+ }
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: eb25eb9c85a88c94aa253071e03aca6e
+timeCreated: 1518026885
+licenseType: Pro
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+
+namespace Cinemachine
+{
+ /// <summary>
+ /// An event-driven class that broadcasts an impulse signal to listeners.
+ ///
+ /// This is the base class for custom impulse sources. It contains an impulse
+ /// definition, where the characteristics of the impulse signal are defined.
+ ///
+ /// API methods are fined for actually broadcasting the impulse. Call these
+ /// methods from your custom code, or hook them up to game events in the Editor.
+ ///
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+ [SaveDuringPlay]
+ public class CinemachineImpulseSource : MonoBehaviour
+ {
+ /// <summary>
+ /// This defines the complete impulse signal that will be broadcast.
+ /// </summary>
+ [CinemachineImpulseDefinitionProperty]
+ public CinemachineImpulseDefinition m_ImpulseDefinition = new CinemachineImpulseDefinition();
+
+ private void OnValidate()
+ {
+ m_ImpulseDefinition.OnValidate();
+ }
+
+ /// <summary>Broadcast the Impulse Signal onto the appropriate channels,
+ /// using a custom position and impact velocity</summary>
+ /// <param name="position">The world-space position from which the impulse will emanate</param>
+ /// <param name="velocity">The impact magnitude and direction</param>
+ public void GenerateImpulseAt(Vector3 position, Vector3 velocity)
+ {
+ if (m_ImpulseDefinition != null)
+ m_ImpulseDefinition.CreateEvent(position, velocity);
+ }
+
+ /// <summary>Broadcast the Impulse Signal onto the appropriate channels, using
+ /// a custom impact velocity, and this transfom's position.</summary>
+ /// <param name="velocity">The impact magnitude and direction</param>
+ public void GenerateImpulse(Vector3 velocity)
+ {
+ GenerateImpulseAt(transform.position, velocity);
+ }
+
+ /// <summary>Broadcast the Impulse Signal onto the appropriate channels,
+ /// with default velocity = (0, -1, 0), and a default position which is
+ /// this transform's location.</summary>
+ public void GenerateImpulse()
+ {
+ GenerateImpulse(Vector3.down);
+ }
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 180ecf9b41d478f468eb3e9083753217
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 73dae0f38fe36064e80bee257b7da7b9
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_POST_PROCESSING_V2
+
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering.PostProcessing;
+
+namespace Cinemachine.PostFX
+{
+ /// <summary>
+ /// This behaviour is a liaison between Cinemachine with the Post-Processing v2 module. You must
+ /// have the Post-Processing V2 stack asset store package installed in order to use this behaviour.
+ ///
+ /// As a component on the Virtual Camera, it holds
+ /// a Post-Processing Profile asset that will be applied to the Unity camera whenever
+ /// the Virtual camera is live. It also has the optional functionality of animating
+ /// the Focus Distance and DepthOfField properties of the Camera State, and
+ /// applying them to the current Post-Processing profile, provided that profile has a
+ /// DepthOfField effect that is enabled.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("")] // Hide in menu
+ [SaveDuringPlay]
+ public class CinemachinePostProcessing : CinemachineExtension
+ {
+ [Tooltip("If checked, then the Focus Distance will be set to the distance between the camera and the LookAt target. Requires DepthOfField effect in the Profile")]
+ public bool m_FocusTracksTarget;
+
+ [Tooltip("Offset from target distance, to be used with Focus Tracks Target. Offsets the sharpest point away from the LookAt target.")]
+ public float m_FocusOffset;
+
+ [Tooltip("This Post-Processing profile will be applied whenever this virtual camera is live")]
+ public PostProcessProfile m_Profile;
+
+ bool mCachedProfileIsInvalid = true;
+ PostProcessProfile mProfileCopy;
+ public PostProcessProfile Profile { get { return mProfileCopy != null ? mProfileCopy : m_Profile; } }
+
+ /// <summary>True if the profile is enabled and nontrivial</summary>
+ public bool IsValid { get { return m_Profile != null && m_Profile.settings.Count > 0; } }
+
+ /// <summary>Called by the editor when the shared asset has been edited</summary>
+ public void InvalidateCachedProfile() { mCachedProfileIsInvalid = true; }
+
+ void CreateProfileCopy()
+ {
+ DestroyProfileCopy();
+ PostProcessProfile profile = ScriptableObject.CreateInstance<PostProcessProfile>();
+ if (m_Profile != null)
+ {
+ foreach (var item in m_Profile.settings)
+ {
+ var itemCopy = Instantiate(item);
+ profile.settings.Add(itemCopy);
+ }
+ }
+ mProfileCopy = profile;
+ mCachedProfileIsInvalid = false;
+ }
+
+ void DestroyProfileCopy()
+ {
+ if (mProfileCopy != null)
+ RuntimeUtility.DestroyObject(mProfileCopy);
+ mProfileCopy = null;
+ }
+
+ protected override void OnDestroy()
+ {
+ base.OnDestroy();
+ DestroyProfileCopy();
+ }
+
+ protected override void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
+ {
+ // Set the focus after the camera has been fully positioned.
+ // GML todo: what about collider?
+ if (stage == CinemachineCore.Stage.Aim)
+ {
+ if (!IsValid)
+ DestroyProfileCopy();
+ else
+ {
+ // Handle Follow Focus
+ if (!m_FocusTracksTarget)
+ DestroyProfileCopy();
+ else
+ {
+ if (mProfileCopy == null || mCachedProfileIsInvalid)
+ CreateProfileCopy();
+ DepthOfField dof;
+ if (mProfileCopy.TryGetSettings(out dof))
+ {
+ float focusDistance = m_FocusOffset;
+ if (state.HasLookAt)
+ focusDistance += (state.FinalPosition - state.ReferenceLookAt).magnitude;
+ dof.focusDistance.value = Mathf.Max(0, focusDistance);
+ }
+ }
+
+ // Apply the post-processing
+ state.AddCustomBlendable(new CameraState.CustomBlendable(this, 1));
+ }
+ }
+ }
+
+ static void OnCameraCut(CinemachineBrain brain)
+ {
+ // Debug.Log("Camera cut event");
+ PostProcessLayer postFX = GetPPLayer(brain);
+ if (postFX != null)
+ postFX.ResetHistory();
+ }
+
+ static void ApplyPostFX(CinemachineBrain brain)
+ {
+ PostProcessLayer ppLayer = GetPPLayer(brain);
+ if (ppLayer == null || !ppLayer.enabled || ppLayer.volumeLayer == 0)
+ return;
+
+ CameraState state = brain.CurrentCameraState;
+ int numBlendables = state.NumCustomBlendables;
+ List<PostProcessVolume> volumes = GetDynamicBrainVolumes(brain, ppLayer, numBlendables);
+ for (int i = 0; i < volumes.Count; ++i)
+ {
+ volumes[i].weight = 0;
+ volumes[i].sharedProfile = null;
+ volumes[i].profile = null;
+ }
+ PostProcessVolume firstVolume = null;
+ int numPPblendables = 0;
+ for (int i = 0; i < numBlendables; ++i)
+ {
+ var b = state.GetCustomBlendable(i);
+ CinemachinePostProcessing src = b.m_Custom as CinemachinePostProcessing;
+ if (!(src == null)) // in case it was deleted
+ {
+ PostProcessVolume v = volumes[i];
+ if (firstVolume == null)
+ firstVolume = v;
+ v.sharedProfile = src.Profile;
+ v.isGlobal = true;
+ v.priority = float.MaxValue-(numBlendables-i)-1;
+ v.weight = b.m_Weight;
+ ++numPPblendables;
+ }
+#if true // set this to true to force first weight to 1
+ // If more than one volume, then set the frst one's weight to 1
+ if (numPPblendables > 1)
+ firstVolume.weight = 1;
+#endif
+ }
+ }
+
+ static string sVolumeOwnerName = "__CMVolumes";
+ static List<PostProcessVolume> sVolumes = new List<PostProcessVolume>();
+ static List<PostProcessVolume> GetDynamicBrainVolumes(
+ CinemachineBrain brain, PostProcessLayer ppLayer, int minVolumes)
+ {
+ // Locate the camera's child object that holds our dynamic volumes
+ GameObject volumeOwner = null;
+ Transform t = brain.transform;
+ int numChildren = t.childCount;
+
+ sVolumes.Clear();
+ for (int i = 0; volumeOwner == null && i < numChildren; ++i)
+ {
+ GameObject child = t.GetChild(i).gameObject;
+ if (child.hideFlags == HideFlags.HideAndDontSave)
+ {
+ child.GetComponents(sVolumes);
+ if (sVolumes.Count > 0)
+ volumeOwner = child;
+ }
+ }
+
+ if (minVolumes > 0)
+ {
+ if (volumeOwner == null)
+ {
+ volumeOwner = new GameObject(sVolumeOwnerName);
+ volumeOwner.hideFlags = HideFlags.HideAndDontSave;
+ volumeOwner.transform.parent = t;
+ }
+ // Update the volume's layer so it will be seen
+ int mask = ppLayer.volumeLayer.value;
+ for (int i = 0; i < 32; ++i)
+ {
+ if ((mask & (1 << i)) != 0)
+ {
+ volumeOwner.layer = i;
+ break;
+ }
+ }
+ while (sVolumes.Count < minVolumes)
+ sVolumes.Add(volumeOwner.gameObject.AddComponent<PostProcessVolume>());
+ }
+ return sVolumes;
+ }
+
+ static Dictionary<CinemachineBrain, PostProcessLayer> mBrainToLayer
+ = new Dictionary<CinemachineBrain, PostProcessLayer>();
+
+ static PostProcessLayer GetPPLayer(CinemachineBrain brain)
+ {
+ PostProcessLayer layer = null;
+ if (mBrainToLayer.TryGetValue(brain, out layer))
+ {
+#if UNITY_EDITOR
+ // Maybe they added it since we last checked
+ if (layer != null || Application.isPlaying)
+#endif
+ return layer;
+ }
+ layer = brain.GetComponent<PostProcessLayer>();
+ mBrainToLayer[brain] = layer;
+ if (layer != null)
+ brain.m_CameraCutEvent.AddListener(OnCameraCut);
+ else
+ brain.m_CameraCutEvent.RemoveListener(OnCameraCut);
+ return layer;
+ }
+
+#if UNITY_EDITOR
+ [UnityEditor.InitializeOnLoad]
+ class EditorInitialize { static EditorInitialize() { InitializeModule(); } }
+#endif
+ [RuntimeInitializeOnLoadMethod]
+ static void InitializeModule()
+ {
+ // Afetr the brain pushes the state to the camera, hook in to the PostFX
+ CinemachineCore.CameraUpdatedEvent.RemoveListener(ApplyPostFX);
+ CinemachineCore.CameraUpdatedEvent.AddListener(ApplyPostFX);
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 729aad4491e915a41bda2b8325cf757a
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_POST_PROCESSING_V3
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+
+namespace Cinemachine.PostFX
+{
+ /// <summary>
+ /// This behaviour is a liaison between Cinemachine with the Post-Processing v3 module.
+ ///
+ /// As a component on the Virtual Camera, it holds
+ /// a Post-Processing Profile asset that will be applied to the Unity camera whenever
+ /// the Virtual camera is live. It also has the optional functionality of animating
+ /// the Focus Distance and DepthOfField properties of the Camera State, and
+ /// applying them to the current Post-Processing profile, provided that profile has a
+ /// DepthOfField effect that is enabled.
+ /// </summary>
+ [DocumentationSorting(DocumentationSortingAttribute.Level.UserRef)]
+#if UNITY_2018_3_OR_NEWER
+ [ExecuteAlways]
+#else
+ [ExecuteInEditMode]
+#endif
+ [AddComponentMenu("")] // Hide in menu
+ [SaveDuringPlay]
+ public class CinemachineVolumeSettings : CinemachineExtension
+ {
+ [Tooltip("If checked, then the Focus Distance will be set to the distance between the camera and the LookAt target. Requires DepthOfField effect in the Profile")]
+ public bool m_FocusTracksTarget;
+
+ [Tooltip("Offset from target distance, to be used with Focus Tracks Target. Offsets the sharpest point away from the LookAt target.")]
+ public float m_FocusOffset;
+
+ [Tooltip("This Post-Processing profile will be applied whenever this virtual camera is live")]
+ public VolumeProfile m_Profile;
+
+ bool mCachedProfileIsInvalid = true;
+ VolumeProfile mProfileCopy;
+ public VolumeProfile Profile { get { return mProfileCopy != null ? mProfileCopy : m_Profile; } }
+
+ /// <summary>True if the profile is enabled and nontrivial</summary>
+ public bool IsValid { get { return m_Profile != null && m_Profile.components.Count > 0; } }
+
+ /// <summary>Called by the editor when the shared asset has been edited</summary>
+ public void InvalidateCachedProfile() { mCachedProfileIsInvalid = true; }
+
+ void CreateProfileCopy()
+ {
+ DestroyProfileCopy();
+ VolumeProfile profile = ScriptableObject.CreateInstance<VolumeProfile>();
+ if (m_Profile != null)
+ {
+ foreach (var item in m_Profile.components)
+ {
+ var itemCopy = Instantiate(item);
+ profile.components.Add(itemCopy);
+ }
+ }
+ mProfileCopy = profile;
+ mCachedProfileIsInvalid = false;
+ }
+
+ void DestroyProfileCopy()
+ {
+ if (mProfileCopy != null)
+ RuntimeUtility.DestroyObject(mProfileCopy);
+ mProfileCopy = null;
+ }
+
+ protected override void OnDestroy()
+ {
+ base.OnDestroy();
+ DestroyProfileCopy();
+ }
+
+ protected override void PostPipelineStageCallback(
+ CinemachineVirtualCameraBase vcam,
+ CinemachineCore.Stage stage, ref CameraState state, float deltaTime)
+ {
+ // Set the focus after the camera has been fully positioned.
+ // GML todo: what about collider?
+ if (stage == CinemachineCore.Stage.Aim)
+ {
+ if (!IsValid)
+ DestroyProfileCopy();
+ else
+ {
+ // Handle Follow Focus
+ if (!m_FocusTracksTarget)
+ DestroyProfileCopy();
+ else
+ {
+ if (mProfileCopy == null || mCachedProfileIsInvalid)
+ CreateProfileCopy();
+
+ DepthOfField dof;
+ if (m_Profile.TryGet(out dof))
+ {
+ float focusDistance = m_FocusOffset;
+ if (state.HasLookAt)
+ focusDistance += (state.FinalPosition - state.ReferenceLookAt).magnitude;
+ dof.focusDistance.value = Mathf.Max(0, focusDistance);
+ }
+ }
+ // Apply the post-processing
+ state.AddCustomBlendable(new CameraState.CustomBlendable(this, 1));
+ }
+ }
+ }
+
+ static void OnCameraCut(CinemachineBrain brain)
+ {
+ // Debug.Log("Camera cut event");
+/*
+ PostProcessLayer postFX = GetPPLayer(brain);
+ if (postFX != null)
+ postFX.ResetHistory();
+*/
+ }
+
+ static void ApplyPostFX(CinemachineBrain brain)
+ {
+ CameraState state = brain.CurrentCameraState;
+ int numBlendables = state.NumCustomBlendables;
+ var volumes = GetDynamicBrainVolumes(brain, numBlendables);
+ for (int i = 0; i < volumes.Count; ++i)
+ {
+ volumes[i].weight = 0;
+ volumes[i].sharedProfile = null;
+ volumes[i].profile = null;
+ }
+ Volume firstVolume = null;
+ int numPPblendables = 0;
+ for (int i = 0; i < numBlendables; ++i)
+ {
+ var b = state.GetCustomBlendable(i);
+ CinemachineVolumeSettings src = b.m_Custom as CinemachineVolumeSettings;
+ if (!(src == null)) // in case it was deleted
+ {
+ var v = volumes[i];
+ if (firstVolume == null)
+ firstVolume = v;
+ v.sharedProfile = src.Profile;
+ v.isGlobal = true;
+ v.priority = float.MaxValue-(numBlendables-i)-1;
+ v.weight = b.m_Weight;
+ ++numPPblendables;
+ }
+#if true // set this to true to force first weight to 1
+ // If more than one volume, then set the frst one's weight to 1
+ if (numPPblendables > 1)
+ firstVolume.weight = 1;
+#endif
+ }
+ }
+
+ static string sVolumeOwnerName = "__CMVolumes";
+ static List<Volume> sVolumes = new List<Volume>();
+ static List<Volume> GetDynamicBrainVolumes(CinemachineBrain brain, int minVolumes)
+ {
+ // Locate the camera's child object that holds our dynamic volumes
+ GameObject volumeOwner = null;
+ Transform t = brain.transform;
+ int numChildren = t.childCount;
+
+ sVolumes.Clear();
+ for (int i = 0; volumeOwner == null && i < numChildren; ++i)
+ {
+ GameObject child = t.GetChild(i).gameObject;
+ if (child.hideFlags == HideFlags.HideAndDontSave)
+ {
+ child.GetComponents(sVolumes);
+ if (sVolumes.Count > 0)
+ volumeOwner = child;
+ }
+ }
+
+ if (minVolumes > 0)
+ {
+ if (volumeOwner == null)
+ {
+ volumeOwner = new GameObject(sVolumeOwnerName);
+ volumeOwner.hideFlags = HideFlags.HideAndDontSave;
+ volumeOwner.transform.parent = t;
+ }
+/*
+ // Update the volume's layer so it will be seen
+ int mask = ppLayer.volumeLayer.value;
+ for (int i = 0; i < 32; ++i)
+ {
+ if ((mask & (1 << i)) != 0)
+ {
+ volumeOwner.layer = i;
+ break;
+ }
+ }
+*/
+ while (sVolumes.Count < minVolumes)
+ sVolumes.Add(volumeOwner.gameObject.AddComponent<Volume>());
+ }
+ return sVolumes;
+ }
+
+#if UNITY_EDITOR
+ [UnityEditor.InitializeOnLoad]
+ class EditorInitialize { static EditorInitialize() { InitializeModule(); } }
+#endif
+ [RuntimeInitializeOnLoadMethod]
+ static void InitializeModule()
+ {
+ // Afetr the brain pushes the state to the camera, hook in to the PostFX
+ CinemachineCore.CameraUpdatedEvent.RemoveListener(ApplyPostFX);
+ CinemachineCore.CameraUpdatedEvent.AddListener(ApplyPostFX);
+ }
+ }
+}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 449ef5ebbe24720439ec31d15f7b6f3d
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {fileID: 2800000, guid: 5f2a108eb023faf43a809979fd3d38f2, type: 3}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 0282251d79d6e964089ace2dc6e6e496
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_TIMELINE
+
+using UnityEngine;
+using UnityEngine.Playables;
+using Cinemachine;
+
+//namespace Cinemachine.Timeline
+//{
+ internal sealed class CinemachineMixer : PlayableBehaviour
+ {
+ // The brain that this track controls
+ private CinemachineBrain mBrain;
+ private int mBrainOverrideId = -1;
+ private bool mPlaying;
+
+ public override void OnPlayableDestroy(Playable playable)
+ {
+ if (mBrain != null)
+ mBrain.ReleaseCameraOverride(mBrainOverrideId); // clean up
+ mBrainOverrideId = -1;
+ }
+
+ public override void PrepareFrame(Playable playable, FrameData info)
+ {
+ mPlaying = info.evaluationType == FrameData.EvaluationType.Playback;
+ }
+
+ struct ClipInfo
+ {
+ public ICinemachineCamera vcam;
+ public float weight;
+ public double localTime;
+ public double duration;
+ }
+
+ public override void ProcessFrame(Playable playable, FrameData info, object playerData)
+ {
+ base.ProcessFrame(playable, info, playerData);
+
+ // Get the brain that this track controls.
+ // Older versions of timeline sent the gameObject by mistake.
+ GameObject go = playerData as GameObject;
+ if (go == null)
+ mBrain = (CinemachineBrain)playerData;
+ else
+ mBrain = go.GetComponent<CinemachineBrain>();
+ if (mBrain == null)
+ return;
+
+ // Find which clips are active. We can process a maximum of 2.
+ // In the case that the weights don't add up to 1, the outgoing weight
+ // will be calculated as the inverse of the incoming weight.
+ int activeInputs = 0;
+ ClipInfo clipA = new ClipInfo();
+ ClipInfo clipB = new ClipInfo();
+ for (int i = 0; i < playable.GetInputCount(); ++i)
+ {
+ float weight = playable.GetInputWeight(i);
+ var clip = (ScriptPlayable<CinemachineShotPlayable>)playable.GetInput(i);
+ CinemachineShotPlayable shot = clip.GetBehaviour();
+ if (shot != null && shot.IsValid
+ && playable.GetPlayState() == PlayState.Playing
+ && weight > 0)
+ {
+ clipA = clipB;
+ clipB.vcam = shot.VirtualCamera;
+ clipB.weight = weight;
+ clipB.localTime = clip.GetTime();
+ clipB.duration = clip.GetDuration();
+ if (++activeInputs == 2)
+ break;
+ }
+ }
+
+ // Figure out which clip is incoming
+ bool incomingIsB = clipB.weight >= 1 || clipB.localTime < clipB.duration / 2;
+ if (activeInputs == 2)
+ {
+ if (clipB.localTime < clipA.localTime)
+ incomingIsB = true;
+ else if (clipB.localTime > clipA.localTime)
+ incomingIsB = false;
+ else
+ incomingIsB = clipB.duration >= clipA.duration;
+ }
+
+ // Override the Cinemachine brain with our results
+ ICinemachineCamera camA = incomingIsB ? clipA.vcam : clipB.vcam;
+ ICinemachineCamera camB = incomingIsB ? clipB.vcam : clipA.vcam;
+ float camWeightB = incomingIsB ? clipB.weight : 1 - clipB.weight;
+ mBrainOverrideId = mBrain.SetCameraOverride(
+ mBrainOverrideId, camA, camB, camWeightB, GetDeltaTime(info.deltaTime));
+ }
+
+ float mLastOverrideFrame;
+ float GetDeltaTime(float deltaTime)
+ {
+ if (!mPlaying)
+ {
+ if (mBrainOverrideId < 0)
+ mLastOverrideFrame = -1;
+ float time = Time.realtimeSinceStartup;
+ deltaTime = Time.unscaledDeltaTime;
+ if (!Application.isPlaying
+ && (mLastOverrideFrame < 0 || time - mLastOverrideFrame > Time.maximumDeltaTime))
+ {
+ deltaTime = -1;
+ }
+ mLastOverrideFrame = time;
+ }
+ return deltaTime;
+ }
+ }
+//}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 961772e8b1d75dd4a915fb8a236d5a8a
+timeCreated: 1489083733
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_TIMELINE
+
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+using Cinemachine;
+
+//namespace Cinemachine.Timeline
+//{
+ /// <summary>
+ /// Internal use only. Not part of the public API.
+ /// </summary>
+ public sealed class CinemachineShot : PlayableAsset, IPropertyPreview
+ {
+ public ExposedReference<CinemachineVirtualCameraBase> VirtualCamera;
+
+ public override Playable CreatePlayable(PlayableGraph graph, GameObject owner)
+ {
+ var playable = ScriptPlayable<CinemachineShotPlayable>.Create(graph);
+ playable.GetBehaviour().VirtualCamera = VirtualCamera.Resolve(graph.GetResolver());
+ return playable;
+ }
+
+ // IPropertyPreview implementation
+ public void GatherProperties(PlayableDirector director, IPropertyCollector driver)
+ {
+ driver.AddFromName<Transform>("m_LocalPosition.x");
+ driver.AddFromName<Transform>("m_LocalPosition.y");
+ driver.AddFromName<Transform>("m_LocalPosition.z");
+ driver.AddFromName<Transform>("m_LocalRotation.x");
+ driver.AddFromName<Transform>("m_LocalRotation.y");
+ driver.AddFromName<Transform>("m_LocalRotation.z");
+
+ driver.AddFromName<Camera>("field of view");
+ driver.AddFromName<Camera>("near clip plane");
+ driver.AddFromName<Camera>("far clip plane");
+ }
+ }
+//}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 90fb794a295e73545af71bcdb7375791
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_TIMELINE
+
+using UnityEngine.Playables;
+using Cinemachine;
+
+//namespace Cinemachine.Timeline
+//{
+ internal sealed class CinemachineShotPlayable : PlayableBehaviour
+ {
+ public CinemachineVirtualCameraBase VirtualCamera;
+ public bool IsValid { get { return VirtualCamera != null; } }
+ }
+//}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 5356d1db487a5284fb27af2798adad33
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+#if CINEMACHINE_TIMELINE
+
+using System;
+using UnityEngine;
+using UnityEngine.Playables;
+using UnityEngine.Timeline;
+using Cinemachine;
+
+//namespace Cinemachine.Timeline
+//{
+ [Serializable]
+ [TrackClipType(typeof(CinemachineShot))]
+#if !UNITY_2018_2_OR_NEWER
+ [TrackMediaType(TimelineAsset.MediaType.Script)]
+#endif
+#if UNITY_2018_3_OR_NEWER
+ [TrackBindingType(typeof(CinemachineBrain), TrackBindingFlags.None)]
+#else
+ [TrackBindingType(typeof(CinemachineBrain))]
+#endif
+ [TrackColor(0.53f, 0.0f, 0.08f)]
+ public class CinemachineTrack : TrackAsset
+ {
+ public override Playable CreateTrackMixer(
+ PlayableGraph graph, GameObject go, int inputCount)
+ {
+ // Hack to set the display name of the clip to match the vcam
+ foreach (var c in GetClips())
+ {
+ CinemachineShot shot = (CinemachineShot)c.asset;
+ CinemachineVirtualCameraBase vcam = shot.VirtualCamera.Resolve(graph.GetResolver());
+ if (vcam != null)
+ c.displayName = vcam.Name;
+ }
+
+ var mixer = ScriptPlayable<CinemachineMixer>.Create(graph);
+ mixer.SetInputCount(inputCount);
+ return mixer;
+ }
+ }
+//}
+#endif
--- /dev/null
+fileFormatVersion: 2
+guid: 05acc715f855ced458d76ee6f8ac6c61
+timeCreated: 1489083732
+licenseType: Pro
+MonoImporter:
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+{
+ "name": "Cinemachine",
+ "references": [
+ "GUID:f06555f75b070af458a003d92f9efb00",
+ "GUID:d60799ab2a985554ea1a39cd38695018",
+ "GUID:df380645f10b7bc4b97d4f5eb6303d95",
+ "GUID:457756d89b35d2941b3e7b37b4ece6f1",
+ "GUID:2bafac87e7f4b9b418d9448d219b01ab"
+ ],
+ "includePlatforms": [],
+ "excludePlatforms": [],
+ "allowUnsafeCode": false,
+ "overrideReferences": false,
+ "precompiledReferences": [],
+ "autoReferenced": true,
+ "defineConstraints": [],
+ "versionDefines": [
+ {
+ "name": "com.unity.postprocessing",
+ "expression": "2.1.0",
+ "define": "CINEMACHINE_POST_PROCESSING_V2"
+ },
+ {
+ "name": "com.unity.timeline",
+ "expression": "0.0.0-builtin",
+ "define": "CINEMACHINE_TIMELINE"
+ },
+ {
+ "name": "com.unity.render-pipelines.high-definition",
+ "expression": "5.3.1",
+ "define": "CINEMACHINE_POST_PROCESSING_V3"
+ },
+ {
+ "name": "com.unity.modules.physics2d",
+ "expression": "1.0.0",
+ "define": "CINEMACHINE_PHYSICS_2D"
+ },
+ {
+ "name": "com.unity.modules.physics",
+ "expression": "1.0.0",
+ "define": "CINEMACHINE_PHYSICS"
+ },
+ {
+ "name": "com.unity.ugui",
+ "expression": "1.0.0",
+ "define": "CINEMACHINE_UGUI"
+ }
+ ]
+}
\ No newline at end of file
--- /dev/null
+fileFormatVersion: 2
+guid: 4307f53044263cf4b835bd812fc161a4
+AssemblyDefinitionImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 5315d0eff1f534d4ea38a117af7d2faa
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 6e777018b430d974e998e37835f8da69
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEngine.TestTools;
+using NUnit.Framework;
+using System.Collections;
+
+[TestFixture]
+public class DampingTests
+{
+ [Test]
+ public void DampFloat()
+ {
+ const float dampTime = 10f;
+ const float initial = 100f;
+ float[] fixedFactor = new float[3] { 0.79f, 0f, 1.07f };
+ for (int f = 0; f < fixedFactor.Length; ++f)
+ {
+ float t = 0;
+ float r = Cinemachine.Utility.Damper.Damp(initial, dampTime, t);
+ Assert.AreEqual(0, r);
+ Assert.Less(r, initial);
+ const int iterations = 10;
+ for (int i = 0; i < iterations; ++i)
+ {
+ t += dampTime / iterations;
+ float fdt = fixedFactor[f] * t;
+ string msg = "i = " + i + ", t = " + t + ", fdt = " + fdt;
+ if (i != iterations-1)
+ Assert.Less(t, dampTime, msg);
+ else
+ t = dampTime;
+ float r2 = Cinemachine.Utility.Damper.Damp(initial, dampTime, t);
+ Assert.Less(r, r2, msg);
+ r = r2;
+ }
+ //Assert.AreEqual(initial * (1 - MathHelpers.kNegligibleResidual), r, "f = " + f);
+ }
+ }
+}
+
--- /dev/null
+fileFormatVersion: 2
+guid: 5f3c3863a56212143af61f92a3644bb0
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+{
+ "name": "com.unity.cinemachine.EditorTests",
+ "references": [
+ "Cinemachine",
+ "com.unity.cinemachine.editor"
+ ],
+ "optionalUnityReferences": [
+ "TestAssemblies"
+ ],
+ "includePlatforms": [
+ "Editor"
+ ],
+ "excludePlatforms": [],
+ "allowUnsafeCode": false,
+ "overrideReferences": false,
+ "precompiledReferences": [],
+ "autoReferenced": true,
+ "defineConstraints": []
+}
\ No newline at end of file
--- /dev/null
+fileFormatVersion: 2
+guid: d5ada0dcd11a06049936072bb3b3ed73
+AssemblyDefinitionImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+fileFormatVersion: 2
+guid: 8bc4fc3f7edf4174fa4f4877f6aa4e2f
+folderAsset: yes
+DefaultImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+using UnityEngine;
+using UnityEngine.TestTools;
+using NUnit.Framework;
+using System.Collections;
+
+public class RuntimeDampingTest
+{
+ [Test]
+ public void DampFloat()
+ {
+ const float dampTime = 10f;
+ const float initial = 100f;
+ float[] fixedFactor = new float[3] { 0.79f, 0f, 1.07f };
+ for (int f = 0; f < fixedFactor.Length; ++f)
+ {
+ float t = 0;
+ float r = Cinemachine.Utility.Damper.Damp(initial, dampTime, t);
+ Assert.AreEqual(0, r);
+ Assert.Less(r, initial);
+ const int iterations = 10;
+ for (int i = 0; i < iterations; ++i)
+ {
+ t += dampTime / iterations;
+ float fdt = fixedFactor[f] * t;
+ string msg = "i = " + i + ", t = " + t + ", fdt = " + fdt;
+ if (i != iterations-1)
+ Assert.Less(t, dampTime, msg);
+ else
+ t = dampTime;
+ float r2 = Cinemachine.Utility.Damper.Damp(initial, dampTime, t);
+ Assert.Less(r, r2, msg);
+ r = r2;
+ }
+ //Assert.AreEqual(initial * (1 - MathHelpers.kNegligibleResidual), r, "f = " + f);
+ }
+ }
+
+/*
+ // A UnityTest behaves like a coroutine in PlayMode
+ // and allows you to yield null to skip a frame in EditMode
+ [UnityTest]
+ public IEnumerator PlayModeSampleTestWithEnumeratorPasses() {
+ // Use the Assert class to test conditions.
+ // yield to skip a frame
+ yield return null;
+ }
+*/
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 8db8d3ba38ef23344baee4d941ad534f
+MonoImporter:
+ externalObjects: {}
+ serializedVersion: 2
+ defaultReferences: []
+ executionOrder: 0
+ icon: {instanceID: 0}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+{
+ "name": "com.unity.cinemachine.Tests",
+ "references": [
+ "Cinemachine"
+ ],
+ "optionalUnityReferences": [
+ "TestAssemblies"
+ ],
+ "includePlatforms": [],
+ "excludePlatforms": [],
+ "allowUnsafeCode": false,
+ "overrideReferences": false,
+ "precompiledReferences": [],
+ "autoReferenced": true,
+ "defineConstraints": []
+}
\ No newline at end of file
--- /dev/null
+fileFormatVersion: 2
+guid: 8ba1cf4afa640804e94ba034367104ab
+AssemblyDefinitionImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+Unity Companion Cinemachine Code License 1.0 (\93License\94)
+Copyright © 2017 Unity Technologies ApS (\93Unity\94)
+
+Unity hereby grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available with this License (\93Software\94), subject to the following terms and conditions:
+
+1. Unity Companion Use Only. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity development engine software license (\93Engine License\94). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted.
+
+2. No Modification of Engine License. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
+
+3. Ownership & Grant Back to You.
+
+3.1 You own your content. In this License, \93derivative works\94 means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); \93derivative works\94 of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
+
+3.2 Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity.
+
+3.3 You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
+
+4. Trademarks. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates (\93Trademarks\94). Descriptive uses of Trademarks are permitted; see, for example, Unity\92s Branding Usage Guidelines at https://unity3d.com/public-relations/brand.
+
+5. Notices & Third-Party Rights. This License, including the copyright notice above, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity \93third-party notices\94 or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
+
+6. DISCLAIMER, LIMITATION OF LIABILITY. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+7. USE IS ACCEPTANCE and License Versions. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License.
+
+8. Use in Compliance with Law and Termination. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
+
+9. Severability. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
+
+10. Governing Law and Venue. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License (\93Dispute\94). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute.
--- /dev/null
+fileFormatVersion: 2
+guid: a8fb8b30e4d6f6640859c9bcaef4bd88
+TextScriptImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
--- /dev/null
+{
+ "name": "com.unity.cinemachine",
+ "displayName": "Cinemachine",
+ "version": "2.3.4",
+ "unity": "2019.1",
+ "description": "Smart camera tools for passionate creators. \n\nIMPORTANT NOTE: If you are upgrading from the Asset Store version of Cinemachine, delete the Cinemachine asset from your project BEFORE installing this version from the Package Manager.",
+ "keywords": [ "camera", "follow", "rig", "fps", "cinematography", "aim", "orbit", "cutscene", "cinematic", "collision", "freelook", "cinemachine", "compose", "composition", "dolly", "track", "clearshot", "noise", "framing", "handheld", "lens", "impulse" ],
+ "category": "cinematography",
+ "dependencies": {
+ },
+ "repository": {
+ "type": "git",
+ "url": "https://github.com/Unity-Technologies/upm-package-cinemachine",
+ "revision": "679387cb1fa822190b530bdbb8ea0945f508b5f6"
+ }
+}
--- /dev/null
+fileFormatVersion: 2
+guid: 7d93e7b7399fbe64790358e67fc94b18
+TextScriptImporter:
+ externalObjects: {}
+ userData:
+ assetBundleName:
+ assetBundleVariant:
targetDevice: 2
useOnDemandResources: 0
accelerometerFrequency: 60
- companyName: DefaultCompany
+ companyName: Randoms For A Cause Studio
productName: mindgames
defaultCursor: {fileID: 0}
cursorHotspot: {x: 0, y: 0}
m_ShowUnitySplashLogo: 1
m_SplashScreenOverlayOpacity: 1
m_SplashScreenAnimation: 1
- m_SplashScreenLogoStyle: 1
- m_SplashScreenDrawMode: 0
+ m_SplashScreenLogoStyle: 0
+ m_SplashScreenDrawMode: 1
m_SplashScreenBackgroundAnimationZoom: 1
m_SplashScreenLogoAnimationZoom: 1
m_SplashScreenBackgroundLandscapeAspect: 1
y: 0
width: 1
height: 1
- m_SplashScreenLogos: []
+ m_SplashScreenLogos:
+ - logo: {fileID: 10404, guid: 0000000000000000e000000000000000, type: 0}
+ duration: 2
+ - logo: {fileID: 0}
+ duration: 2
m_VirtualRealitySplashScreen: {fileID: 0}
m_HolographicTrackingLossScreen: {fileID: 0}
defaultScreenWidth: 1024
16:10: 1
16:9: 1
Others: 1
- bundleVersion: 0.1
+ bundleVersion: 0.0.1F
preloadedAssets: []
metroInputSource: 0
wsaTransparentSwapchain: 0
Base path: 'C:/Program Files/Unity/Hub/Editor/2019.2.15f1/Editor/Data', plugins path 'C:/Program Files/Unity/Hub/Editor/2019.2.15f1/Editor/Data/PlaybackEngines'
Cmd: initializeCompiler
+Cmd: initializeCompiler
+Cmd: preprocessCompute
+ insize=1953 outsize=1957 ok=1
+Cmd: compileComputeKernel
+ api=4 insize=1957 outsize=559 ok=1
Cmd: preprocess
- insize=7631 outsize=2417 ok=1
-Cmd: compileSnippet
- error: 2 plat 4 at (93): failed to open source file: 'TMPro_Properties.cginc'\nCompiling Vertex program
-Platform defines: UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR
- api=4 type=0 insize=5657 outsize=0 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=0
-Cmd: compileSnippet
- error: 2 plat 4 at (93): failed to open source file: 'TMPro_Properties.cginc'\nCompiling Vertex program
-Platform defines: UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR
- api=4 type=0 insize=5657 outsize=0 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=0
-Cmd: compileSnippet
- error: 2 plat 4 at (93): failed to open source file: 'TMPro_Properties.cginc'\nCompiling Fragment program
-Platform defines: UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR
- api=4 type=1 insize=5657 outsize=0 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=0
-Cmd: preprocess
- insize=1141 outsize=385 ok=1
-Cmd: compileSnippet
- api=4 type=0 insize=1194 outsize=538 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: compileSnippet
- api=4 type=1 insize=1194 outsize=190 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: preprocess
- insize=1743 outsize=450 ok=1
-Cmd: compileSnippet
- api=4 type=0 insize=1731 outsize=1166 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: compileSnippet
- api=4 type=1 insize=1731 outsize=838 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: preprocess
- insize=511 outsize=508 ok=1
-Cmd: compileSnippet
- api=4 type=0 insize=1593 outsize=790 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: compileSnippet
- api=4 type=1 insize=1593 outsize=402 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: preprocess
- insize=1353 outsize=484 ok=1
-Cmd: compileSnippet
- api=4 type=0 insize=1310 outsize=718 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: compileSnippet
- api=4 type=1 insize=1310 outsize=662 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: preprocess
- insize=1209 outsize=503 ok=1
-Cmd: compileSnippet
- api=4 type=0 insize=1147 outsize=650 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: compileSnippet
- api=4 type=1 insize=1147 outsize=562 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: preprocess
- insize=1561 outsize=592 ok=1
-Cmd: compileSnippet
- api=4 type=0 insize=1410 outsize=734 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: compileSnippet
- api=4 type=1 insize=1410 outsize=750 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: preprocess
- insize=1213 outsize=457 ok=1
-Cmd: compileSnippet
- api=4 type=0 insize=1194 outsize=538 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
-Cmd: compileSnippet
- api=4 type=1 insize=1194 outsize=190 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
+ insize=1495 outsize=207 ok=1
Cmd: compileSnippet
- api=4 type=0 insize=1475 outsize=538 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
+ api=4 type=0 insize=1619 outsize=538 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
Cmd: compileSnippet
- api=4 type=1 insize=1475 outsize=246 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
+ api=4 type=1 insize=1619 outsize=1010 kw= pd=UNITY_ENABLE_REFLECTION_BUFFERS UNITY_USE_DITHER_MASK_FOR_ALPHABLENDED_SHADOWS UNITY_PBS_USE_BRDF1 UNITY_SPECCUBE_BOX_PROJECTION UNITY_SPECCUBE_BLENDING UNITY_ENABLE_DETAIL_NORMALMAP SHADER_API_DESKTOP UNITY_COLORSPACE_GAMMA UNITY_LIGHT_PROBE_PROXY_VOLUME UNITY_LIGHTMAP_FULL_HDR ok=1
Base path: 'C:/Program Files/Unity/Hub/Editor/2019.2.15f1/Editor/Data', plugins path 'C:/Program Files/Unity/Hub/Editor/2019.2.15f1/Editor/Data/PlaybackEngines'
Cmd: initializeCompiler
Cmd: compileComputeKernel
- api=4 insize=2186 outsize=754 ok=1
-Cmd: compileComputeKernel
- api=4 insize=10441 outsize=5235 ok=1
+ api=4 insize=1957 outsize=1383 ok=1
{
"dependencies": {
+ "com.unity.cinemachine": "2.3.4",
"com.unity.collab-proxy": "1.2.16",
"com.unity.ext.nunit": "1.0.0",
"com.unity.ide.rider": "1.1.0",
targetDevice: 2
useOnDemandResources: 0
accelerometerFrequency: 60
- companyName: DefaultCompany
+ companyName: Randoms For A Cause Studio
productName: mindgames
defaultCursor: {fileID: 0}
cursorHotspot: {x: 0, y: 0}
m_ShowUnitySplashLogo: 1
m_SplashScreenOverlayOpacity: 1
m_SplashScreenAnimation: 1
- m_SplashScreenLogoStyle: 1
- m_SplashScreenDrawMode: 0
+ m_SplashScreenLogoStyle: 0
+ m_SplashScreenDrawMode: 1
m_SplashScreenBackgroundAnimationZoom: 1
m_SplashScreenLogoAnimationZoom: 1
m_SplashScreenBackgroundLandscapeAspect: 1
y: 0
width: 1
height: 1
- m_SplashScreenLogos: []
+ m_SplashScreenLogos:
+ - logo: {fileID: 10404, guid: 0000000000000000e000000000000000, type: 0}
+ duration: 2
+ - logo: {fileID: 0}
+ duration: 2
m_VirtualRealitySplashScreen: {fileID: 0}
m_HolographicTrackingLossScreen: {fileID: 0}
defaultScreenWidth: 1024
16:10: 1
16:9: 1
Others: 1
- bundleVersion: 0.1
+ bundleVersion: 0.0.1F
preloadedAssets: []
metroInputSource: 0
wsaTransparentSwapchain: 0
OSDN Git Service
