nothke/quality-control
1
0
Fork 0
mirror of https://github.com/nothke/quality-control.git synced 2024-11-14 14:43:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: nothke:a0159596cb8e33d3f7dc274aa9e45d0ade3d4591
Branches Tags
nothke:master
nothke:psx
..
compare: nothke:4ed5f3b190fbcc3cae63bfcfd78ed8ca192f02ed
Branches Tags
nothke:psx
nothke:master

No commits in common. "a0159596cb8e33d3f7dc274aa9e45d0ade3d4591" and "4ed5f3b190fbcc3cae63bfcfd78ed8ca192f02ed" have entirely different histories.
a0159596cb ... 4ed5f3b190

55 changed files with 6 additions and 5874 deletions
Show Stats Expand all files Collapse all files

8
Assets/Materials.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: dbdf4c4a357cc334796477d031b9d789
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Meshes.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 764cc9da84bd8224799ae7e38d40f05b
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: f5f3393f99206534a9f7c642a8fba028
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/KinematicCharacterController.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 80ae4a9ddbd64d846a0b7de1a75c9f83
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

9
Assets/Plugins/KinematicCharacterController/Core.meta
View File

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: c8854cb84deea8146b0cc7833ff338fd
folderAsset: yes
timeCreated: 1499134826
licenseType: Store
DefaultImporter:
userData:
assetBundleName:
assetBundleVariant:

10
Assets/Plugins/KinematicCharacterController/Core/Editor.meta
View File

@ -1,10 +0,0 @@
fileFormatVersion: 2
guid: 220667f043f505a4eb52d0208e14818e
folderAsset: yes
timeCreated: 1504492780
licenseType: Store
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

17
Assets/Plugins/KinematicCharacterController/Core/Editor/KCC.Editor.asmdef
View File

@ -1,17 +0,0 @@
{
"name": "KCC.Editor",
"references": [
"GUID:1bf68a6e05395544c9eb0c8d1ab94588"
],
"includePlatforms": [
"Editor"
],
"excludePlatforms": [],
"allowUnsafeCode": false,
"overrideReferences": false,
"precompiledReferences": [],
"autoReferenced": true,
"defineConstraints": [],
"versionDefines": [],
"noEngineReferences": false
}

7
Assets/Plugins/KinematicCharacterController/Core/Editor/KCC.Editor.asmdef.meta
View File

@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 8b7c931d99dfb09428a98748ecfd6169
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

28
Assets/Plugins/KinematicCharacterController/Core/Editor/KinematicCharacterMotorEditor.cs
View File

@ -1,28 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
namespace KinematicCharacterController
{
[CustomEditor(typeof(KinematicCharacterMotor))]
public class KinematicCharacterMotorEditor : Editor
{
protected virtual void OnSceneGUI()
{
KinematicCharacterMotor motor = (target as KinematicCharacterMotor);
if (motor)
{
Vector3 characterBottom = motor.transform.position + (motor.Capsule.center + (-Vector3.up * (motor.Capsule.height * 0.5f)));
Handles.color = Color.yellow;
Handles.CircleHandleCap(
0,
characterBottom + (motor.transform.up * motor.MaxStepHeight),
Quaternion.LookRotation(motor.transform.up, motor.transform.forward),
motor.Capsule.radius + 0.1f,
EventType.Repaint);
}
}
}
}

13
Assets/Plugins/KinematicCharacterController/Core/Editor/KinematicCharacterMotorEditor.cs.meta
View File

@ -1,13 +0,0 @@
fileFormatVersion: 2
guid: 7db3ed6d74cbf2b489cab5e1586bed7a
timeCreated: 1518400757
licenseType: Store
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

21
Assets/Plugins/KinematicCharacterController/Core/Editor/ReadOnlyPropertyDrawer.cs
View File

@ -1,21 +0,0 @@
using UnityEngine;
using UnityEditor;
namespace KinematicCharacterController
{
[CustomPropertyDrawer(typeof(ReadOnlyAttribute))]
public class ReadOnlyPropertyDrawer : PropertyDrawer
{
public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
{
return EditorGUI.GetPropertyHeight(property, label, true);
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
GUI.enabled = false;
EditorGUI.PropertyField(position, property, label, true);
GUI.enabled = true;
}
}
}

13
Assets/Plugins/KinematicCharacterController/Core/Editor/ReadOnlyPropertyDrawer.cs.meta
View File

@ -1,13 +0,0 @@
fileFormatVersion: 2
guid: 0d4351ab88853824b85a8f458928d825
timeCreated: 1504492796
licenseType: Store
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

50
Assets/Plugins/KinematicCharacterController/Core/ICharacterController.cs
View File

@ -1,50 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace KinematicCharacterController
{
public interface ICharacterController
{
/// <summary>
/// This is called when the motor wants to know what its rotation should be right now
/// </summary>
void UpdateRotation(ref Quaternion currentRotation, float deltaTime);
/// <summary>
/// This is called when the motor wants to know what its velocity should be right now
/// </summary>
void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime);
/// <summary>
/// This is called before the motor does anything
/// </summary>
void BeforeCharacterUpdate(float deltaTime);
/// <summary>
/// This is called after the motor has finished its ground probing, but before PhysicsMover/Velocity/etc.... handling
/// </summary>
void PostGroundingUpdate(float deltaTime);
/// <summary>
/// This is called after the motor has finished everything in its update
/// </summary>
void AfterCharacterUpdate(float deltaTime);
/// <summary>
/// This is called after when the motor wants to know if the collider can be collided with (or if we just go through it)
/// </summary>
bool IsColliderValidForCollisions(Collider coll);
/// <summary>
/// This is called when the motor's ground probing detects a ground hit
/// </summary>
void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport);
/// <summary>
/// This is called when the motor's movement logic detects a hit
/// </summary>
void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport);
/// <summary>
/// This is called after every move hit, to give you an opportunity to modify the HitStabilityReport to your liking
/// </summary>
void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, Vector3 atCharacterPosition, Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport);
/// <summary>
/// This is called when the character detects discrete collisions (collisions that don't result from the motor's capsuleCasts when moving)
/// </summary>
void OnDiscreteCollisionDetected(Collider hitCollider);
}
}

11
Assets/Plugins/KinematicCharacterController/Core/ICharacterController.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: f13aa252bd3bf9943b1d65e68d93dcfb
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

14
Assets/Plugins/KinematicCharacterController/Core/IMoverController.cs
View File

@ -1,14 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace KinematicCharacterController
{
public interface IMoverController
{
/// <summary>
/// This is called to let you tell the PhysicsMover where it should be right now
/// </summary>
void UpdateMovement(out Vector3 goalPosition, out Quaternion goalRotation, float deltaTime);
}
}

11
Assets/Plugins/KinematicCharacterController/Core/IMoverController.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 8ae7eceec45f1be4c8450edc46c0ad36
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

3
Assets/Plugins/KinematicCharacterController/Core/KCC.asmdef
View File

@ -1,3 +0,0 @@
{
"name": "KCC"
}

7
Assets/Plugins/KinematicCharacterController/Core/KCC.asmdef.meta
View File

@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 1bf68a6e05395544c9eb0c8d1ab94588
AssemblyDefinitionImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

33
Assets/Plugins/KinematicCharacterController/Core/KCCSettings.cs
View File

@ -1,33 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace KinematicCharacterController
{
[CreateAssetMenu]
public class KCCSettings : ScriptableObject
{
/// <summary>
/// Determines if the system simulates automatically.
/// If true, the simulation is done on FixedUpdate
/// </summary>
[Tooltip("Determines if the system simulates automatically. If true, the simulation is done on FixedUpdate")]
public bool AutoSimulation = true;
/// <summary>
/// Should interpolation of characters and PhysicsMovers be handled
/// </summary>
[Tooltip("Should interpolation of characters and PhysicsMovers be handled")]
public bool Interpolate = true;
/// <summary>
/// Initial capacity of the system's list of Motors (will resize automatically if needed, but setting a high initial capacity can help preventing GC allocs)
/// </summary>
[Tooltip("Initial capacity of the system's list of Motors (will resize automatically if needed, but setting a high initial capacity can help preventing GC allocs)")]
public int MotorsListInitialCapacity = 100;
/// <summary>
/// Initial capacity of the system's list of Movers (will resize automatically if needed, but setting a high initial capacity can help preventing GC allocs)
/// </summary>
[Tooltip("Initial capacity of the system's list of Movers (will resize automatically if needed, but setting a high initial capacity can help preventing GC allocs)")]
public int MoversListInitialCapacity = 100;
}
}

11
Assets/Plugins/KinematicCharacterController/Core/KCCSettings.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 2b43d8459fe4812488b2c47ac60e41c3
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

2689
Assets/Plugins/KinematicCharacterController/Core/KinematicCharacterMotor.cs
View File

File diff suppressed because it is too large Load Diff

11
Assets/Plugins/KinematicCharacterController/Core/KinematicCharacterMotor.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: 4d1bc5515e3ab954e80599c538834774
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

294
Assets/Plugins/KinematicCharacterController/Core/KinematicCharacterSystem.cs
View File

