|
private GetGroundHit ( |
||
| hit | ||
| Résultat | bool | |
// Update is called once per frame
void FixedUpdate()
{
WheelL = GameObject.Find("WheelFL").GetComponent<WheelCollider>();
WheelR = GameObject.Find("WheelFR").GetComponent<WheelCollider>();
WheelHit hit;
float travelL = 1.0f;
float travelR = 1.0f;
bool GroundedL = WheelL.GetGroundHit(out hit);
if (GroundedL)
{
travelL = (-WheelL.transform.InverseTransformPoint(hit.point).y - WheelL.radius) / WheelL.suspensionDistance;
}
bool GroundedR = WheelR.GetGroundHit(out hit);
if (GroundedR)
{
travelR = (-WheelR.transform.InverseTransformPoint(hit.point).y - WheelR.radius) / WheelR.suspensionDistance;
}
float antiRollForce = (travelL - travelR) * antiRoll;
if (GroundedL)
{
rb.AddForceAtPosition(WheelL.transform.up * -antiRollForce, WheelL.transform.position);
}
if (GroundedR)
{
rb.AddForceAtPosition(WheelR.transform.up * antiRollForce, WheelR.transform.position);
}
}
public VehicleWheel( WheelCollider vehicleWheel,
WheelComponent wheelComponent,
WheelPosition frontRear,
WheelPosition leftRight )
{
wheelFrontRear = frontRear;
wheelLeftRight = leftRight;
checkCurrentWheelState = WheelsOnGround.WHEEL_ON_GROUND;
mainWheelCollider = vehicleWheel;
wheelPhysicsComponent = wheelComponent;
visualWheel = vehicleWheel.GetComponentInChildren<MeshRenderer>( ).transform;
wheelRadius = ( visualWheel.GetComponent<Renderer>().bounds.size.y / 2 );
mainWheelCollider.radius = wheelRadius;
mainWheelCollider.GetGroundHit( out wheelGroundContactPoint );
}
private void AntiRoll(WheelCollider leftWheel, WheelCollider rightWheel)
{
var AntiRoll = 5000f;
WheelHit hit;
var travelL = 1.0f;
var travelR = 1.0f;
var groundedL = leftWheel.GetGroundHit(out hit);
if (groundedL)
travelL = (-leftWheel.transform.InverseTransformPoint(hit.point).y - leftWheel.radius) / leftWheel.suspensionDistance;
var groundedR = rightWheel.GetGroundHit(out hit);
if (groundedR)
travelR = (-rightWheel.transform.InverseTransformPoint(hit.point).y - rightWheel.radius) / rightWheel.suspensionDistance;
var antiRollForce = (travelL - travelR) * AntiRoll;
if (groundedL)
rBody.AddForceAtPosition(leftWheel.transform.up * -antiRollForce, leftWheel.transform.position);
if (groundedR)
rBody.AddForceAtPosition(rightWheel.transform.up * antiRollForce, rightWheel.transform.position);
}
static public int GetGroundHit(IntPtr l)
{
try {
#if DEBUG
var method = System.Reflection.MethodBase.GetCurrentMethod();
string methodName = GetMethodName(method);
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.BeginSample(methodName);
#else
Profiler.BeginSample(methodName);
#endif
#endif
UnityEngine.WheelCollider self = (UnityEngine.WheelCollider)checkSelf(l);
UnityEngine.WheelHit a1;
var ret = self.GetGroundHit(out a1);
pushValue(l, true);
pushValue(l, ret);
pushValue(l, a1);
return(3);
}
catch (Exception e) {
return(error(l, e));
}
#if DEBUG
finally {
#if UNITY_5_5_OR_NEWER
UnityEngine.Profiling.Profiler.EndSample();
#else
Profiler.EndSample();
#endif
}
#endif
}
static public int GetGroundHit(IntPtr l)
{
try {
UnityEngine.WheelCollider self = (UnityEngine.WheelCollider)checkSelf(l);
UnityEngine.WheelHit a1;
var ret = self.GetGroundHit(out a1);
pushValue(l, true);
pushValue(l, ret);
pushValue(l, a1);
return(3);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int GetGroundHit(IntPtr l)
{
try {
UnityEngine.WheelCollider self = (UnityEngine.WheelCollider)checkSelf(l);
UnityEngine.WheelHit a1;
var ret = self.GetGroundHit(out a1);
pushValue(l, ret);
pushValue(l, a1);
return(2);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
private Vector3 CalculateWheelPosition(Transform w,WheelCollider col,Vector3 startPos)
{
//18
WheelHit hit; Vector3 lp = w.localPosition;
if (col.GetGroundHit(out hit))
{
lp.y -= Vector3.Dot(w.position - hit.point, transform.up) - wheelRadius;
}
else
{ lp.y = startPos.y - suspensionOffset; }
return lp;
}
void DoRollBar(WheelCollider wheelL, WheelCollider wheelR)
{
WheelHit hit;
float travelL = 1.0f;
float travelR = 1.0f;
bool groundedL = wheelL.GetGroundHit(out hit);
if (groundedL)
{
travelL = (-wheelL.transform.InverseTransformPoint(hit.point).y - wheelL.radius) / wheelL.suspensionDistance;
}
bool groundedR = wheelR.GetGroundHit(out hit);
if (groundedR)
{
travelR = (-wheelR.transform.InverseTransformPoint(hit.point).y - wheelR.radius) / wheelR.suspensionDistance;
}
float antiRollForce = (travelL - travelR) * antiRoll;
if (groundedL)
{
rb.AddForceAtPosition(wheelL.transform.up * -antiRollForce, wheelL.transform.position);
}
if (groundedR)
{
rb.AddForceAtPosition(wheelR.transform.up * antiRollForce, wheelR.transform.position);
}
}
public void ApplyBrakeTorque(WheelCollider wc, float brake){
if(ABS && handbrakeInput <= .1f){
WheelHit hit;
wc.GetGroundHit(out hit);
if((Mathf.Abs(hit.forwardSlip) * brakeInput) >= ABSThreshold){
ABSAct = true;
brake = 0;
}else{
ABSAct = false;
}
}
wc.brakeTorque = brake;
}
public void ESPCheck(WheelCollider slippingLeftWheel, WheelCollider slippingRightWheel, WheelCollider correspondingWheel){
WheelHit leftHit;
slippingLeftWheel.GetGroundHit(out leftHit);
WheelHit rightHit;
slippingRightWheel.GetGroundHit(out rightHit);
float totalSlip = Mathf.Abs(leftHit.sidewaysSlip) + Mathf.Abs(rightHit.sidewaysSlip);
if(totalSlip > ESPThreshold){
ESPAct = true;
ApplyBrakeTorque(correspondingWheel, (brake * ESPStrength) * totalSlip);
}else{
ESPAct = false;
}
}
public void ApplyMotorTorque(WheelCollider wc, float torque){
if(TCS){
WheelHit hit;
wc.GetGroundHit(out hit);
if(Mathf.Abs(wc.rpm) >= 100){
if(hit.forwardSlip > .25f){
TCSAct = true;
torque -= Mathf.Clamp(torque * (hit.forwardSlip) * TCSStrength, 0f, engineTorque);
}else{
TCSAct = false;
torque += Mathf.Clamp(torque * (hit.forwardSlip) * TCSStrength, -engineTorque, 0f);
}
}else{
TCSAct = false;
}
}
if(OverTorque())
torque = 0;
if(automaticGear){
if(!reverseGear)
wc.motorTorque = (torque * (1 - clutchInput)) * (Mathf.Clamp((gasInput * fuelInput), 0f, 1f) * boostInput) * engineTorqueCurve[currentGear].Evaluate(wheelRPMToSpeed);
else
wc.motorTorque = (-torque * (1 - clutchInput)) * (Mathf.Clamp((brakeInput * fuelInput), 0f, 1f) * boostInput) * engineTorqueCurve[currentGear].Evaluate(wheelRPMToSpeed);
}else{
if(!reverseGear)
wc.motorTorque = (torque * (1 - clutchInput)) * (Mathf.Clamp((gasInput * fuelInput), 0f, 1f) * boostInput) * engineTorqueCurve[currentGear].Evaluate(wheelRPMToSpeed);
else
wc.motorTorque = (-torque * (1 - clutchInput)) * (Mathf.Clamp((gasInput * fuelInput), 0f, 1f) * boostInput) * engineTorqueCurve[currentGear].Evaluate(wheelRPMToSpeed);
}
ApplyEngineSound(wc.motorTorque);
}
public void WheelCamber (WheelCollider wc){
WheelHit CorrespondingGroundHit;
Vector3 wheelLocalEuler;
wc.GetGroundHit(out CorrespondingGroundHit);
float handling = Mathf.Lerp (-2f, 2f, CorrespondingGroundHit.force / 7500f);
if(wc.transform.localPosition.x < 0)
wheelLocalEuler = new Vector3(wc.transform.localEulerAngles.x, wc.transform.localEulerAngles.y, (-handling));
else
wheelLocalEuler = new Vector3(wc.transform.localEulerAngles.x, wc.transform.localEulerAngles.y, (handling));
Quaternion wheelCamber = Quaternion.Euler(wheelLocalEuler);
wc.transform.localRotation = wheelCamber;
}
public void WheelAlign (WheelCollider wc, Transform wm, float rotation){
RaycastHit hit;
WheelHit CorrespondingGroundHit;
Vector3 ColliderCenterPoint = wc.transform.TransformPoint(wc.center);
wc.GetGroundHit(out CorrespondingGroundHit);
if(Physics.Raycast(ColliderCenterPoint, -wc.transform.up, out hit, (wc.suspensionDistance + wc.radius) * transform.localScale.y) && !hit.collider.isTrigger && hit.transform.root != transform){
wm.transform.position = hit.point + (wc.transform.up * wc.radius) * transform.localScale.y;
float extension = (-wc.transform.InverseTransformPoint(CorrespondingGroundHit.point).y - wc.radius) / wc.suspensionDistance;
Debug.DrawLine(CorrespondingGroundHit.point, CorrespondingGroundHit.point + wc.transform.up * (CorrespondingGroundHit.force / rigid.mass), extension <= 0.0 ? Color.magenta : Color.white);
Debug.DrawLine(CorrespondingGroundHit.point, CorrespondingGroundHit.point - wc.transform.forward * CorrespondingGroundHit.forwardSlip * 2f, Color.green);
Debug.DrawLine(CorrespondingGroundHit.point, CorrespondingGroundHit.point - wc.transform.right * CorrespondingGroundHit.sidewaysSlip * 2f, Color.red);
}else{
wm.transform.position = ColliderCenterPoint - (wc.transform.up * wc.suspensionDistance) * transform.localScale.y;
}
rotation += wc.rpm * 6 * Time.deltaTime;
wm.transform.rotation = wc.transform.rotation * Quaternion.Euler(rotation, wc.steerAngle, wc.transform.rotation.z);
}
// Use this for initialization
private Vector3 CalculateWheelOrBonePosition(Transform w,WheelCollider col,Vector3 startPos, bool isWheel)
{
WheelHit hit;
Vector3 lp = w.localPosition;
if (col.GetGroundHit(out hit)) {
lp[wheelsAndBonesAxisSettings.WPAxisPointer] -= Vector3.Dot(w.position - hit.point, transform.up);
if(isWheel){
lp[wheelsAndBonesAxisSettings.WPAxisPointer] += wheelsOffset;
if(wheelsAndBonesAxisSettings.inverseWheelsPosition)
lp[wheelsAndBonesAxisSettings.WPAxisPointer] *=-1.0f;
}else{
lp[wheelsAndBonesAxisSettings.BPAxisPointer] += bonesOffset;
if(wheelsAndBonesAxisSettings.inverseBonesPosition)
lp[wheelsAndBonesAxisSettings.BPAxisPointer] *=-1.0f;
}
}else {
if(isWheel){
lp[wheelsAndBonesAxisSettings.WPAxisPointer] = startPos[wheelsAndBonesAxisSettings.WPAxisPointer] - noGroundedColOffset;
if(wheelsAndBonesAxisSettings.inverseWheelsPosition)
lp[wheelsAndBonesAxisSettings.WPAxisPointer] *=-1.0f;
}else{
lp[wheelsAndBonesAxisSettings.BPAxisPointer] = startPos[wheelsAndBonesAxisSettings.BPAxisPointer] - noGroundedColOffset;
if(wheelsAndBonesAxisSettings.inverseBonesPosition)
lp[wheelsAndBonesAxisSettings.BPAxisPointer] *=-1.0f;
}
}
return lp;
}
private void antiRoll(WheelCollider _colliderLeft, WheelCollider _colliderRight, float _antiRollValue)
{
WheelHit wHit;
float travelL = 1.0f;
float travelR = 1.0f;
bool groundedL = _colliderLeft.GetGroundHit(out wHit);
if (groundedL)
{
travelL = (-_colliderLeft.transform.InverseTransformPoint(wHit.point).y - _colliderLeft.radius) /_colliderLeft.suspensionDistance;
}
bool groundedR = _colliderRight.GetGroundHit(out wHit);
if (groundedR)
{
travelR = (-_colliderRight.transform.InverseTransformPoint(wHit.point).y - _colliderRight.radius)/_colliderRight.suspensionDistance;
}
float antirollForce = (travelL - travelR) * _antiRollValue;
if (groundedL) rb.AddForceAtPosition(_colliderLeft.transform.up * -antirollForce, _colliderLeft.transform.position);
if (groundedR) rb.AddForceAtPosition(_colliderRight.transform.up * antirollForce, _colliderRight.transform.position);
}
public void ApplyMotorTorque(WheelCollider wc, float torque, bool leftSide){
if(speed > maxspeed || Mathf.Abs(FrontLeftWheelCollider.rpm) > 3000 || Mathf.Abs(RearLeftWheelCollider.rpm) > 3000 || !engineRunning)
torque = 0;
if(reversing && speed > 55)
torque = 0;
if(!engineRunning)
torque = 0;
if(ASR){
WheelHit hit;
wc.GetGroundHit(out hit);
if(Mathf.Abs(hit.forwardSlip) > .35f)
torque = 0;
}
if(!reversing){
if(leftSide)
wc.motorTorque = (torque * (1 - clutchInput)) * (Mathf.Clamp((gasInput * fuelInput) * differentialRatioLeft, 0f, 1f) * boostInput) * engineTorqueCurve[currentGear].Evaluate(speed);
else
wc.motorTorque = (torque * (1 - clutchInput)) * (Mathf.Clamp((gasInput * fuelInput) * differentialRatioRight, 0f, 1f) * boostInput) * engineTorqueCurve[currentGear].Evaluate(speed);
}else{
wc.motorTorque = (-torque * (1 - clutchInput)) * brakeInput;
}
}
public void ApplyBrakeTorque(WheelCollider wc, float brake){
if(ABS && handbrakeInput < .1f){
WheelHit hit;
wc.GetGroundHit(out hit);
if(Mathf.Abs(hit.forwardSlip) > .35f)
brake = 0;
}
wc.brakeTorque = brake;
}
