public void Awake()
{
// velocityBuffer = new List<Vector3>();
if(GetComponent<Rigidbody>())
oldCollisionMode = GetComponent<Rigidbody>().collisionDetectionMode;
positionKalman = new KalmanFilter();
positionKalman.initialize(3,3);
positionKalman.skipIdenticalMeasurements = true;
}
public void saveRigidbody(Rigidbody rb)
{
mass = rb.mass;
drag = rb.drag;
angularDrag = rb.angularDrag;
useGravity = rb.useGravity;
isKinematic = rb.isKinematic;
interpolation = rb.interpolation;
collisionDetection = rb.collisionDetectionMode;
constraints = rb.constraints;
}
//#####################################################################################################
//######## pass map info to constructor #########
//#####################################################################################################
public pathFinder(Vector2 leftUpCorner, int width, int height, float offset, CollisionDetectionMode CDM)
{
CollisionMode = CDM;
NodeArray = new node[height, width];
map_leftUpCorner = leftUpCorner;
map_width = width;
map_height = height;
map_offset = offset;
CreateMap();
ResetForNewPath();
}
protected void SetCollisionMode(CollisionDetectionMode newMode, bool force = false)
{
Rigidbody[] rigidBodies = this.GetComponentsInChildren <Rigidbody>();
for (int rigidBodyIndex = 0; rigidBodyIndex < rigidBodies.Length; rigidBodyIndex++)
{
if (rigidBodies[rigidBodyIndex].isKinematic == false || force)
{
rigidBodies[rigidBodyIndex].collisionDetectionMode = newMode;
}
}
}
public SCG_RigidBodySerialized(Rigidbody rigidbody)
{
mass = rigidbody.mass;
drag = rigidbody.drag;
angDrag = rigidbody.angularDrag;
useGravity = rigidbody.useGravity;
isKinematic = rigidbody.isKinematic;
interpolate = rigidbody.interpolation;
collDetect = rigidbody.collisionDetectionMode;
constraints = rigidbody.constraints;
}
public void Awake()
{
// velocityBuffer = new List<Vector3>();
if (GetComponent <Rigidbody>())
{
oldCollisionMode = GetComponent <Rigidbody>().collisionDetectionMode;
}
positionKalman = new KalmanFilter();
positionKalman.initialize(3, 3);
positionKalman.skipIdenticalMeasurements = true;
}
// Use this for initialization
void Start()
{
rb = gameObject.GetComponent <Rigidbody>();
mass = rb.mass;
collmode = rb.collisionDetectionMode;
interpolationmode = rb.interpolation;
if (bolts.Length != 0 && boltParent != null)
{
StartCoroutine(UpdatePartTightness());
}
}
public StoredRigidbody(Rigidbody rb)
{
mass = rb.mass;
drag = rb.drag;
angularDrag = rb.angularDrag;
useGravity = rb.useGravity;
isKinematic = rb.isKinematic;
interpolation = rb.interpolation;
collisionDetectionMode = rb.collisionDetectionMode;
constraints = rb.constraints;
parent = rb.transform.parent;
}
public static GameObject AddRigidBody(this GameObject gameObject, float mass,
CollisionDetectionMode collisionDetectionMode, bool isKinematic, bool useGravity,
RigidbodyConstraints constraints)
{
var component = gameObject.GetOrAddComponent <Rigidbody>();
component.mass = mass;
component.collisionDetectionMode = collisionDetectionMode;
component.constraints = constraints;
component.isKinematic = isKinematic;
component.useGravity = useGravity;
return(gameObject);
}
public virtual void DestroyRigibody()
{
if (rigidbodyMovable == null)
{
return;
}
massRb = rigidbodyMovable.mass;
collisionDetectionModeRb = rigidbodyMovable.collisionDetectionMode;
drag = rigidbodyMovable.drag;
Destroy(rigidbodyMovable);
}
/// <summary>
///
/// </summary>
/// <param name="binaryReader"></param>
public override void Deserialize(BinaryReader binaryReader)
{
base.Deserialize(binaryReader);
mass = binaryReader.ReadSingle();
drag = binaryReader.ReadSingle();
angularDrag = binaryReader.ReadSingle();
useGravity = binaryReader.ReadBoolean();
isKinematic = binaryReader.ReadBoolean();
interpolation = (RigidbodyInterpolation)binaryReader.ReadInt32();
collisionDetectionMode = (CollisionDetectionMode)binaryReader.ReadInt32();
constraints = (RigidbodyConstraints)binaryReader.ReadInt32();
}
public void RegisterRigidBody(Rigidbody body)
{
Interpolation = body.interpolation;
UseGravity = body.useGravity;
IsKinematic = body.isKinematic;
MaxAngularVelocity = body.maxAngularVelocity;
MaxDepenetrationVelocity = body.maxDepenetrationVelocity;
AngularDrag = body.angularDrag;
Drag = body.drag;
CollisionMode = body.collisionDetectionMode;
Layer = body.gameObject.layer;
DetectCollision = body.detectCollisions;
Constraints = body.constraints;
}
internal void Draw()
{
cdMode = (CollisionDetectionMode)EditorGUILayout.EnumPopup("Collision detection:", cdMode);
rigidDrag = EditorGUILayout.FloatField("Rigid Drag:", rigidDrag);
rigidAngularDrag = EditorGUILayout.FloatField("Rigid Angular Drag:", rigidAngularDrag);
asTrigger = EditorGUILayout.Toggle("Trigger colliders:", asTrigger);
isKinematic = EditorGUILayout.Toggle("Is kinematic:", isKinematic);
useGravity = EditorGUILayout.Toggle("Use gravity:", useGravity);
createTips = EditorGUILayout.Toggle("Create tips:", createTips);
}
public void FixedUpdate()
{
if (switchToContinuousCollisionMode)
{
oldCollisionMode = GetComponent <Rigidbody>().collisionDetectionMode;
GetComponent <Rigidbody>().collisionDetectionMode = CollisionDetectionMode.Continuous;
switchToContinuousCollisionMode = false;
}
if (switchToOldCollisionMode)
{
GetComponent <Rigidbody>().collisionDetectionMode = oldCollisionMode;
switchToOldCollisionMode = false;
}
UpdateTransform(true);
transformHasBeenUpdated = true;
}
public void FixedUpdate()
{
if(switchToContinuousCollisionMode)
{
oldCollisionMode = rigidbody.collisionDetectionMode;
rigidbody.collisionDetectionMode = CollisionDetectionMode.Continuous;
switchToContinuousCollisionMode = false;
}
if(switchToOldCollisionMode)
{
rigidbody.collisionDetectionMode = oldCollisionMode;
switchToOldCollisionMode = false;
}
UpdateTransform(true);
transformHasBeenUpdated = true;
}
/// <summary>
/// コンストラクタ
/// </summary>
/// <param name="component">Rigidbodyオブジェクト</param>
public RigidbodyKun(Component component) : base(component)
{
componentKunType = ComponentKunType.Rigidbody;
var rigidbody = component as Rigidbody;
if (rigidbody)
{
mass = rigidbody.mass;
drag = rigidbody.drag;
angularDrag = rigidbody.angularDrag;
useGravity = rigidbody.useGravity;
isKinematic = rigidbody.isKinematic;
interpolation = rigidbody.interpolation;
collisionDetectionMode = rigidbody.collisionDetectionMode;
constraints = rigidbody.constraints;
}
}
public static string GetStringFromCollisionDetectionMode(CollisionDetectionMode mode)
{
switch (mode)
{
case CollisionDetectionMode.Discrete:
return(Discrete);
case CollisionDetectionMode.Continuous:
return(Continuous);
case CollisionDetectionMode.ContinuousDynamic:
return(ContinuousDynamic);
default:
return(Discrete);
}
}
void SetHeldObject(Transform transform)
{
heldObject = transform.gameObject;
heldObject.GetComponent <Rigidbody>().useGravity = false;
heldObjectLayer = heldObject.layer;
//SetLayer(transform, LayerMask.NameToLayer("Ignore Raycast"));
heldObjectMass = heldObject.GetComponent <Rigidbody>().mass;
heldObject.GetComponent <Rigidbody>().mass = 0;
heldObjectWasKinematic = heldObject.GetComponent <Rigidbody>().isKinematic;
heldObject.GetComponent <Rigidbody>().isKinematic = false;
heldObjectCollisionDetectionMode = heldObject.GetComponent <Rigidbody>().collisionDetectionMode;
heldObject.GetComponent <Rigidbody>().collisionDetectionMode = CollisionDetectionMode.ContinuousDynamic;
moveHeldObject = StartCoroutine(MoveHeldObject());
}
/// <summary>
/// Allows teleportation of gameobjects from an Origin to a ArrivalTarget. It teleports the object
/// by its root, which if unspecified is the root of the game object. Objects can be teleported
/// in reference to another gameobject, which is useful for dopplegangers
/// </summary>
/// <param name="origin">The Origin of the Portal</param>
/// <param name="destination">The ArrivalTarget of the Portal</param>
/// <param name="teleportedObject">The Object to teleport</param>
/// <param name="deepestRoot">The deepest root to teleport the object by</param>
/// <param name="reference">The transform to teleport the object in reference to</param>
public static void TeleportObject(GameObject teleportedObject, Transform origin, Transform destination, Transform deepestRoot = null, Transform reference = null, bool physics = true, bool scale = true)
{
if (!destination)
{
throw new ArgumentException();
}
Rigidbody rigidBody;
CollisionDetectionMode oldMode = CollisionDetectionMode.Discrete;
rigidBody = teleportedObject.GetComponent <Rigidbody>();
if (!deepestRoot)
{
deepestRoot = teleportedObject.transform.root;
}
if (!reference)
{
reference = deepestRoot;
}
Quaternion diffQuat = destination.rotation * (Quaternion.Inverse(origin.rotation));
Vector3 localPos = origin.InverseTransformPoint(reference.position);
deepestRoot.position = destination.TransformPoint(localPos);
deepestRoot.rotation = diffQuat * reference.rotation;
Vector3 newScale = reference.localScale;
if (scale)
{
newScale.Scale(new Vector3(1f / origin.transform.lossyScale.x, 1f / origin.transform.lossyScale.y, 1f / origin.transform.lossyScale.z));
newScale.Scale(destination.transform.lossyScale);
deepestRoot.localScale = newScale;
}
if (rigidBody)
{
rigidBody.WakeUp();
if (physics)
{
rigidBody.velocity = diffQuat * rigidBody.velocity;
rigidBody.angularVelocity = destination.TransformVector(origin.InverseTransformVector(rigidBody.angularVelocity));
}
}
}
public SCG_RigidBodySerialized(float mass,
float drag,
float angDrag,
bool useGravity,
bool isKinematic,
RigidbodyInterpolation interpolation,
CollisionDetectionMode collDetect,
RigidbodyConstraints constraints)
{
this.mass = mass;
this.drag = drag;
this.angDrag = angDrag;
this.useGravity = useGravity;
this.isKinematic = isKinematic;
this.interpolate = interpolation;
this.collDetect = collDetect;
this.constraints = constraints;
}
private void RemoveRigidbody()
{
if (r == null)
{
return;
}
_mass = r.mass;
_drag = r.drag;
_angularDrag = r.angularDrag;
_useGravity = r.useGravity;
_isKinematic = r.isKinematic;
_interpolation = r.interpolation;
_collisionDetectionMode = r.collisionDetectionMode;
_constraints = r.constraints;
Destroy(r);
}
protected virtual void Awake()
{
if (OnTouchBegin == null)
{
OnTouchBegin = new UnityEvent();
}
if (OnTouchUpdate == null)
{
OnTouchUpdate = new UnityEvent();
}
if (OnTouchEnd == null)
{
OnTouchEnd = new UnityEvent();
}
if (OnHoldBegin == null)
{
OnHoldBegin = new UnityEvent();
}
if (OnHoldUpdate == null)
{
OnHoldUpdate = new UnityEvent();
}
if (OnHoldEnd == null)
{
OnHoldEnd = new UnityEvent();
}
if (OnUseBegin == null)
{
OnUseBegin = new UnityEvent();
}
if (OnUseUpdate == null)
{
OnUseUpdate = new UnityEvent();
}
if (OnUseEnd == null)
{
OnUseEnd = new UnityEvent();
}
if (body != null)
{
originalDetectionMode = body.collisionDetectionMode;
}
}
void Awake()
{
col = GetComponent <Collider>();
rigid = GetComponent <Rigidbody>();
if (GameObject.FindGameObjectWithTag("Player"))
{
input = GameObject.FindGameObjectWithTag("Player").GetComponent <InputBridge>();
}
else
{
Debug.LogError("No InputBridge Found on Player GameObject. Make sure you have one Player with the 'Player' Tag and the InputBridge component");
}
events = GetComponents <GrabbableEvents>().ToList();
collisions = new List <Collider>();
// Try parent if no rigid found here
if (rigid == null && transform.parent != null)
{
rigid = transform.parent.GetComponent <Rigidbody>();
}
// Store initial rigidbody properties so we can reset them later as needed
if (rigid)
{
initialCollisionMode = rigid.collisionDetectionMode;
initialInterpolationMode = rigid.interpolation;
wasKinematic = rigid.isKinematic;
usedGravity = rigid.useGravity;
}
// Store initial parent so we can reset later if needed
UpdateOriginalParent(transform.parent);
validGrabbers = new List <Grabber>();
OriginalScale = transform.localScale.x;
if (GameObject.FindGameObjectWithTag("Player"))
{
player = GameObject.FindGameObjectWithTag("Player").GetComponentInChildren <BNGPlayerController>();
}
}
private IEnumerator SafelyEnableShowcase(bool hide)
{
//Debug.Log("SafelyEnableShowcase(): Waiting for everything to initialize");
yield return(new WaitWhile(() => NothingIsNull()));
isInShowcaseMode = true;
previousDetectionMode = rb.collisionDetectionMode; //Only doing this to hide warnings in the inspector
rb.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative; //Only doing this to hide warnings in the inspector
rb.isKinematic = true;
playerMovement.enabled = false;
audioSource.enabled = false;
prefabGameObject = visualsPrefab.GetPrefab();
prefabGameObject.GetComponent <TrailRenderer>().enabled = false;
prefabGameObject.GetComponent <Light>().enabled = false;
if (hide)
{
prefabGameObject.GetComponentInChildren <MeshRenderer>().enabled = false;
}
directionSphere.GetPrefab().SetActive(false);
}
public void ResetRigidbodyVariables()
{
//reset rigidbody variables
Mass = 1f;
Drag = 0f;
AngularDrag = 0.05f;
UseGravity = true;
IsKinematic = false;
Interpolation = RigidbodyInterpolation.None;
CollisionDetection = CollisionDetectionMode.Discrete;
FreezePositionX = false;
FreezePositionY = false;
FreezePositionZ = false;
FreezeRotationX = false;
FreezeRotationY = false;
FreezeRotationZ = false;
//apply changes
SetRigidbodyVariables();
}
override public void OnStateEnter(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
rb = animator.GetComponent <Rigidbody>();
if (SetKinematic == OnEnterOnExit.OnEnter)
{
if (isKinematic == true)
{
current = rb.collisionDetectionMode;
rb.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
}
rb.isKinematic = isKinematic;
}
else if (SetKinematic == OnEnterOnExit.OnEnterOnExit)
{
current = rb.collisionDetectionMode;
rb.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
rb.isKinematic = true;
}
}
public void TeleportTo(Vector3 position, Quaternion rotation)
{
if (isRoot)
{
transform.position = position;
}
SetRotation(rotation);
/*
* immediately update physics position...
* transform set wasnt updating fast enough for physics detection of the ragdoll
* through raycasts/collisions
*/
if (rigidbody != null)
{
CollisionDetectionMode originalDetectionMode = rigidbody.collisionDetectionMode;
bool rbWasKinematic = rigidbody.isKinematic;
if (!rbWasKinematic)
{
//need to set the collision detection mode as discrete to set kinematic and
//teleport rigidbody (or unity throws an error)
rigidbody.collisionDetectionMode = CollisionDetectionMode.Discrete;
rigidbody.isKinematic = true;
}
rigidbody.MovePosition(transform.position);
rigidbody.MoveRotation(transform.rotation);
if (!rbWasKinematic)
{
rigidbody.isKinematic = false;
rigidbody.collisionDetectionMode = originalDetectionMode;
}
}
}
override public void OnStateExit(Animator animator, AnimatorStateInfo stateInfo, int layerIndex)
{
if (SetKinematic == OnEnterOnExit.OnExit)
{
if (isKinematic == true)
{
current = rb.collisionDetectionMode;
rb.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative;
}
else
{
rb.collisionDetectionMode = current;
}
rb.isKinematic = isKinematic;
}
else if (SetKinematic == OnEnterOnExit.OnEnterOnExit)
{
rb.isKinematic = false;
rb.collisionDetectionMode = current;
}
}
// リセット時
private void Reset()
{
this.Radius = 1.0f;
this.Mass = 1.0f;
this.Drag = 0.0f;
this.AngularDrag = 0.05f;
this.GravityScale = 1.0f;
this.AxesAngle = 0.0f;
this.MainSpring.Frequency = 0.0f;
this.MainSpring.DampingRatio = 0.0f;
this.SubSpring.Frequency = 0.0f;
this.SubSpring.DampingRatio = 0.0f;
this.MainLowAngularLimit = -180.0f;
this.MainHighAngularLimit = +180.0f;
this.SubAngularLimit = 180.0f;
this.LimitBounciness = 0.0f;
this.Material = null;
this.DetectCollisions = true;
this.CollisionDetectionMode = CollisionDetectionMode.Discrete;
Invalidate();
}
public void SetKinematic(bool kinematic)
{
if (rigidbody == null)
{
return;
}
if (kinematic)
{
collisionDetectionModeBeforeKinematic = rigidbody.collisionDetectionMode;
//need to set the collision detection mode as discrete to set kinematic and
//teleport rigidbody (or unity throws an error)
rigidbody.collisionDetectionMode = CollisionDetectionMode.Discrete;
rigidbody.isKinematic = true;
}
else
{
rigidbody.isKinematic = false;
rigidbody.collisionDetectionMode = collisionDetectionModeBeforeKinematic;
}
}
public static bool SetDefaultRigidBody(GameObject gameObj, CollisionDetectionMode collisionDetectionMode = CollisionDetectionMode.Discrete,
float mass = 1f, float drag = 0f, float angularDrag = 0.05f, bool detectCollisions = true)
{
if (gameObj == null)
{
return(false);
}
Rigidbody rigidBody = gameObj.GetComponent <Rigidbody>();
if (rigidBody == null)
{
rigidBody = gameObj.AddComponent <Rigidbody>();
}
rigidBody.velocity = Vector3.zero;
rigidBody.angularVelocity = Vector3.zero;
rigidBody.drag = drag;
rigidBody.angularDrag = angularDrag;
rigidBody.mass = mass;
rigidBody.useGravity = true;
rigidBody.isKinematic = true;
rigidBody.freezeRotation = false;
rigidBody.constraints = RigidbodyConstraints.None;
rigidBody.collisionDetectionMode = collisionDetectionMode;
rigidBody.centerOfMass = Vector3.zero;
rigidBody.inertiaTensorRotation = Quaternion.identity;
rigidBody.inertiaTensor = Vector3.one;
rigidBody.detectCollisions = detectCollisions;
rigidBody.position = Vector3.zero;
rigidBody.rotation = Quaternion.identity;
rigidBody.interpolation = RigidbodyInterpolation.None;
rigidBody.solverIterations = 6;
rigidBody.sleepThreshold = 0.005f;
rigidBody.maxAngularVelocity = 7f;
rigidBody.solverVelocityIterations = 1;
rigidBody.hideFlags = HideFlags.None;
return(true);
}
private void CopyRigidbodySettings()
{
Rigidbody oldRb = gameObject.GetComponent <Rigidbody>();
if (oldRb == null)
{
return;
}
t_velocity = oldRb.velocity;
t_angularVelocity = oldRb.angularVelocity;
t_drag = oldRb.drag;
t_angularDrag = oldRb.angularDrag;
t_mass = oldRb.mass;
t_useGravity = oldRb.useGravity;
t_isKinematic = oldRb.isKinematic;
t_freezeRotation = oldRb.freezeRotation;
t_constraints = oldRb.constraints;
t_collisionDetectionMod = oldRb.collisionDetectionMode;
t_centerOfMass = oldRb.centerOfMass;
t_inertiaTensorRotation = oldRb.inertiaTensorRotation;
t_inertiaTensor = oldRb.inertiaTensor;
t_detectCollisions = oldRb.detectCollisions;
t_useConeFriction = oldRb.useConeFriction;
t_position = oldRb.position;
t_rotation = oldRb.rotation;
t_interpolation = oldRb.interpolation;
t_solverIterationCount = oldRb.solverIterationCount;
#if UNITY_5
t_sleepThreshold = oldRb.sleepThreshold;
#else
t_sleepVelocity = oldRb.sleepVelocity;
t_sleepAngularVelocity = oldRb.sleepAngularVelocity;
#endif
t_maxAngularVelocity = oldRb.maxAngularVelocity;
}
public void Awake()
{
velocityBuffer = new List<Vector3>();
if(rigidbody)
oldCollisionMode = rigidbody.collisionDetectionMode;
}
private static void AddRigidBodies(GameObject sGameObject, string gameObjectName,
float rbMass, float rbDrag, float rbAngularDrag, bool rbUseGravity,
bool rbIsKinematic, RigidbodyInterpolation rbInterpolation,
CollisionDetectionMode rbCollisionDetectionMode)
{
if (sGameObject.name == gameObjectName)
{
var rigidBody = sGameObject.AddComponent<Rigidbody>();
rigidBody.isKinematic = rbIsKinematic;
rigidBody.useGravity = rbUseGravity;
rigidBody.mass = rbMass;
rigidBody.drag = rbDrag;
rigidBody.angularDrag = rbAngularDrag;
rigidBody.interpolation = rbInterpolation;
rigidBody.collisionDetectionMode = rbCollisionDetectionMode;
}
foreach (Transform childTransform in sGameObject.transform)
{
AddRigidBodies(childTransform.gameObject, gameObjectName, rbMass, rbDrag, rbAngularDrag, rbUseGravity,
rbIsKinematic, rbInterpolation, rbCollisionDetectionMode);
}
}
public void ResetRigidbodyVariables()
{
//reset rigidbody variables
Mass=1f;
Drag=0f;
AngularDrag=0.05f;
UseGravity=true;
IsKinematic=false;
Interpolation = RigidbodyInterpolation.None;
CollisionDetection = CollisionDetectionMode.Discrete;
FreezePositionX=false;
FreezePositionY=false;
FreezePositionZ=false;
FreezeRotationX=false;
FreezeRotationY=false;
FreezeRotationZ=false;
//apply changes
SetRigidbodyVariables();
}
public RigidbodySettings(Rigidbody rigidbody)
{
_rigidbody = rigidbody;
_isKinematic = rigidbody.isKinematic;
_velocity = rigidbody.velocity;
_angularVelocity = rigidbody.angularVelocity;
_mass = rigidbody.mass;
_drag = rigidbody.drag;
_angularDrag = rigidbody.angularDrag;
_useGravity = rigidbody.useGravity;
_interpolate = rigidbody.interpolation;
_collisionDetection = rigidbody.collisionDetectionMode;
_constraints = rigidbody.constraints;
}
private void CopyRigidbodySettings()
{
Rigidbody oldRb = gameObject.GetComponent<Rigidbody>();
if(oldRb == null) return;
t_velocity = oldRb.velocity;
t_angularVelocity = oldRb.angularVelocity;
t_drag = oldRb.drag;
t_angularDrag = oldRb.angularDrag;
t_mass = oldRb.mass;
t_useGravity = oldRb.useGravity;
t_isKinematic = oldRb.isKinematic;
t_freezeRotation = oldRb.freezeRotation;
t_constraints = oldRb.constraints;
t_collisionDetectionMod = oldRb.collisionDetectionMode;
t_centerOfMass = oldRb.centerOfMass;
t_inertiaTensorRotation = oldRb.inertiaTensorRotation;
t_inertiaTensor = oldRb.inertiaTensor;
t_detectCollisions = oldRb.detectCollisions;
t_useConeFriction = oldRb.useConeFriction;
t_position = oldRb.position;
t_rotation = oldRb.rotation;
t_interpolation = oldRb.interpolation;
t_solverIterationCount = oldRb.solverIterationCount;
#if UNITY_5
t_sleepThreshold = oldRb.sleepThreshold;
#else
t_sleepVelocity = oldRb.sleepVelocity;
t_sleepAngularVelocity = oldRb.sleepAngularVelocity;
#endif
t_maxAngularVelocity = oldRb.maxAngularVelocity;
}