@ -1,294 +0,0 @@
using System;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using UnityEngine;
namespace KinematicCharacterController
{
/// <summary>
/// The system that manages the simulation of KinematicCharacterMotor and PhysicsMover
/// </summary>
[DefaultExecutionOrder(-100)]
public class KinematicCharacterSystem : MonoBehaviour
{
private static KinematicCharacterSystem _instance;
public static List<KinematicCharacterMotor> CharacterMotors = new List<KinematicCharacterMotor>();
public static List<PhysicsMover> PhysicsMovers = new List<PhysicsMover>();
private static float _lastCustomInterpolationStartTime = -1f;
private static float _lastCustomInterpolationDeltaTime = -1f;
public static KCCSettings Settings;
/// <summary>
/// Creates a KinematicCharacterSystem instance if there isn't already one
/// </summary>
public static void EnsureCreation()
{
if (_instance == null)
{
GameObject systemGameObject = new GameObject("KinematicCharacterSystem");
_instance = systemGameObject.AddComponent<KinematicCharacterSystem>();
systemGameObject.hideFlags = HideFlags.NotEditable;
_instance.hideFlags = HideFlags.NotEditable;
Settings = ScriptableObject.CreateInstance<KCCSettings>();
GameObject.DontDestroyOnLoad(systemGameObject);
}
}
/// <summary>
/// Gets the KinematicCharacterSystem instance if any
/// </summary>
/// <returns></returns>
public static KinematicCharacterSystem GetInstance()
{
return _instance;
}
/// <summary>
/// Sets the maximum capacity of the character motors list, to prevent allocations when adding characters
/// </summary>
/// <param name="capacity"></param>
public static void SetCharacterMotorsCapacity(int capacity)
{
if (capacity < CharacterMotors.Count)
{
capacity = CharacterMotors.Count;
}
CharacterMotors.Capacity = capacity;
}
/// <summary>
/// Registers a KinematicCharacterMotor into the system
/// </summary>
public static void RegisterCharacterMotor(KinematicCharacterMotor motor)
{
CharacterMotors.Add(motor);
}
/// <summary>
/// Unregisters a KinematicCharacterMotor from the system
/// </summary>
public static void UnregisterCharacterMotor(KinematicCharacterMotor motor)
{
CharacterMotors.Remove(motor);
}
/// <summary>
/// Sets the maximum capacity of the physics movers list, to prevent allocations when adding movers
/// </summary>
/// <param name="capacity"></param>
public static void SetPhysicsMoversCapacity(int capacity)
{
if (capacity < PhysicsMovers.Count)
{
capacity = PhysicsMovers.Count;
}
PhysicsMovers.Capacity = capacity;
}
/// <summary>
/// Registers a PhysicsMover into the system
/// </summary>
public static void RegisterPhysicsMover(PhysicsMover mover)
{
PhysicsMovers.Add(mover);
mover.Rigidbody.interpolation = RigidbodyInterpolation.None;
}
/// <summary>
/// Unregisters a PhysicsMover from the system
/// </summary>
public static void UnregisterPhysicsMover(PhysicsMover mover)
{
PhysicsMovers.Remove(mover);
}
// This is to prevent duplicating the singleton gameobject on script recompiles
private void OnDisable()
{
Destroy(this.gameObject);
}
private void Awake()
{
_instance = this;
}
private void FixedUpdate()
{
if (Settings.AutoSimulation)
{
float deltaTime = Time.deltaTime;
if (Settings.Interpolate)
{
PreSimulationInterpolationUpdate(deltaTime);
}
Simulate(deltaTime, CharacterMotors, PhysicsMovers);
if (Settings.Interpolate)
{
PostSimulationInterpolationUpdate(deltaTime);
}
}
}
private void LateUpdate()
{
if (Settings.Interpolate)
{
CustomInterpolationUpdate();
}
}
/// <summary>
/// Remembers the point to interpolate from for KinematicCharacterMotors and PhysicsMovers
/// </summary>
public static void PreSimulationInterpolationUpdate(float deltaTime)
{
// Save pre-simulation poses and place transform at transient pose
for (int i = 0; i < CharacterMotors.Count; i++)
{
KinematicCharacterMotor motor = CharacterMotors[i];
motor.InitialTickPosition = motor.TransientPosition;
motor.InitialTickRotation = motor.TransientRotation;
motor.Transform.SetPositionAndRotation(motor.TransientPosition, motor.TransientRotation);
}
for (int i = 0; i < PhysicsMovers.Count; i++)
{
PhysicsMover mover = PhysicsMovers[i];
mover.InitialTickPosition = mover.TransientPosition;
mover.InitialTickRotation = mover.TransientRotation;
mover.Transform.SetPositionAndRotation(mover.TransientPosition, mover.TransientRotation);
mover.Rigidbody.position = mover.TransientPosition;
mover.Rigidbody.rotation = mover.TransientRotation;
}
}
/// <summary>
/// Ticks characters and/or movers
/// </summary>
public static void Simulate(float deltaTime, List<KinematicCharacterMotor> motors, List<PhysicsMover> movers)
{
int characterMotorsCount = motors.Count;
int physicsMoversCount = movers.Count;
#pragma warning disable 0162
// Update PhysicsMover velocities
for (int i = 0; i < physicsMoversCount; i++)
{
movers[i].VelocityUpdate(deltaTime);
}
// Character controller update phase 1
for (int i = 0; i < characterMotorsCount; i++)
{
motors[i].UpdatePhase1(deltaTime);
}
// Simulate PhysicsMover displacement
for (int i = 0; i < physicsMoversCount; i++)
{
PhysicsMover mover = movers[i];
mover.Transform.SetPositionAndRotation(mover.TransientPosition, mover.TransientRotation);
mover.Rigidbody.position = mover.TransientPosition;
mover.Rigidbody.rotation = mover.TransientRotation;
}
// Character controller update phase 2 and move
for (int i = 0; i < characterMotorsCount; i++)
{
KinematicCharacterMotor motor = motors[i];
motor.UpdatePhase2(deltaTime);
motor.Transform.SetPositionAndRotation(motor.TransientPosition, motor.TransientRotation);
}
#pragma warning restore 0162
}
/// <summary>
/// Initiates the interpolation for KinematicCharacterMotors and PhysicsMovers
/// </summary>
public static void PostSimulationInterpolationUpdate(float deltaTime)
{
_lastCustomInterpolationStartTime = Time.time;
_lastCustomInterpolationDeltaTime = deltaTime;
// Return interpolated roots to their initial poses
for (int i = 0; i < CharacterMotors.Count; i++)
{
KinematicCharacterMotor motor = CharacterMotors[i];
motor.Transform.SetPositionAndRotation(motor.InitialTickPosition, motor.InitialTickRotation);
}
for (int i = 0; i < PhysicsMovers.Count; i++)
{
PhysicsMover mover = PhysicsMovers[i];
if (mover.MoveWithPhysics)
{
mover.Rigidbody.position = mover.InitialTickPosition;
mover.Rigidbody.rotation = mover.InitialTickRotation;
mover.Rigidbody.MovePosition(mover.TransientPosition);
mover.Rigidbody.MoveRotation(mover.TransientRotation);
}
else
{
mover.Rigidbody.position = (mover.TransientPosition);
mover.Rigidbody.rotation = (mover.TransientRotation);
}
}
}
/// <summary>
/// Handles per-frame interpolation
/// </summary>
private static void CustomInterpolationUpdate()
{
float interpolationFactor = Mathf.Clamp01((Time.time - _lastCustomInterpolationStartTime) / _lastCustomInterpolationDeltaTime);
// Handle characters interpolation
for (int i = 0; i < CharacterMotors.Count; i++)
{
KinematicCharacterMotor motor = CharacterMotors[i];
motor.Transform.SetPositionAndRotation(
Vector3.Lerp(motor.InitialTickPosition, motor.TransientPosition, interpolationFactor),
Quaternion.Slerp(motor.InitialTickRotation, motor.TransientRotation, interpolationFactor));
}
// Handle PhysicsMovers interpolation
for (int i = 0; i < PhysicsMovers.Count; i++)
{
PhysicsMover mover = PhysicsMovers[i];
mover.Transform.SetPositionAndRotation(
Vector3.Lerp(mover.InitialTickPosition, mover.TransientPosition, interpolationFactor),
Quaternion.Slerp(mover.InitialTickRotation, mover.TransientRotation, interpolationFactor));
Vector3 newPos = mover.Transform.position;
Quaternion newRot = mover.Transform.rotation;
mover.PositionDeltaFromInterpolation = newPos - mover.LatestInterpolationPosition;
mover.RotationDeltaFromInterpolation = Quaternion.Inverse(mover.LatestInterpolationRotation) * newRot;
mover.LatestInterpolationPosition = newPos;
mover.LatestInterpolationRotation = newRot;
}
}
}
}

12
Assets/Plugins/KinematicCharacterController/Core/KinematicCharacterSystem.cs.meta
View File

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: dbd80c9a62d41084aad50ae44255beb9
timeCreated: 1500241576
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

261
Assets/Plugins/KinematicCharacterController/Core/PhysicsMover.cs
View File

@ -1,261 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace KinematicCharacterController
{
/// <summary>
/// Represents the entire state of a PhysicsMover that is pertinent for simulation.
/// Use this to save state or revert to past state
/// </summary>
[System.Serializable]
public struct PhysicsMoverState
{
public Vector3 Position;
public Quaternion Rotation;
public Vector3 Velocity;
public Vector3 AngularVelocity;
}
/// <summary>
/// Component that manages the movement of moving kinematic rigidbodies for
/// proper interaction with characters
/// </summary>
[RequireComponent(typeof(Rigidbody))]
public class PhysicsMover : MonoBehaviour
{
/// <summary>
/// The mover's Rigidbody
/// </summary>
[ReadOnly]
public Rigidbody Rigidbody;
/// <summary>
/// Determines if the platform moves with rigidbody.MovePosition (when true), or with rigidbody.position (when false)
/// </summary>
public bool MoveWithPhysics = true;
/// <summary>
/// Index of this motor in KinematicCharacterSystem arrays
/// </summary>
[NonSerialized]
public IMoverController MoverController;
/// <summary>
/// Remembers latest position in interpolation
/// </summary>
[NonSerialized]
public Vector3 LatestInterpolationPosition;
/// <summary>
/// Remembers latest rotation in interpolation
/// </summary>
[NonSerialized]
public Quaternion LatestInterpolationRotation;
/// <summary>
/// The latest movement made by interpolation
/// </summary>
[NonSerialized]
public Vector3 PositionDeltaFromInterpolation;
/// <summary>
/// The latest rotation made by interpolation
/// </summary>
[NonSerialized]
public Quaternion RotationDeltaFromInterpolation;
/// <summary>
/// Index of this motor in KinematicCharacterSystem arrays
/// </summary>
public int IndexInCharacterSystem { get; set; }
/// <summary>
/// Remembers initial position before all simulation are done
/// </summary>
public Vector3 Velocity { get; protected set; }
/// <summary>
/// Remembers initial position before all simulation are done
/// </summary>
public Vector3 AngularVelocity { get; protected set; }
/// <summary>
/// Remembers initial position before all simulation are done
/// </summary>
public Vector3 InitialTickPosition { get; set; }
/// <summary>
/// Remembers initial rotation before all simulation are done
/// </summary>
public Quaternion InitialTickRotation { get; set; }
/// <summary>
/// The mover's Transform
/// </summary>
public Transform Transform { get; private set; }
/// <summary>
/// The character's position before the movement calculations began
/// </summary>
public Vector3 InitialSimulationPosition { get; private set; }
/// <summary>
/// The character's rotation before the movement calculations began
/// </summary>
public Quaternion InitialSimulationRotation { get; private set; }
private Vector3 _internalTransientPosition;
/// <summary>
/// The mover's rotation (always up-to-date during the character update phase)
/// </summary>
public Vector3 TransientPosition
{
get
{
return _internalTransientPosition;
}
private set
{
_internalTransientPosition = value;
}
}
private Quaternion _internalTransientRotation;
/// <summary>
/// The mover's rotation (always up-to-date during the character update phase)
/// </summary>
public Quaternion TransientRotation
{
get
{
return _internalTransientRotation;
}
private set
{
_internalTransientRotation = value;
}
}
private void Reset()
{
ValidateData();
}
private void OnValidate()
{
ValidateData();
}
/// <summary>
/// Handle validating all required values
/// </summary>
public void ValidateData()
{
Rigidbody = gameObject.GetComponent<Rigidbody>();
Rigidbody.centerOfMass = Vector3.zero;
Rigidbody.maxAngularVelocity = Mathf.Infinity;
Rigidbody.maxDepenetrationVelocity = Mathf.Infinity;
Rigidbody.isKinematic = true;
Rigidbody.interpolation = RigidbodyInterpolation.None;
}
private void OnEnable()
{
KinematicCharacterSystem.EnsureCreation();
KinematicCharacterSystem.RegisterPhysicsMover(this);
}
private void OnDisable()
{
KinematicCharacterSystem.UnregisterPhysicsMover(this);
}
private void Awake()
{
Transform = this.transform;
ValidateData();
TransientPosition = Rigidbody.position;
TransientRotation = Rigidbody.rotation;
InitialSimulationPosition = Rigidbody.position;
InitialSimulationRotation = Rigidbody.rotation;
LatestInterpolationPosition = Transform.position;
LatestInterpolationRotation = Transform.rotation;
}
/// <summary>
/// Sets the mover's position directly
/// </summary>
public void SetPosition(Vector3 position)
{
Transform.position = position;
Rigidbody.position = position;
InitialSimulationPosition = position;
TransientPosition = position;
}
/// <summary>
/// Sets the mover's rotation directly
/// </summary>
public void SetRotation(Quaternion rotation)
{
Transform.rotation = rotation;
Rigidbody.rotation = rotation;
InitialSimulationRotation = rotation;
TransientRotation = rotation;
}
/// <summary>
/// Sets the mover's position and rotation directly
/// </summary>
public void SetPositionAndRotation(Vector3 position, Quaternion rotation)
{
Transform.SetPositionAndRotation(position, rotation);
Rigidbody.position = position;
Rigidbody.rotation = rotation;
InitialSimulationPosition = position;
InitialSimulationRotation = rotation;
TransientPosition = position;
TransientRotation = rotation;
}
/// <summary>
/// Returns all the state information of the mover that is pertinent for simulation
/// </summary>
public PhysicsMoverState GetState()
{
PhysicsMoverState state = new PhysicsMoverState();
state.Position = TransientPosition;
state.Rotation = TransientRotation;
state.Velocity = Velocity;
state.AngularVelocity = AngularVelocity;
return state;
}
/// <summary>
/// Applies a mover state instantly
/// </summary>
public void ApplyState(PhysicsMoverState state)
{
SetPositionAndRotation(state.Position, state.Rotation);
Velocity = state.Velocity;
AngularVelocity = state.AngularVelocity;
}
/// <summary>
/// Caches velocity values based on deltatime and target position/rotations
/// </summary>
public void VelocityUpdate(float deltaTime)
{
InitialSimulationPosition = TransientPosition;
InitialSimulationRotation = TransientRotation;
MoverController.UpdateMovement(out _internalTransientPosition, out _internalTransientRotation, deltaTime);
if (deltaTime > 0f)
{
Velocity = (TransientPosition - InitialSimulationPosition) / deltaTime;
Quaternion rotationFromCurrentToGoal = TransientRotation * (Quaternion.Inverse(InitialSimulationRotation));
AngularVelocity = (Mathf.Deg2Rad * rotationFromCurrentToGoal.eulerAngles) / deltaTime;
}
}
}
}

