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; }