12
Assets/Plugins/KinematicCharacterController/Core/PhysicsMover.cs.meta
View File

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 075ccbe9837b0744985e09ba3f015b9b
timeCreated: 1488089271
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/KinematicCharacterController/Core/ReadOnlyAttribute.cs
View File

@ -1,8 +0,0 @@
using UnityEngine;
namespace KinematicCharacterController
{
public class ReadOnlyAttribute : PropertyAttribute
{
}
}

13
Assets/Plugins/KinematicCharacterController/Core/ReadOnlyAttribute.cs.meta
View File

@ -1,13 +0,0 @@
fileFormatVersion: 2
guid: 63e8828991cf67f42bfeb498686aad0b
timeCreated: 1504493014
licenseType: Store
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/KinematicCharacterController/ExampleCharacter.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: b8da84cc169c79b4894eefab60565279
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Materials.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: f1cc217451b989d4db08290832cb9dc0
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

76
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Materials/White.mat
View File

@ -1,76 +0,0 @@
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!21 &2100000
Material:
serializedVersion: 6
m_ObjectHideFlags: 0
m_PrefabParentObject: {fileID: 0}
m_PrefabInternal: {fileID: 0}
m_Name: White
m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
m_ShaderKeywords:
m_LightmapFlags: 4
m_EnableInstancingVariants: 0
m_DoubleSidedGI: 0
m_CustomRenderQueue: -1
stringTagMap: {}
disabledShaderPasses: []
m_SavedProperties:
serializedVersion: 3
m_TexEnvs:
- _BumpMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailAlbedoMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailMask:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _DetailNormalMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _EmissionMap:
m_Texture: {fileID: 0}
m_Scale: {x: 4, y: 4}
m_Offset: {x: 0, y: 0}
- _MainTex:
m_Texture: {fileID: 0}
m_Scale: {x: 4, y: 4}
m_Offset: {x: 0, y: 0}
- _MetallicGlossMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _OcclusionMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
- _ParallaxMap:
m_Texture: {fileID: 0}
m_Scale: {x: 1, y: 1}
m_Offset: {x: 0, y: 0}
m_Floats:
- _BumpScale: 0.5
- _Cutoff: 0.5
- _DetailNormalMapScale: 1
- _DstBlend: 0
- _GlossMapScale: 1
- _Glossiness: 0.661
- _GlossyReflections: 1
- _Metallic: 0
- _Mode: 0
- _OcclusionStrength: 1
- _Parallax: 0.02
- _SmoothnessTextureChannel: 0
- _SpecularHighlights: 1
- _SrcBlend: 1
- _UVSec: 0
- _ZWrite: 1
m_Colors:
- _Color: {r: 1, g: 1, b: 1, a: 1}
- _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

9
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Materials/White.mat.meta
View File

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: cf774b4c734b1d04e9fbf6d71e964591
timeCreated: 1493180259
licenseType: Store
NativeFormatImporter:
mainObjectFileID: 2100000
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Prefabs.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 974715e4a94547d4189e0801712b2685
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

127
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCamera.prefab
View File

@ -1,127 +0,0 @@
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!1 &1937979026721672
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 4353896453404184}
- component: {fileID: 20127477809793788}
- component: {fileID: 124551908420297706}
- component: {fileID: 81410469953920030}
- component: {fileID: 114014416615829144}
m_Layer: 0
m_Name: ExampleCamera
m_TagString: MainCamera
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &4353896453404184
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1937979026721672}
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: -5}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children: []
m_Father: {fileID: 0}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!20 &20127477809793788
Camera:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1937979026721672}
m_Enabled: 1
serializedVersion: 2
m_ClearFlags: 1
m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
m_projectionMatrixMode: 1
m_SensorSize: {x: 36, y: 24}
m_LensShift: {x: 0, y: 0}
m_GateFitMode: 2
m_FocalLength: 50
m_NormalizedViewPortRect:
serializedVersion: 2
x: 0
y: 0
width: 1
height: 1
near clip plane: 0.3
far clip plane: 1000
field of view: 75
orthographic: 0
orthographic size: 5
m_Depth: -1
m_CullingMask:
serializedVersion: 2
m_Bits: 4294967295
m_RenderingPath: -1
m_TargetTexture: {fileID: 0}
m_TargetDisplay: 0
m_TargetEye: 3
m_HDR: 1
m_AllowMSAA: 1
m_AllowDynamicResolution: 0
m_ForceIntoRT: 0
m_OcclusionCulling: 1
m_StereoConvergence: 10
m_StereoSeparation: 0.022
--- !u!124 &124551908420297706
Behaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1937979026721672}
m_Enabled: 1
--- !u!81 &81410469953920030
AudioListener:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1937979026721672}
m_Enabled: 1
--- !u!114 &114014416615829144
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1937979026721672}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 24092a40b02616e479baeb940325e339, type: 3}
m_Name:
m_EditorClassIdentifier:
Camera: {fileID: 20127477809793788}
FollowPointFraming: {x: 0, y: 0}
FollowingSharpness: 10000
DefaultDistance: 6
MinDistance: 0
MaxDistance: 10
DistanceMovementSpeed: 5
DistanceMovementSharpness: 10
InvertX: 0
InvertY: 0
DefaultVerticalAngle: 20
MinVerticalAngle: -90
MaxVerticalAngle: 90
RotationSpeed: 1.3
RotationSharpness: 10000
ObstructionCheckRadius: 0.2
ObstructionLayers:
serializedVersion: 2
m_Bits: 4294965759
ObstructionSharpness: 10000
IgnoredColliders: []

9
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCamera.prefab.meta
View File

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: c75e91cf060bbf04e89204fa400606df
timeCreated: 1499181144
licenseType: Store
NativeFormatImporter:
mainObjectFileID: 100100000
userData:
assetBundleName:
assetBundleVariant:

394
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCharacter.prefab
View File

@ -1,394 +0,0 @@
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!1 &43330285
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 43330286}
m_Layer: 0
m_Name: Root
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &43330286
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 43330285}
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children:
- {fileID: 4036232530805280}
- {fileID: 4718917724592500}
m_Father: {fileID: 4898694727102280}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1072008595159340
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 4036232530805280}
m_Layer: 0
m_Name: Meshes
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &4036232530805280
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1072008595159340}
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children:
- {fileID: 4903610365175460}
m_Father: {fileID: 43330286}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1 &1339159333115884
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 4903610365175460}
- component: {fileID: 33711778101729860}
- component: {fileID: 23310449951372792}
m_Layer: 0
m_Name: Capsule
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &4903610365175460
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1339159333115884}
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 1, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children:
- {fileID: 4485742127011420}
m_Father: {fileID: 4036232530805280}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!33 &33711778101729860
MeshFilter:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1339159333115884}
m_Mesh: {fileID: 10208, guid: 0000000000000000e000000000000000, type: 0}
--- !u!23 &23310449951372792
MeshRenderer:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1339159333115884}
m_Enabled: 1
m_CastShadows: 1
m_ReceiveShadows: 1
m_DynamicOccludee: 1
m_MotionVectors: 1
m_LightProbeUsage: 1
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RenderingLayerMask: 4294967295
m_RendererPriority: 0
m_Materials:
- {fileID: 2100000, guid: cf774b4c734b1d04e9fbf6d71e964591, type: 2}
m_StaticBatchInfo:
firstSubMesh: 0
subMeshCount: 0
m_StaticBatchRoot: {fileID: 0}
m_ProbeAnchor: {fileID: 0}
m_LightProbeVolumeOverride: {fileID: 0}
m_ScaleInLightmap: 1
m_ReceiveGI: 1
m_PreserveUVs: 1
m_IgnoreNormalsForChartDetection: 0
m_ImportantGI: 0
m_StitchLightmapSeams: 0
m_SelectedEditorRenderState: 3
m_MinimumChartSize: 4
m_AutoUVMaxDistance: 0.5
m_AutoUVMaxAngle: 89
m_LightmapParameters: {fileID: 0}
m_SortingLayerID: 0
m_SortingLayer: 0
m_SortingOrder: 0
--- !u!1 &1398904762131290
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 4898694727102280}
- component: {fileID: 136457490459165436}
- component: {fileID: 114565867274256808}
- component: {fileID: 114967586934651944}
- component: {fileID: 6177337246575538918}
m_Layer: 0
m_Name: ExampleCharacter
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &4898694727102280
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1398904762131290}
m_LocalRotation: {x: 0, y: 0.7071068, z: 0, w: 0.70710677}
m_LocalPosition: {x: -40.14, y: 0, z: -29.24}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children:
- {fileID: 43330286}
m_Father: {fileID: 0}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 0, y: 90.00001, z: 0}
--- !u!136 &136457490459165436
CapsuleCollider:
m_ObjectHideFlags: 8
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1398904762131290}
m_Material: {fileID: 0}
m_IsTrigger: 0
m_Enabled: 1
m_Radius: 0.5
m_Height: 2
m_Direction: 1
m_Center: {x: 0, y: 1, z: 0}
--- !u!114 &114565867274256808
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1398904762131290}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 76020eee813ed7844bcea94c5d5ce76a, type: 3}
m_Name:
m_EditorClassIdentifier:
Motor: {fileID: 114967586934651944}
MaxStableMoveSpeed: 10
StableMovementSharpness: 15
OrientationSharpness: 10
OrientationMethod: 1
MaxAirMoveSpeed: 15
AirAccelerationSpeed: 18
Drag: 0.1
AllowJumpingWhenSliding: 0
JumpUpSpeed: 10
JumpScalableForwardSpeed: 10
JumpPreGroundingGraceTime: 0
JumpPostGroundingGraceTime: 0
IgnoredColliders:
- {fileID: 0}
- {fileID: 0}
BonusOrientationMethod: 0
BonusOrientationSharpness: 10
Gravity: {x: 0, y: -30, z: 0}
MeshRoot: {fileID: 4036232530805280}
CameraFollowPoint: {fileID: 4718917724592500}
--- !u!114 &114967586934651944
MonoBehaviour:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1398904762131290}
m_Enabled: 1
m_EditorHideFlags: 0
m_Script: {fileID: 11500000, guid: 4d1bc5515e3ab954e80599c538834774, type: 3}
m_Name:
m_EditorClassIdentifier:
Capsule: {fileID: 136457490459165436}
CapsuleRadius: 0.5
CapsuleHeight: 2
CapsuleYOffset: 1
CapsulePhysicsMaterial: {fileID: 0}
GroundDetectionExtraDistance: 0
MaxStableSlopeAngle: 60
StableGroundLayers:
serializedVersion: 2
m_Bits: 4294967295
DiscreteCollisionEvents: 0
StepHandling: 1
MaxStepHeight: 0.5
AllowSteppingWithoutStableGrounding: 0
MinRequiredStepDepth: 0.1
LedgeAndDenivelationHandling: 1
MaxStableDistanceFromLedge: 0.5
MaxVelocityForLedgeSnap: 0
MaxStableDenivelationAngle: 180
InteractiveRigidbodyHandling: 1
RigidbodyInteractionType: 0
SimulatedCharacterMass: 1
PreserveAttachedRigidbodyMomentum: 1
HasPlanarConstraint: 0
PlanarConstraintAxis: {x: 0, y: 0, z: 1}
MaxMovementIterations: 5
MaxDecollisionIterations: 1
CheckMovementInitialOverlaps: 1
KillVelocityWhenExceedMaxMovementIterations: 1
KillRemainingMovementWhenExceedMaxMovementIterations: 1
--- !u!54 &6177337246575538918
Rigidbody:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1398904762131290}
serializedVersion: 2
m_Mass: 1
m_Drag: 0
m_AngularDrag: 0.05
m_UseGravity: 0
m_IsKinematic: 1
m_Interpolate: 0
m_Constraints: 0
m_CollisionDetection: 0
--- !u!1 &1758411822872852
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 4485742127011420}
- component: {fileID: 33111717300596878}
- component: {fileID: 23624829931232870}
m_Layer: 0
m_Name: Cylinder
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &4485742127011420
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1758411822872852}
m_LocalRotation: {x: 0.70710677, y: -0, z: -0, w: 0.7071068}
m_LocalPosition: {x: 0, y: 0.44099998, z: 0.18199922}
m_LocalScale: {x: 0.88040376, y: 0.34093377, z: 0.51656276}
m_Children: []
m_Father: {fileID: 4903610365175460}
m_RootOrder: 0
m_LocalEulerAnglesHint: {x: 90.00001, y: 0, z: 0}
--- !u!33 &33111717300596878
MeshFilter:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1758411822872852}
m_Mesh: {fileID: 10206, guid: 0000000000000000e000000000000000, type: 0}
--- !u!23 &23624829931232870
MeshRenderer:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1758411822872852}
m_Enabled: 1
m_CastShadows: 1
m_ReceiveShadows: 1
m_DynamicOccludee: 1
m_MotionVectors: 1
m_LightProbeUsage: 1
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RenderingLayerMask: 4294967295
m_RendererPriority: 0
m_Materials:
- {fileID: 2100000, guid: cf774b4c734b1d04e9fbf6d71e964591, type: 2}
m_StaticBatchInfo:
firstSubMesh: 0
subMeshCount: 0
m_StaticBatchRoot: {fileID: 0}
m_ProbeAnchor: {fileID: 0}
m_LightProbeVolumeOverride: {fileID: 0}
m_ScaleInLightmap: 1
m_ReceiveGI: 1
m_PreserveUVs: 1
m_IgnoreNormalsForChartDetection: 0
m_ImportantGI: 0
m_StitchLightmapSeams: 0
m_SelectedEditorRenderState: 3
m_MinimumChartSize: 4
m_AutoUVMaxDistance: 0.5
m_AutoUVMaxAngle: 89
m_LightmapParameters: {fileID: 0}
m_SortingLayerID: 0
m_SortingLayer: 0
m_SortingOrder: 0
--- !u!1 &1854746833484672
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 4718917724592500}
m_Layer: 0
m_Name: CameraTarget
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!4 &4718917724592500
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 1854746833484672}
m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
m_LocalPosition: {x: 0, y: 1.43, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_Children: []
m_Father: {fileID: 43330286}
m_RootOrder: 1
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

9
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Prefabs/ExampleCharacter.prefab.meta
View File

@ -1,9 +0,0 @@
fileFormatVersion: 2
guid: d295472d4ce25404e9aed2627c34801f
timeCreated: 1499181148
licenseType: Store
NativeFormatImporter:
mainObjectFileID: 100100000
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Scripts.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 9751300dc66704b4f87d358c2a60f913
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

179
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterCamera.cs
View File

@ -1,179 +0,0 @@
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace KinematicCharacterController.Examples
{
public class ExampleCharacterCamera : MonoBehaviour
{
[Header("Framing")]
public Camera Camera;
public Vector2 FollowPointFraming = new Vector2(0f, 0f);
public float FollowingSharpness = 10000f;
[Header("Distance")]
public float DefaultDistance = 6f;
public float MinDistance = 0f;
public float MaxDistance = 10f;
public float DistanceMovementSpeed = 5f;
public float DistanceMovementSharpness = 10f;
[Header("Rotation")]
public bool InvertX = false;
public bool InvertY = false;
[Range(-90f, 90f)]
public float DefaultVerticalAngle = 20f;
[Range(-90f, 90f)]
public float MinVerticalAngle = -90f;
[Range(-90f, 90f)]
public float MaxVerticalAngle = 90f;
public float RotationSpeed = 1f;
public float RotationSharpness = 10000f;
public bool RotateWithPhysicsMover = false;
[Header("Obstruction")]
public float ObstructionCheckRadius = 0.2f;
public LayerMask ObstructionLayers = -1;
public float ObstructionSharpness = 10000f;
public List<Collider> IgnoredColliders = new List<Collider>();
public Transform Transform { get; private set; }
public Transform FollowTransform { get; private set; }
public Vector3 PlanarDirection { get; set; }
public float TargetDistance { get; set; }
private bool _distanceIsObstructed;
private float _currentDistance;
private float _targetVerticalAngle;
private RaycastHit _obstructionHit;
private int _obstructionCount;
private RaycastHit[] _obstructions = new RaycastHit[MaxObstructions];
private float _obstructionTime;
private Vector3 _currentFollowPosition;
private const int MaxObstructions = 32;
void OnValidate()
{
DefaultDistance = Mathf.Clamp(DefaultDistance, MinDistance, MaxDistance);
DefaultVerticalAngle = Mathf.Clamp(DefaultVerticalAngle, MinVerticalAngle, MaxVerticalAngle);
}
void Awake()
{
Transform = this.transform;
_currentDistance = DefaultDistance;
TargetDistance = _currentDistance;
_targetVerticalAngle = 0f;
PlanarDirection = Vector3.forward;
}
// Set the transform that the camera will orbit around
public void SetFollowTransform(Transform t)
{
FollowTransform = t;
PlanarDirection = FollowTransform.forward;
_currentFollowPosition = FollowTransform.position;
}
public void UpdateWithInput(float deltaTime, float zoomInput, Vector3 rotationInput)
{
if (FollowTransform)
{
if (InvertX)
{
rotationInput.x *= -1f;
}
if (InvertY)
{
rotationInput.y *= -1f;
}
// Process rotation input
Quaternion rotationFromInput = Quaternion.Euler(FollowTransform.up * (rotationInput.x * RotationSpeed));
PlanarDirection = rotationFromInput * PlanarDirection;
PlanarDirection = Vector3.Cross(FollowTransform.up, Vector3.Cross(PlanarDirection, FollowTransform.up));
Quaternion planarRot = Quaternion.LookRotation(PlanarDirection, FollowTransform.up);
_targetVerticalAngle -= (rotationInput.y * RotationSpeed);
_targetVerticalAngle = Mathf.Clamp(_targetVerticalAngle, MinVerticalAngle, MaxVerticalAngle);
Quaternion verticalRot = Quaternion.Euler(_targetVerticalAngle, 0, 0);
Quaternion targetRotation = Quaternion.Slerp(Transform.rotation, planarRot * verticalRot, 1f - Mathf.Exp(-RotationSharpness * deltaTime));
// Apply rotation
Transform.rotation = targetRotation;
// Process distance input
if (_distanceIsObstructed && Mathf.Abs(zoomInput) > 0f)
{
TargetDistance = _currentDistance;
}
TargetDistance += zoomInput * DistanceMovementSpeed;
TargetDistance = Mathf.Clamp(TargetDistance, MinDistance, MaxDistance);
// Find the smoothed follow position
_currentFollowPosition = Vector3.Lerp(_currentFollowPosition, FollowTransform.position, 1f - Mathf.Exp(-FollowingSharpness * deltaTime));
// Handle obstructions
{
RaycastHit closestHit = new RaycastHit();
closestHit.distance = Mathf.Infinity;
_obstructionCount = Physics.SphereCastNonAlloc(_currentFollowPosition, ObstructionCheckRadius, -Transform.forward, _obstructions, TargetDistance, ObstructionLayers, QueryTriggerInteraction.Ignore);
for (int i = 0; i < _obstructionCount; i++)
{
bool isIgnored = false;
for (int j = 0; j < IgnoredColliders.Count; j++)
{
if (IgnoredColliders[j] == _obstructions[i].collider)
{
isIgnored = true;
break;
}
}
for (int j = 0; j < IgnoredColliders.Count; j++)
{
if (IgnoredColliders[j] == _obstructions[i].collider)
{
isIgnored = true;
break;
}
}
if (!isIgnored && _obstructions[i].distance < closestHit.distance && _obstructions[i].distance > 0)
{
closestHit = _obstructions[i];
}
}
// If obstructions detecter
if (closestHit.distance < Mathf.Infinity)
{
_distanceIsObstructed = true;
_currentDistance = Mathf.Lerp(_currentDistance, closestHit.distance, 1 - Mathf.Exp(-ObstructionSharpness * deltaTime));
}
// If no obstruction
else
{
_distanceIsObstructed = false;
_currentDistance = Mathf.Lerp(_currentDistance, TargetDistance, 1 - Mathf.Exp(-DistanceMovementSharpness * deltaTime));
}
}
// Find the smoothed camera orbit position
Vector3 targetPosition = _currentFollowPosition - ((targetRotation * Vector3.forward) * _currentDistance);
// Handle framing
targetPosition += Transform.right * FollowPointFraming.x;
targetPosition += Transform.up * FollowPointFraming.y;
// Apply position
Transform.position = targetPosition;
}
}
}
}

12
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterCamera.cs.meta
View File

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 24092a40b02616e479baeb940325e339
timeCreated: 1485657083
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

516
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterController.cs
View File

@ -1,516 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using KinematicCharacterController;
using System;
namespace KinematicCharacterController.Examples
{
public enum CharacterState
{
Default,
}
public enum OrientationMethod
{
TowardsCamera,
TowardsMovement,
}
public struct PlayerCharacterInputs
{
public float MoveAxisForward;
public float MoveAxisRight;
public Quaternion CameraRotation;
public bool JumpDown;
public bool CrouchDown;
public bool CrouchUp;
}
public struct AICharacterInputs
{
public Vector3 MoveVector;
public Vector3 LookVector;
}
public enum BonusOrientationMethod
{
None,
TowardsGravity,
TowardsGroundSlopeAndGravity,
}
public class ExampleCharacterController : MonoBehaviour, ICharacterController
{
public KinematicCharacterMotor Motor;
[Header("Stable Movement")]
public float MaxStableMoveSpeed = 10f;
public float StableMovementSharpness = 15f;
public float OrientationSharpness = 10f;
public OrientationMethod OrientationMethod = OrientationMethod.TowardsCamera;
[Header("Air Movement")]
public float MaxAirMoveSpeed = 15f;
public float AirAccelerationSpeed = 15f;
public float Drag = 0.1f;
[Header("Jumping")]
public bool AllowJumpingWhenSliding = false;
public float JumpUpSpeed = 10f;
public float JumpScalableForwardSpeed = 10f;
public float JumpPreGroundingGraceTime = 0f;
public float JumpPostGroundingGraceTime = 0f;
[Header("Misc")]
public List<Collider> IgnoredColliders = new List<Collider>();
public BonusOrientationMethod BonusOrientationMethod = BonusOrientationMethod.None;
public float BonusOrientationSharpness = 10f;
public Vector3 Gravity = new Vector3(0, -30f, 0);
public Transform MeshRoot;
public Transform CameraFollowPoint;
public float CrouchedCapsuleHeight = 1f;
public CharacterState CurrentCharacterState { get; private set; }
private Collider[] _probedColliders = new Collider[8];
private RaycastHit[] _probedHits = new RaycastHit[8];
private Vector3 _moveInputVector;
private Vector3 _lookInputVector;
private bool _jumpRequested = false;
private bool _jumpConsumed = false;
private bool _jumpedThisFrame = false;
private float _timeSinceJumpRequested = Mathf.Infinity;
private float _timeSinceLastAbleToJump = 0f;
private Vector3 _internalVelocityAdd = Vector3.zero;
private bool _shouldBeCrouching = false;
private bool _isCrouching = false;
private Vector3 lastInnerNormal = Vector3.zero;
private Vector3 lastOuterNormal = Vector3.zero;
private void Awake()
{
// Handle initial state
TransitionToState(CharacterState.Default);
// Assign the characterController to the motor
Motor.CharacterController = this;
}
/// <summary>
/// Handles movement state transitions and enter/exit callbacks
/// </summary>
public void TransitionToState(CharacterState newState)
{
CharacterState tmpInitialState = CurrentCharacterState;
OnStateExit(tmpInitialState, newState);
CurrentCharacterState = newState;
OnStateEnter(newState, tmpInitialState);
}
/// <summary>
/// Event when entering a state
/// </summary>
public void OnStateEnter(CharacterState state, CharacterState fromState)
{
switch (state)
{
case CharacterState.Default:
{
break;
}
}
}
/// <summary>
/// Event when exiting a state
/// </summary>
public void OnStateExit(CharacterState state, CharacterState toState)
{
switch (state)
{
case CharacterState.Default:
{
break;
}
}
}
/// <summary>
/// This is called every frame by ExamplePlayer in order to tell the character what its inputs are
/// </summary>
public void SetInputs(ref PlayerCharacterInputs inputs)
{
// Clamp input
Vector3 moveInputVector = Vector3.ClampMagnitude(new Vector3(inputs.MoveAxisRight, 0f, inputs.MoveAxisForward), 1f);
// Calculate camera direction and rotation on the character plane
Vector3 cameraPlanarDirection = Vector3.ProjectOnPlane(inputs.CameraRotation * Vector3.forward, Motor.CharacterUp).normalized;
if (cameraPlanarDirection.sqrMagnitude == 0f)
{
cameraPlanarDirection = Vector3.ProjectOnPlane(inputs.CameraRotation * Vector3.up, Motor.CharacterUp).normalized;
}
Quaternion cameraPlanarRotation = Quaternion.LookRotation(cameraPlanarDirection, Motor.CharacterUp);
switch (CurrentCharacterState)
{
case CharacterState.Default:
{
// Move and look inputs
_moveInputVector = cameraPlanarRotation * moveInputVector;
switch (OrientationMethod)
{
case OrientationMethod.TowardsCamera:
_lookInputVector = cameraPlanarDirection;
break;
case OrientationMethod.TowardsMovement:
_lookInputVector = _moveInputVector.normalized;
break;
}
// Jumping input
if (inputs.JumpDown)
{
_timeSinceJumpRequested = 0f;
_jumpRequested = true;
}
// Crouching input
if (inputs.CrouchDown)
{
_shouldBeCrouching = true;
if (!_isCrouching)
{
_isCrouching = true;
Motor.SetCapsuleDimensions(0.5f, CrouchedCapsuleHeight, CrouchedCapsuleHeight * 0.5f);
MeshRoot.localScale = new Vector3(1f, 0.5f, 1f);
}
}
else if (inputs.CrouchUp)
{
_shouldBeCrouching = false;
}
break;
}
}
}
/// <summary>
/// This is called every frame by the AI script in order to tell the character what its inputs are
/// </summary>
public void SetInputs(ref AICharacterInputs inputs)
{
_moveInputVector = inputs.MoveVector;
_lookInputVector = inputs.LookVector;
}
private Quaternion _tmpTransientRot;
/// <summary>
/// (Called by KinematicCharacterMotor during its update cycle)
/// This is called before the character begins its movement update
/// </summary>
public void BeforeCharacterUpdate(float deltaTime)
{
}
/// <summary>
/// (Called by KinematicCharacterMotor during its update cycle)
/// This is where you tell your character what its rotation should be right now.
/// This is the ONLY place where you should set the character's rotation
/// </summary>
public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
{
switch (CurrentCharacterState)
{
case CharacterState.Default:
{
if (_lookInputVector.sqrMagnitude > 0f && OrientationSharpness > 0f)
{
// Smoothly interpolate from current to target look direction
Vector3 smoothedLookInputDirection = Vector3.Slerp(Motor.CharacterForward, _lookInputVector, 1 - Mathf.Exp(-OrientationSharpness * deltaTime)).normalized;
// Set the current rotation (which will be used by the KinematicCharacterMotor)
currentRotation = Quaternion.LookRotation(smoothedLookInputDirection, Motor.CharacterUp);
}
Vector3 currentUp = (currentRotation * Vector3.up);
if (BonusOrientationMethod == BonusOrientationMethod.TowardsGravity)
{
// Rotate from current up to invert gravity
Vector3 smoothedGravityDir = Vector3.Slerp(currentUp, -Gravity.normalized, 1 - Mathf.Exp(-BonusOrientationSharpness * deltaTime));
currentRotation = Quaternion.FromToRotation(currentUp, smoothedGravityDir) * currentRotation;
}
else if (BonusOrientationMethod == BonusOrientationMethod.TowardsGroundSlopeAndGravity)
{
if (Motor.GroundingStatus.IsStableOnGround)
{
Vector3 initialCharacterBottomHemiCenter = Motor.TransientPosition + (currentUp * Motor.Capsule.radius);
Vector3 smoothedGroundNormal = Vector3.Slerp(Motor.CharacterUp, Motor.GroundingStatus.GroundNormal, 1 - Mathf.Exp(-BonusOrientationSharpness * deltaTime));
currentRotation = Quaternion.FromToRotation(currentUp, smoothedGroundNormal) * currentRotation;
// Move the position to create a rotation around the bottom hemi center instead of around the pivot
Motor.SetTransientPosition(initialCharacterBottomHemiCenter + (currentRotation * Vector3.down * Motor.Capsule.radius));
}
else
{
Vector3 smoothedGravityDir = Vector3.Slerp(currentUp, -Gravity.normalized, 1 - Mathf.Exp(-BonusOrientationSharpness * deltaTime));
currentRotation = Quaternion.FromToRotation(currentUp, smoothedGravityDir) * currentRotation;
}
}
else
{
Vector3 smoothedGravityDir = Vector3.Slerp(currentUp, Vector3.up, 1 - Mathf.Exp(-BonusOrientationSharpness * deltaTime));
currentRotation = Quaternion.FromToRotation(currentUp, smoothedGravityDir) * currentRotation;
}
break;
}
}
}
/// <summary>
/// (Called by KinematicCharacterMotor during its update cycle)
/// This is where you tell your character what its velocity should be right now.
/// This is the ONLY place where you can set the character's velocity
/// </summary>
public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
{
switch (CurrentCharacterState)
{
case CharacterState.Default:
{
// Ground movement
if (Motor.GroundingStatus.IsStableOnGround)
{
float currentVelocityMagnitude = currentVelocity.magnitude;
Vector3 effectiveGroundNormal = Motor.GroundingStatus.GroundNormal;
// Reorient velocity on slope
currentVelocity = Motor.GetDirectionTangentToSurface(currentVelocity, effectiveGroundNormal) * currentVelocityMagnitude;
// Calculate target velocity
Vector3 inputRight = Vector3.Cross(_moveInputVector, Motor.CharacterUp);
Vector3 reorientedInput = Vector3.Cross(effectiveGroundNormal, inputRight).normalized * _moveInputVector.magnitude;
Vector3 targetMovementVelocity = reorientedInput * MaxStableMoveSpeed;
// Smooth movement Velocity
currentVelocity = Vector3.Lerp(currentVelocity, targetMovementVelocity, 1f - Mathf.Exp(-StableMovementSharpness * deltaTime));
}
// Air movement
else
{
// Add move input
if (_moveInputVector.sqrMagnitude > 0f)
{
Vector3 addedVelocity = _moveInputVector * AirAccelerationSpeed * deltaTime;
Vector3 currentVelocityOnInputsPlane = Vector3.ProjectOnPlane(currentVelocity, Motor.CharacterUp);
// Limit air velocity from inputs
if (currentVelocityOnInputsPlane.magnitude < MaxAirMoveSpeed)
{
// clamp addedVel to make total vel not exceed max vel on inputs plane
Vector3 newTotal = Vector3.ClampMagnitude(currentVelocityOnInputsPlane + addedVelocity, MaxAirMoveSpeed);
addedVelocity = newTotal - currentVelocityOnInputsPlane;
}
else
{
// Make sure added vel doesn't go in the direction of the already-exceeding velocity
if (Vector3.Dot(currentVelocityOnInputsPlane, addedVelocity) > 0f)
{
addedVelocity = Vector3.ProjectOnPlane(addedVelocity, currentVelocityOnInputsPlane.normalized);
}
}
// Prevent air-climbing sloped walls
if (Motor.GroundingStatus.FoundAnyGround)
{
if (Vector3.Dot(currentVelocity + addedVelocity, addedVelocity) > 0f)
{
Vector3 perpenticularObstructionNormal = Vector3.Cross(Vector3.Cross(Motor.CharacterUp, Motor.GroundingStatus.GroundNormal), Motor.CharacterUp).normalized;
addedVelocity = Vector3.ProjectOnPlane(addedVelocity, perpenticularObstructionNormal);
}
}
// Apply added velocity
currentVelocity += addedVelocity;
}
// Gravity
currentVelocity += Gravity * deltaTime;
// Drag
currentVelocity *= (1f / (1f + (Drag * deltaTime)));
}
// Handle jumping
_jumpedThisFrame = false;
_timeSinceJumpRequested += deltaTime;
if (_jumpRequested)
{
// See if we actually are allowed to jump
if (!_jumpConsumed && ((AllowJumpingWhenSliding ? Motor.GroundingStatus.FoundAnyGround : Motor.GroundingStatus.IsStableOnGround) || _timeSinceLastAbleToJump <= JumpPostGroundingGraceTime))
{
// Calculate jump direction before ungrounding
Vector3 jumpDirection = Motor.CharacterUp;
if (Motor.GroundingStatus.FoundAnyGround && !Motor.GroundingStatus.IsStableOnGround)
{
jumpDirection = Motor.GroundingStatus.GroundNormal;
}
// Makes the character skip ground probing/snapping on its next update.
// If this line weren't here, the character would remain snapped to the ground when trying to jump. Try commenting this line out and see.
Motor.ForceUnground();
// Add to the return velocity and reset jump state
currentVelocity += (jumpDirection * JumpUpSpeed) - Vector3.Project(currentVelocity, Motor.CharacterUp);
currentVelocity += (_moveInputVector * JumpScalableForwardSpeed);
_jumpRequested = false;
_jumpConsumed = true;
_jumpedThisFrame = true;
}
}
// Take into account additive velocity
if (_internalVelocityAdd.sqrMagnitude > 0f)
{
currentVelocity += _internalVelocityAdd;
_internalVelocityAdd = Vector3.zero;
}
break;
}
}
}
/// <summary>
/// (Called by KinematicCharacterMotor during its update cycle)
/// This is called after the character has finished its movement update
/// </summary>
public void AfterCharacterUpdate(float deltaTime)
{
switch (CurrentCharacterState)
{
case CharacterState.Default:
{
// Handle jump-related values
{
// Handle jumping pre-ground grace period
if (_jumpRequested && _timeSinceJumpRequested > JumpPreGroundingGraceTime)
{
_jumpRequested = false;
}
if (AllowJumpingWhenSliding ? Motor.GroundingStatus.FoundAnyGround : Motor.GroundingStatus.IsStableOnGround)
{
// If we're on a ground surface, reset jumping values
if (!_jumpedThisFrame)
{
_jumpConsumed = false;
}
_timeSinceLastAbleToJump = 0f;
}
else
{
// Keep track of time since we were last able to jump (for grace period)
_timeSinceLastAbleToJump += deltaTime;
}
}
// Handle uncrouching
if (_isCrouching && !_shouldBeCrouching)
{
// Do an overlap test with the character's standing height to see if there are any obstructions
Motor.SetCapsuleDimensions(0.5f, 2f, 1f);
if (Motor.CharacterOverlap(
Motor.TransientPosition,
Motor.TransientRotation,
_probedColliders,
Motor.CollidableLayers,
QueryTriggerInteraction.Ignore) > 0)
{
// If obstructions, just stick to crouching dimensions
Motor.SetCapsuleDimensions(0.5f, CrouchedCapsuleHeight, CrouchedCapsuleHeight * 0.5f);
}
else
{
// If no obstructions, uncrouch
MeshRoot.localScale = new Vector3(1f, 1f, 1f);
_isCrouching = false;
}
}
break;
}
}
}
public void PostGroundingUpdate(float deltaTime)
{
// Handle landing and leaving ground
if (Motor.GroundingStatus.IsStableOnGround && !Motor.LastGroundingStatus.IsStableOnGround)
{
OnLanded();
}
else if (!Motor.GroundingStatus.IsStableOnGround && Motor.LastGroundingStatus.IsStableOnGround)
{
OnLeaveStableGround();
}
}
public bool IsColliderValidForCollisions(Collider coll)
{
if (IgnoredColliders.Count == 0)
{
return true;
}
if (IgnoredColliders.Contains(coll))
{
return false;
}
return true;
}
public void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport)
{
}
public void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport)
{
}
public void AddVelocity(Vector3 velocity)
{
switch (CurrentCharacterState)
{
case CharacterState.Default:
{
_internalVelocityAdd += velocity;
break;
}
}
}
public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, Vector3 atCharacterPosition, Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport)
{
}
protected void OnLanded()
{
}
protected void OnLeaveStableGround()
{
}
public void OnDiscreteCollisionDetected(Collider hitCollider)
{
}
}
}

13
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Scripts/ExampleCharacterController.cs.meta
View File

@ -1,13 +0,0 @@
fileFormatVersion: 2
guid: 76020eee813ed7844bcea94c5d5ce76a
timeCreated: 1503446428
licenseType: Store
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

99
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Scripts/ExamplePlayer.cs
View File

@ -1,99 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using KinematicCharacterController;
using KinematicCharacterController.Examples;
namespace KinematicCharacterController.Examples
{
public class ExamplePlayer : MonoBehaviour
{
public ExampleCharacterController Character;
public ExampleCharacterCamera CharacterCamera;
private const string MouseXInput = "Mouse X";
private const string MouseYInput = "Mouse Y";
private const string MouseScrollInput = "Mouse ScrollWheel";
private const string HorizontalInput = "Horizontal";
private const string VerticalInput = "Vertical";
private void Start()
{
Cursor.lockState = CursorLockMode.Locked;
// Tell camera to follow transform
CharacterCamera.SetFollowTransform(Character.CameraFollowPoint);
// Ignore the character's collider(s) for camera obstruction checks
CharacterCamera.IgnoredColliders.Clear();
CharacterCamera.IgnoredColliders.AddRange(Character.GetComponentsInChildren<Collider>());
}
private void Update()
{
if (Input.GetMouseButtonDown(0))
{
Cursor.lockState = CursorLockMode.Locked;
}
HandleCharacterInput();
}
private void LateUpdate()
{
// Handle rotating the camera along with physics movers
if (CharacterCamera.RotateWithPhysicsMover && Character.Motor.AttachedRigidbody != null)
{
CharacterCamera.PlanarDirection = Character.Motor.AttachedRigidbody.GetComponent<PhysicsMover>().RotationDeltaFromInterpolation * CharacterCamera.PlanarDirection;
CharacterCamera.PlanarDirection = Vector3.ProjectOnPlane(CharacterCamera.PlanarDirection, Character.Motor.CharacterUp).normalized;
}
HandleCameraInput();
}
private void HandleCameraInput()
{
// Create the look input vector for the camera
float mouseLookAxisUp = Input.GetAxisRaw(MouseYInput);
float mouseLookAxisRight = Input.GetAxisRaw(MouseXInput);
Vector3 lookInputVector = new Vector3(mouseLookAxisRight, mouseLookAxisUp, 0f);
// Prevent moving the camera while the cursor isn't locked
if (Cursor.lockState != CursorLockMode.Locked)
{
lookInputVector = Vector3.zero;
}
// Input for zooming the camera (disabled in WebGL because it can cause problems)
float scrollInput = -Input.GetAxis(MouseScrollInput);
#if UNITY_WEBGL
scrollInput = 0f;
#endif
// Apply inputs to the camera
CharacterCamera.UpdateWithInput(Time.deltaTime, scrollInput, lookInputVector);
// Handle toggling zoom level
if (Input.GetMouseButtonDown(1))
{
CharacterCamera.TargetDistance = (CharacterCamera.TargetDistance == 0f) ? CharacterCamera.DefaultDistance : 0f;
}
}
private void HandleCharacterInput()
{
PlayerCharacterInputs characterInputs = new PlayerCharacterInputs();
// Build the CharacterInputs struct
characterInputs.MoveAxisForward = Input.GetAxisRaw(VerticalInput);
characterInputs.MoveAxisRight = Input.GetAxisRaw(HorizontalInput);
characterInputs.CameraRotation = CharacterCamera.Transform.rotation;
characterInputs.JumpDown = Input.GetKeyDown(KeyCode.Space);
characterInputs.CrouchDown = Input.GetKeyDown(KeyCode.C);
characterInputs.CrouchUp = Input.GetKeyUp(KeyCode.C);
// Apply inputs to character
Character.SetInputs(ref characterInputs);
}
}
}

12
Assets/Plugins/KinematicCharacterController/ExampleCharacter/Scripts/ExamplePlayer.cs.meta
View File

@ -1,12 +0,0 @@
fileFormatVersion: 2
guid: 461cd396e3fc7cc4eb9c92bde05c1b9a
timeCreated: 1485657184
licenseType: Store
MonoImporter:
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Prefabs.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 8afac09345cd4ef4a8ddfd914bed2228
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

556
Assets/Scenes/test_conveyor_belt.unity
View File

@ -1,556 +0,0 @@
%YAML 1.1
%TAG !u! tag:unity3d.com,2011:
--- !u!29 &1
OcclusionCullingSettings:
m_ObjectHideFlags: 0
serializedVersion: 2
m_OcclusionBakeSettings:
smallestOccluder: 5
smallestHole: 0.25
backfaceThreshold: 100
m_SceneGUID: 00000000000000000000000000000000
m_OcclusionCullingData: {fileID: 0}
--- !u!104 &2
RenderSettings:
m_ObjectHideFlags: 0
serializedVersion: 9
m_Fog: 0
m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
m_FogMode: 3
m_FogDensity: 0.01
m_LinearFogStart: 0
m_LinearFogEnd: 300
m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
m_AmbientIntensity: 1
m_AmbientMode: 0
m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
m_SkyboxMaterial: {fileID: 10304, guid: 0000000000000000f000000000000000, type: 0}
m_HaloStrength: 0.5
m_FlareStrength: 1
m_FlareFadeSpeed: 3
m_HaloTexture: {fileID: 0}
m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
m_DefaultReflectionMode: 0
m_DefaultReflectionResolution: 128
m_ReflectionBounces: 1
m_ReflectionIntensity: 1
m_CustomReflection: {fileID: 0}
m_Sun: {fileID: 705507994}
m_UseRadianceAmbientProbe: 0
--- !u!157 &3
LightmapSettings:
m_ObjectHideFlags: 0
serializedVersion: 12
m_GIWorkflowMode: 1
m_GISettings:
serializedVersion: 2
m_BounceScale: 1
m_IndirectOutputScale: 1
m_AlbedoBoost: 1
m_EnvironmentLightingMode: 0
m_EnableBakedLightmaps: 1
m_EnableRealtimeLightmaps: 0
m_LightmapEditorSettings:
serializedVersion: 12
m_Resolution: 2
m_BakeResolution: 40
m_AtlasSize: 1024
m_AO: 0
m_AOMaxDistance: 1
m_CompAOExponent: 1
m_CompAOExponentDirect: 0
m_ExtractAmbientOcclusion: 0
m_Padding: 2
m_LightmapParameters: {fileID: 0}
m_LightmapsBakeMode: 1
m_TextureCompression: 1
m_FinalGather: 0
m_FinalGatherFiltering: 1
m_FinalGatherRayCount: 256
m_ReflectionCompression: 2
m_MixedBakeMode: 2
m_BakeBackend: 1
m_PVRSampling: 1
m_PVRDirectSampleCount: 32
m_PVRSampleCount: 500
m_PVRBounces: 2
m_PVREnvironmentSampleCount: 500
m_PVREnvironmentReferencePointCount: 2048
m_PVRFilteringMode: 2
m_PVRDenoiserTypeDirect: 0
m_PVRDenoiserTypeIndirect: 0
m_PVRDenoiserTypeAO: 0
m_PVRFilterTypeDirect: 0
m_PVRFilterTypeIndirect: 0
m_PVRFilterTypeAO: 0
m_PVREnvironmentMIS: 0
m_PVRCulling: 1
m_PVRFilteringGaussRadiusDirect: 1
m_PVRFilteringGaussRadiusIndirect: 5
m_PVRFilteringGaussRadiusAO: 2
m_PVRFilteringAtrousPositionSigmaDirect: 0.5
m_PVRFilteringAtrousPositionSigmaIndirect: 2
m_PVRFilteringAtrousPositionSigmaAO: 1
m_ExportTrainingData: 0
m_TrainingDataDestination: TrainingData
m_LightProbeSampleCountMultiplier: 4
m_LightingDataAsset: {fileID: 0}
m_LightingSettings: {fileID: 0}
--- !u!196 &4
NavMeshSettings:
serializedVersion: 2
m_ObjectHideFlags: 0
m_BuildSettings:
serializedVersion: 3
agentTypeID: 0
agentRadius: 0.5
agentHeight: 2
agentSlope: 45
agentClimb: 0.4
ledgeDropHeight: 0
maxJumpAcrossDistance: 0
minRegionArea: 2
manualCellSize: 0
cellSize: 0.16666667
manualTileSize: 0
tileSize: 256
buildHeightMesh: 0
maxJobWorkers: 0
preserveTilesOutsideBounds: 0
debug:
m_Flags: 0
m_NavMeshData: {fileID: 0}
--- !u!1 &473816182
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 473816187}
- component: {fileID: 473816186}
- component: {fileID: 473816185}
- component: {fileID: 473816184}
- component: {fileID: 473816183}
m_Layer: 0
m_Name: Cube (1)
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!54 &473816183
Rigidbody:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 473816182}
serializedVersion: 4
m_Mass: 1
m_Drag: 0
m_AngularDrag: 0.05
m_CenterOfMass: {x: 0, y: 0, z: 0}
m_InertiaTensor: {x: 1, y: 1, z: 1}
m_InertiaRotation: {x: 0, y: 0, z: 0, w: 1}
m_IncludeLayers:
serializedVersion: 2
m_Bits: 0
m_ExcludeLayers:
serializedVersion: 2
m_Bits: 0
m_ImplicitCom: 1
m_ImplicitTensor: 1
m_UseGravity: 1
m_IsKinematic: 0
m_Interpolate: 0
m_Constraints: 0
m_CollisionDetection: 0
--- !u!65 &473816184
BoxCollider:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 473816182}
m_Material: {fileID: 0}
m_IncludeLayers:
serializedVersion: 2
m_Bits: 0
m_ExcludeLayers:
serializedVersion: 2
m_Bits: 0
m_LayerOverridePriority: 0
m_IsTrigger: 0
m_ProvidesContacts: 0
m_Enabled: 1
serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &473816185
MeshRenderer:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 473816182}
m_Enabled: 1
m_CastShadows: 1
m_ReceiveShadows: 1
m_DynamicOccludee: 1
m_StaticShadowCaster: 0
m_MotionVectors: 1
m_LightProbeUsage: 1
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
- {fileID: 10303, guid: 0000000000000000f000000000000000, type: 0}
m_StaticBatchInfo:
firstSubMesh: 0
subMeshCount: 0
m_StaticBatchRoot: {fileID: 0}
m_ProbeAnchor: {fileID: 0}
m_LightProbeVolumeOverride: {fileID: 0}
m_ScaleInLightmap: 1
m_ReceiveGI: 1
m_PreserveUVs: 0
m_IgnoreNormalsForChartDetection: 0
m_ImportantGI: 0
m_StitchLightmapSeams: 1
m_SelectedEditorRenderState: 3
m_MinimumChartSize: 4
m_AutoUVMaxDistance: 0.5
m_AutoUVMaxAngle: 89
m_LightmapParameters: {fileID: 0}
m_SortingLayerID: 0
m_SortingLayer: 0
m_SortingOrder: 0
m_AdditionalVertexStreams: {fileID: 0}
--- !u!33 &473816186
MeshFilter:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 473816182}
m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
--- !u!4 &473816187
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 473816182}
serializedVersion: 2
m_LocalRotation: {x: 0.30602813, y: 0.05105421, z: -0.15643394, w: 0.9376933}
m_LocalPosition: {x: 6.93, y: 2.23, z: -0.1150293}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 36.15, y: 0, z: -18.943}
--- !u!1 &705507993
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 705507995}
- component: {fileID: 705507994}
m_Layer: 0
m_Name: Directional Light
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!108 &705507994
Light:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 705507993}
m_Enabled: 1
serializedVersion: 10
m_Type: 1
m_Shape: 0
m_Color: {r: 1, g: 0.95686275, b: 0.8392157, a: 1}
m_Intensity: 1
m_Range: 10
m_SpotAngle: 30
m_InnerSpotAngle: 21.80208
m_CookieSize: 10
m_Shadows:
m_Type: 2
m_Resolution: -1
m_CustomResolution: -1
m_Strength: 1
m_Bias: 0.05
m_NormalBias: 0.4
m_NearPlane: 0.2
m_CullingMatrixOverride:
e00: 1
e01: 0
e02: 0
e03: 0
e10: 0
e11: 1
e12: 0
e13: 0
e20: 0
e21: 0
e22: 1
e23: 0
e30: 0
e31: 0
e32: 0
e33: 1
m_UseCullingMatrixOverride: 0
m_Cookie: {fileID: 0}
m_DrawHalo: 0
m_Flare: {fileID: 0}
m_RenderMode: 0
m_CullingMask:
serializedVersion: 2
m_Bits: 4294967295
m_RenderingLayerMask: 1
m_Lightmapping: 1
m_LightShadowCasterMode: 0
m_AreaSize: {x: 1, y: 1}
m_BounceIntensity: 1
m_ColorTemperature: 6570
m_UseColorTemperature: 0
m_BoundingSphereOverride: {x: 0, y: 0, z: 0, w: 0}
m_UseBoundingSphereOverride: 0
m_UseViewFrustumForShadowCasterCull: 1
m_ShadowRadius: 0
m_ShadowAngle: 0
--- !u!4 &705507995
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 705507993}
serializedVersion: 2
m_LocalRotation: {x: 0.40821788, y: -0.23456968, z: 0.10938163, w: 0.8754261}
m_LocalPosition: {x: 0, y: 3, z: 0}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
--- !u!1 &891192242
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 891192246}
- component: {fileID: 891192245}
- component: {fileID: 891192244}
- component: {fileID: 891192243}
m_Layer: 0
m_Name: Cube
m_TagString: Untagged
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!65 &891192243
BoxCollider:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 891192242}
m_Material: {fileID: 0}
m_IncludeLayers:
serializedVersion: 2
m_Bits: 0
m_ExcludeLayers:
serializedVersion: 2
m_Bits: 0
m_LayerOverridePriority: 0
m_IsTrigger: 0
m_ProvidesContacts: 0
m_Enabled: 1
serializedVersion: 3
m_Size: {x: 1, y: 1, z: 1}
m_Center: {x: 0, y: 0, z: 0}
--- !u!23 &891192244
MeshRenderer:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 891192242}
m_Enabled: 1
m_CastShadows: 1
m_ReceiveShadows: 1
m_DynamicOccludee: 1
m_StaticShadowCaster: 0
m_MotionVectors: 1
m_LightProbeUsage: 1
m_ReflectionProbeUsage: 1
m_RayTracingMode: 2
m_RayTraceProcedural: 0
m_RenderingLayerMask: 1
m_RendererPriority: 0
m_Materials:
- {fileID: 10303, guid: 0000000000000000f000000000000000, type: 0}
m_StaticBatchInfo:
firstSubMesh: 0
subMeshCount: 0
m_StaticBatchRoot: {fileID: 0}
m_ProbeAnchor: {fileID: 0}
m_LightProbeVolumeOverride: {fileID: 0}
m_ScaleInLightmap: 1
m_ReceiveGI: 1
m_PreserveUVs: 0
m_IgnoreNormalsForChartDetection: 0
m_ImportantGI: 0
m_StitchLightmapSeams: 1
m_SelectedEditorRenderState: 3
m_MinimumChartSize: 4
m_AutoUVMaxDistance: 0.5
m_AutoUVMaxAngle: 89
m_LightmapParameters: {fileID: 0}
m_SortingLayerID: 0
m_SortingLayer: 0
m_SortingOrder: 0
m_AdditionalVertexStreams: {fileID: 0}
--- !u!33 &891192245
MeshFilter:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 891192242}
m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
--- !u!4 &891192246
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 891192242}
serializedVersion: 2
m_LocalRotation: {x: -0, y: -0.70710576, z: -0, w: 0.70710784}
m_LocalPosition: {x: 0, y: 0, z: 0}
m_LocalScale: {x: 3.1029825, y: 0.20722, z: 24.11014}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 0, y: -90, z: 0}
--- !u!1 &963194225
GameObject:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
serializedVersion: 6
m_Component:
- component: {fileID: 963194228}
- component: {fileID: 963194227}
- component: {fileID: 963194226}
m_Layer: 0
m_Name: Main Camera
m_TagString: MainCamera
m_Icon: {fileID: 0}
m_NavMeshLayer: 0
m_StaticEditorFlags: 0
m_IsActive: 1
--- !u!81 &963194226
AudioListener:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 963194225}
m_Enabled: 1
--- !u!20 &963194227
Camera:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 963194225}
m_Enabled: 1
serializedVersion: 2
m_ClearFlags: 1
m_BackGroundColor: {r: 0.19215687, g: 0.3019608, b: 0.4745098, a: 0}
m_projectionMatrixMode: 1
m_GateFitMode: 2
m_FOVAxisMode: 0
m_Iso: 200
m_ShutterSpeed: 0.005
m_Aperture: 16
m_FocusDistance: 10
m_FocalLength: 50
m_BladeCount: 5
m_Curvature: {x: 2, y: 11}
m_BarrelClipping: 0.25
m_Anamorphism: 0
m_SensorSize: {x: 36, y: 24}
m_LensShift: {x: 0, y: 0}
m_NormalizedViewPortRect:
serializedVersion: 2
x: 0
y: 0
width: 1
height: 1
near clip plane: 0.3
far clip plane: 1000
field of view: 60
orthographic: 0
orthographic size: 5
m_Depth: -1
m_CullingMask:
serializedVersion: 2
m_Bits: 4294967295
m_RenderingPath: -1
m_TargetTexture: {fileID: 0}
m_TargetDisplay: 0
m_TargetEye: 3
m_HDR: 1
m_AllowMSAA: 1
m_AllowDynamicResolution: 0
m_ForceIntoRT: 0
m_OcclusionCulling: 1
m_StereoConvergence: 10
m_StereoSeparation: 0.022
--- !u!4 &963194228
Transform:
m_ObjectHideFlags: 0
m_CorrespondingSourceObject: {fileID: 0}
m_PrefabInstance: {fileID: 0}
m_PrefabAsset: {fileID: 0}
m_GameObject: {fileID: 963194225}
serializedVersion: 2
m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
m_LocalPosition: {x: 0, y: 1, z: -10}
m_LocalScale: {x: 1, y: 1, z: 1}
m_ConstrainProportionsScale: 0
m_Children: []
m_Father: {fileID: 0}
m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
--- !u!1660057539 &9223372036854775807
SceneRoots:
m_ObjectHideFlags: 0
m_Roots:
- {fileID: 963194228}
- {fileID: 705507995}
- {fileID: 891192246}
- {fileID: 473816187}

7
Assets/Scenes/test_conveyor_belt.unity.meta
View File

@ -1,7 +0,0 @@
fileFormatVersion: 2
guid: 8f9205ee506fb534d868df8537e76507
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Scripts.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: 8cfcb212ffcd02c4f9a2c70fac9ae7c5
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

27
Assets/Scripts/ConveyorBelt.cs
View File

@ -1,27 +0,0 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
public class ConveyorBelt : MonoBehaviour
{
public float speed = 1;
List<ContactPoint> contactPoints = new List<ContactPoint>();
private void OnCollisionStay(Collision collision)
{
Vector3 targetSpeed = speed * Vector3.forward;
Vector3 vel = collision.relativeVelocity;
int count = collision.GetContacts(contactPoints);
if (collision.rigidbody)
{
for (int i = 0; i < count; i++)
{
}
}
}
}

11
Assets/Scripts/ConveyorBelt.cs.meta
View File

@ -1,11 +0,0 @@
fileFormatVersion: 2
guid: e0f1f2901f5dad644b6199c19a0e8cce
MonoImporter:
externalObjects: {}
serializedVersion: 2
defaultReferences: []
executionOrder: 0
icon: {instanceID: 0}
userData:
assetBundleName:
assetBundleVariant:

8
Assets/Textures.meta
View File

@ -1,8 +0,0 @@
fileFormatVersion: 2
guid: c3bad3b2baaa54f47ac1811c6792f4a2
folderAsset: yes
DefaultImporter:
externalObjects: {}
userData:
assetBundleName:
assetBundleVariant:

1
Packages/manifest.json
View File

@ -1,6 +1,5 @@
{ {
"dependencies": { "dependencies": {
"com.unity.ide.visualstudio": "2.0.22",
"com.unity.textmeshpro": "3.0.6", "com.unity.textmeshpro": "3.0.6",
"com.unity.ugui": "1.0.0", "com.unity.ugui": "1.0.0",
"com.unity.modules.ai": "1.0.0", "com.unity.modules.ai": "1.0.0",

27
Packages/packages-lock.json
View File

@ -1,32 +1,5 @@
{ {
"dependencies": { "dependencies": {
"com.unity.ext.nunit": {
"version": "1.0.6",
"depth": 2,
"source": "registry",
"dependencies": {},
"url": "https://packages.unity.com"
},
"com.unity.ide.visualstudio": {
"version": "2.0.22",
"depth": 0,
"source": "registry",
"dependencies": {
"com.unity.test-framework": "1.1.9"
},
"url": "https://packages.unity.com"
},
"com.unity.test-framework": {
"version": "1.1.33",
"depth": 1,
"source": "registry",
"dependencies": {
"com.unity.ext.nunit": "1.0.6",
"com.unity.modules.imgui": "1.0.0",
"com.unity.modules.jsonserialize": "1.0.0"
},
"url": "https://packages.unity.com"
},
"com.unity.textmeshpro": { "com.unity.textmeshpro": {
"version": "3.0.6", "version": "3.0.6",
"depth": 0, "depth": 0,

29
ProjectSettings/EditorSettings.asset
View File

@ -3,45 +3,28 @@
--- !u!159 &1 --- !u!159 &1
EditorSettings: EditorSettings:
m_ObjectHideFlags: 0 m_ObjectHideFlags: 0
serializedVersion: 12 serializedVersion: 11
m_ExternalVersionControlSupport: Visible Meta Files
m_SerializationMode: 2 m_SerializationMode: 2
m_LineEndingsForNewScripts: 0 m_LineEndingsForNewScripts: 0
m_DefaultBehaviorMode: 0 m_DefaultBehaviorMode: 0
m_PrefabRegularEnvironment: {fileID: 0} m_PrefabRegularEnvironment: {fileID: 0}
m_PrefabUIEnvironment: {fileID: 0} m_PrefabUIEnvironment: {fileID: 0}
m_SpritePackerMode: 0 m_SpritePackerMode: 0
m_SpritePackerCacheSize: 10
m_SpritePackerPaddingPower: 1 m_SpritePackerPaddingPower: 1
m_Bc7TextureCompressor: 0
m_EtcTextureCompressorBehavior: 1 m_EtcTextureCompressorBehavior: 1
m_EtcTextureFastCompressor: 1 m_EtcTextureFastCompressor: 1
m_EtcTextureNormalCompressor: 2 m_EtcTextureNormalCompressor: 2
m_EtcTextureBestCompressor: 4 m_EtcTextureBestCompressor: 4
m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmdef;rsp;asmref m_ProjectGenerationIncludedExtensions: txt;xml;fnt;cd;asmdef;rsp;asmref
m_ProjectGenerationRootNamespace: m_ProjectGenerationRootNamespace:
m_CollabEditorSettings:
inProgressEnabled: 1
m_EnableTextureStreamingInEditMode: 1 m_EnableTextureStreamingInEditMode: 1
m_EnableTextureStreamingInPlayMode: 1 m_EnableTextureStreamingInPlayMode: 1
m_EnableEditorAsyncCPUTextureLoading: 0
m_AsyncShaderCompilation: 1 m_AsyncShaderCompilation: 1
m_PrefabModeAllowAutoSave: 1 m_EnterPlayModeOptionsEnabled: 0
m_EnterPlayModeOptionsEnabled: 1
m_EnterPlayModeOptions: 3 m_EnterPlayModeOptions: 3
m_GameObjectNamingDigits: 1 m_ShowLightmapResolutionOverlay: 1
m_GameObjectNamingScheme: 0
m_AssetNamingUsesSpace: 1
m_InspectorUseIMGUIDefaultInspector: 0
m_UseLegacyProbeSampleCount: 0 m_UseLegacyProbeSampleCount: 0
m_SerializeInlineMappingsOnOneLine: 1 m_SerializeInlineMappingsOnOneLine: 1
m_DisableCookiesInLightmapper: 0
m_AssetPipelineMode: 1
m_RefreshImportMode: 0
m_CacheServerMode: 0
m_CacheServerEndpoint:
m_CacheServerNamespacePrefix: default
m_CacheServerEnableDownload: 1
m_CacheServerEnableUpload: 1
m_CacheServerEnableAuth: 0
m_CacheServerEnableTls: 0
m_CacheServerValidationMode: 2
m_CacheServerDownloadBatchSize: 128
m_EnableEnlightenBakedGI: 0

121
ProjectSettings/SceneTemplateSettings.json
View File

@ -1,121 +0,0 @@
{
"templatePinStates": [],
"dependencyTypeInfos": [
{
"userAdded": false,
"type": "UnityEngine.AnimationClip",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEditor.Animations.AnimatorController",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.AnimatorOverrideController",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEditor.Audio.AudioMixerController",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.ComputeShader",
"defaultInstantiationMode": 1
},
{
"userAdded": false,
"type": "UnityEngine.Cubemap",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.GameObject",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEditor.LightingDataAsset",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.LightingSettings",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.Material",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEditor.MonoScript",
"defaultInstantiationMode": 1
},
{
"userAdded": false,
"type": "UnityEngine.PhysicMaterial",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.PhysicsMaterial2D",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.Rendering.PostProcessing.PostProcessProfile",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.Rendering.PostProcessing.PostProcessResources",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.Rendering.VolumeProfile",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEditor.SceneAsset",
"defaultInstantiationMode": 1
},
{
"userAdded": false,
"type": "UnityEngine.Shader",
"defaultInstantiationMode": 1
},
{
"userAdded": false,
"type": "UnityEngine.ShaderVariantCollection",
"defaultInstantiationMode": 1
},
{
"userAdded": false,
"type": "UnityEngine.Texture",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.Texture2D",
"defaultInstantiationMode": 0
},
{
"userAdded": false,
"type": "UnityEngine.Timeline.TimelineAsset",
"defaultInstantiationMode": 0
}
],
"defaultDependencyTypeInfo": {
"userAdded": false,
"type": "<default_scene_template_dependencies>",
"defaultInstantiationMode": 1
},
"newSceneOverride": 0
}