} //centerLine of PlayerCar in PCH
public void DrawCenterLine(GameObject car, float carTf, CurvySpline curvySpline, Texture2D lineRendererTxt)
{
Vector3 heading = curvySpline.Interpolate(0) - car.transform.position;
float increaseAmount = 1f / (curvySpline.Length * SPLINE_GIZMO_SMOOTHNESS);
if (Vector3.Dot(heading, car.transform.forward) > 0) //starting point is in front of me
{
for (float i = carTf; i > 0; i -= increaseAmount)
{
Vector3 pos = curvySpline.Interpolate(i);
CenterPoints.Add(pos);
}
}
else //starting point is behind me
{
for (float i = carTf; i < 1; i += increaseAmount)
{
Vector3 pos = curvySpline.Interpolate(i);
CenterPoints.Add(pos);
}
}
lineRenderer2.positionCount = CenterPoints.Count;
lineRenderer2.SetPositions(CenterPoints.ToArray());
lineRenderer2.colorGradient = MakeLineRendererGradient(centerLineColor);
lineRenderer2.material.SetColor("_Color", CenterLineColor); //set tint color of lineRenderer
Texture2D txt = UpdateParams(centerLineColor, lineRendererTxt);
lineRenderer2.material.SetTexture("_MainTex", txt);
CenterPoints.Clear();
} //centerLine of PlayerCar in SF
void InitPosAndRot()
{
if (!Spline)
{
return;
}
if (Spline.Interpolate(InitialF) != mTransform.position)
{
mTransform.position = Spline.Interpolate(InitialF);
}
// Rotate the transform to match the spline's orientation?
if (SetOrientation && mTransform.rotation != Spline.GetOrientationFast(InitialF))
{
mTransform.rotation = Spline.GetOrientationFast(InitialF);
}
}
void DoInterpolate()
{
if (!mSpline.IsInitialized)
{
return;
}
GameObject go = Fsm.GetOwnerDefaultTarget(GameObject);
if (go)
{
float tf = (PositionMode == CurvyPositionMode.Relative) ? CurvyUtility.ClampTF(Position.Value, Clamping) : mSpline.DistanceToTF(Position.Value, Clamping);
Vector3 p = (UseCache.Value) ? mSpline.InterpolateFast(tf) : mSpline.Interpolate(tf);
if (Space == Space.Self)
{
go.transform.localPosition = p;
if (SetOrientation)
{
go.transform.localRotation = mSpline.GetOrientationFast(tf);
}
}
else
{
go.transform.position = mSpline.transform.TransformPoint(p);
if (SetOrientation)
{
go.transform.rotation = mSpline.transform.rotation * mSpline.GetOrientationFast(tf);
}
}
}
}
// Use this for initialization
IEnumerator Start()
{
if (Spline && Cube)
{
while (!Spline.IsInitialized)
{
yield return(null);
}
cubes = new Transform[Amount];
tf = new float[Amount];
dir = new int[Amount];
cubes[0] = Cube;
tf[0] = 0;
dir[0] = (Speed >= 0) ? 1 : -1;
// Scale Cube depending on Spline length and number of cubes
float sc = Spline.Length / Amount;
Cube.localScale = new Vector3(sc * 0.7f, sc * 0.7f, sc * 0.7f);
// Create and position cubes
Cube.position = Spline.InterpolateByDistance(0);
for (int i = 1; i < Amount; i++)
{
{
tf[i] = Spline.DistanceToTF(i * sc);
cubes[i] = getCube();
cubes[i].position = Spline.Interpolate(tf[i]);
cubes[i].rotation = Spline.GetOrientationFast(tf[i]);
dir[i] = (Speed >= 0) ? 1 : -1;
}
}
Speed = Mathf.Abs(Speed);
}
}
public void UpdateATL(CurvySpline spline)
{
t = spline.GetNearestPointTF(transform.position);
Vector3 splineAtT = spline.Interpolate(t);
if (transform.position.y < splineAtT.y)
{
lastPos = splineAtT;
Camera.main.GetComponent <CameraController_three> ().falling = true;
//SceneManager.LoadScene ("three");
StartCoroutine(Fall(5.0f, spline)); //pass in length of fall
}
else
{
Camera.main.GetComponent <CameraController_three> ().falling = false;
}
if (!m_Jump)
{
m_Jump = Input.GetButtonDown("Jump");
}
//disabling jump
m_Jump = false;
}
/// <summary>
/// Gets the interpolated position for a certain group TF
/// </summary>
/// <remarks>TF (Total Fragment) relates to the total length of the group</remarks>
/// <param name="tf">TF value identifying position in the group (0..1)</param>
/// <returns>the interpolated position</returns>
public override Vector3 Interpolate(float tf)
{
float localTF;
CurvySpline spl = TFToSpline(tf, out localTF);
return(spl.Interpolate(localTF));
}
void FixedUpdate()
{
if (Spline)
{
var v = Input.GetAxis("Vertical") * VSpeed;
var h = Input.GetAxis("Horizontal") * HSpeed;
Vector3 p;
// get nearest TF and point on spline
mTF = Spline.GetNearestPointTF(transform.localPosition, out p);
// apply forward thrust along spline direction (tangent)
if (v != 0)
{
mRigidBody.AddForce(Spline.GetTangentFast(mTF) * v, ForceMode.Force);
}
// apply side thrust to left/right from the spline's "forward" vector
if (h != 0)
{
Vector3 offset = Spline.GetExtrusionPointFast(mTF, 1, 90);
Vector3 hdir = p - offset;
mRigidBody.AddForce(hdir * h, ForceMode.Force);
}
if (Input.GetKeyDown(KeyCode.Space))
{
mRigidBody.AddForce(Vector3.up * JumpForce, ForceMode.Impulse);
}
// continously drag toward the spline to add some magic gravity
mRigidBody.AddForce((Spline.Interpolate(mTF) - transform.localPosition) * CenterDrag, ForceMode.VelocityChange);
}
}
// Update is called once per frame
public void UpdateATL(SplineLord_one splineLord_one, BookController bookController)
{
//print (Input.mouseScrollDelta.y);
speed = -Input.mouseScrollDelta.y * _sensitivity;
transform.position -= transform.up * _offset.y;
_jumpTimer = Mathf.Clamp01(_jumpTimer - Time.deltaTime);
if (Input.GetKeyDown(KeyCode.Space) && _jumpTimer <= 0.0f) //getkeydown only true first frame down, getkeyup true first frame released, getkey is true if down and false if up
{
_jumpTimer = 1.0f;
}
_offset = new Vector3(0.0f, Mathf.Sin(AxKEasing.EaseOutQuad(0.0f, 1.0f, 1.0f - _jumpTimer) * Mathf.PI), 0.0f);
CurvySpline curSpline = splineLord_one.GetSpline();
//this way gets nearest point on spline to current position
t = curSpline.GetNearestPointTF(transform.position);
t += (speed / curSpline.Length) * Time.deltaTime * 5.0f;
transform.position = curSpline.Interpolate(t);
//Vector3 sForward = curSpline.GetTangentToSpline( t );
//Vector3 sNormal = curSpline.GetOrientationOnSpline (t);
//Quaternion lookRotation = Quaternion.LookRotation (sForward, sNormal);
transform.rotation = Quaternion.Slerp(transform.rotation, curSpline.GetOrientationFast(t), Time.deltaTime * 5.0f);
transform.position += transform.up * _offset.y; //places player over spline
int indexOffset = 4;
Vector3 v1 = curSpline.ControlPoints [0 + indexOffset].transform.position - curSpline.ControlPoints [1 + indexOffset].transform.position;
Vector3 v2 = transform.position - curSpline.ControlPoints [1 + indexOffset].transform.position;
float dot = Vector3.Dot(v1, v2);
//print ( (Time.timeSinceLevelLoad % 2.0f).ToString( "F7" ) + " " + ( Time.timeSinceLevelLoad ).ToString( "F5" ) + " " + ( Time.timeSinceLevelLoad / 2.0f ).ToString( "F6") );
if (Time.timeSinceLevelLoad % 2.0f <= 0.1f) // dot < -.2)
{
//splineLord.CreateControlPoint ();
}
if (t > .5)
{
//SplineLord.GenerateSpline(curSpline);
}
/*
* if (t > .5)
* {
* splineLord.RegisterSpline() (next: get end pt from data stream)
* delete last spline
* }
*/
}
IEnumerator CameraFollowPathCoroutine(CurvySpline path, float duration, AnimationCurve cameraEvolutionOnPathCurve, Transform lookAtObjectStart, Transform lookAtObjectEnd, GameObject objectToDisplayText, string localisationKey, GameObject animationToPlay, string nameAnimationToPlay)
{
float elapsedTime = 0;
if (textToErase != null && textToErase.GetComponent <CutScenesText3D>() != null)
{
textToErase.GetComponent <CutScenesText3D>().MessageToErase();
}
textToErase = objectToDisplayText;
if (objectToDisplayText != null && objectToDisplayText.GetComponent <CutScenesText3D>() != null)
{
objectToDisplayText.GetComponent <CutScenesText3D>().MessageToDisplay(localisationKey);
}
if (animationToPlay != null && animationToPlay.GetComponent <Animation>())
{
animationToPlay.GetComponent <Animation>().Play(nameAnimationToPlay);
}
while (elapsedTime < duration)
{
float k = elapsedTime / duration;
float abstractK = Mathf.Clamp01(cameraEvolutionOnPathCurve.Evaluate(k));
cutsceneCamera.transform.position = path.Interpolate(abstractK);
cutsceneCamera.transform.LookAt(Vector3.Lerp(lookAtObjectStart.position, lookAtObjectEnd.position, abstractK));
/*if (GameManager.instance.currentState != GameManager.STATE.PAUSE) {
* elapsedTime += Time.deltaTime;
* }*
*/
yield return(null);
}
cutsceneCamera.transform.position = path.Interpolate(1);
cutsceneCamera.transform.LookAt(lookAtObjectEnd.position);
}
/// <summary>
/// Builds a mesh from a spline (2D), taking interpolated points based on curvation angle
/// </summary>
/// <param name="spline">the spline to use</param>
/// <param name="ignoreAxis">the axis to ignore (0=x,1=y,2=z)</param>
/// <param name="close">True to create a mesh with triangles, False to create a vertex line mesh</param>
/// <param name="angleDiff">the curvation angle used to interpolate points</param>
public static Mesh CreateSplineMesh(CurvySpline spline, int ignoreAxis, bool close, float angleDiff)
{
float tf = 0;
int dir = 1;
List <Vector3> verts = new List <Vector3>();
verts.Add(spline.Transform.worldToLocalMatrix.MultiplyPoint3x4(spline.Interpolate(0)));
while (tf < 1)
{
verts.Add(spline.Transform.worldToLocalMatrix.MultiplyPoint3x4(spline.MoveByAngle(ref tf, ref dir, angleDiff, CurvyClamping.Clamp, 0.005f)));
}
return(buildSplineMesh(verts.ToArray(), ignoreAxis, !close));
}
void InitPosAndRot()
{
if (!Spline)
{
return;
}
float tf = Spline.DistanceToTF(InitialDistance);
mTransform.position = Spline.Interpolate(tf);
if (SetOrientation)
{
mTransform.rotation = Spline.GetOrientationFast(tf);
}
}
} //NavigationLine of PlayerCar and TrafficCar in SF
public void DrawCenterLine(float carTf, PlayerCarLines.Lane lane, CurvySpline curvySpline, Texture2D lineRendererTxt)
{
float increaseAmount = 1f / (curvySpline.Length * SPLINE_GIZMO_SMOOTHNESS);
float endTf = carTf;
if (lane.Equals(PlayerCarLines.Lane.RIGHT))
{
int direction = 1;
curvySpline.MoveByLengthFast(ref endTf, ref direction, 75.0f, CurvyClamping.Clamp); //this is to determine a constant length of the curve drawn, since Tf isn't proportional to the curve length, so you can't use a constant value!
for (float i = carTf; i < endTf; i += increaseAmount)
{
Vector3 pos = curvySpline.Interpolate(i);
CenterPoints.Add(pos);
}
}
else
{
int direction = -1;
curvySpline.MoveByLengthFast(ref endTf, ref direction, 75.0f, CurvyClamping.Clamp); //this is to determine a constant length of the curve drawn, since Tf isn't proportional to the curve length, so you can't use a constant value!
for (float i = carTf; i > endTf; i -= increaseAmount)
{
Vector3 pos = curvySpline.Interpolate(i);
CenterPoints.Add(pos);
}
}
lineRenderer2.positionCount = CenterPoints.Count;
lineRenderer2.SetPositions(CenterPoints.ToArray());
lineRenderer2.colorGradient = MakeLineRendererGradient(centerLineColor);
lineRenderer2.material.SetColor("_Color", CenterLineColor); //set tint color of particle shader
Texture2D txt = UpdateParams(centerLineColor, lineRendererTxt);
lineRenderer2.material.SetTexture("_MainTex", txt);
CenterPoints.Clear();
} //centerLine of PlayerCar in PCH
// public Object[] prefabs;
public void CreateObstacle(CurvySpline curSpline)
{
GameObject newGameObject = GameObject.CreatePrimitive(PrimitiveType.Cube); //create GO, add mesh filter with cube mesh and adds mesh renderer
newGameObject.transform.position = curSpline.Interpolate(0.3f); // place obstacle ahead of player
//Obstacle obstacle = newGameObject.AddComponent<JumpObstacle>();
Obstacle obstacle = newGameObject.AddComponent <MiniGameObstacle>();
obstacle.StartATL();
RegisterObject(obstacle);
print("cube");
}
IEnumerator LaneKeeping(float waitTime)
{
while (true)
{
yield return(new WaitForSeconds(waitTime));
RaycastHit hit;
CurvySpline curvySpline = null;
CurvySpline pathEnhancedCurvySpline = null;
if (Physics.Raycast(rayCastPos.position, rayCastPos.TransformDirection(-Vector3.up), out hit, 10.0f, 1 << LayerMask.NameToLayer("Graphics")))
{
curvySpline = hit.collider.gameObject.GetComponent <CurvySpline>();
pathEnhancedCurvySpline = pathEnhanced.GetComponent <CurvySpline>();
if (curvySpline.IsInitialized && pathEnhancedCurvySpline.IsInitialized)
{
//Debug.Log("meshcollider found is: " + hit.collider);
float carTf = curvySpline.GetNearestPointTF(transform.position); //determine the nearest t of the car with respect to the centerLine
Vector3 centerLinePoint = curvySpline.Interpolate(carTf);
float dist = Vector3.Distance(transform.position, centerLinePoint);
Lane lane = MonitorLane(centerLinePoint); //this is to understand if I am partially in the oncoming lane
if (dist < 2.0f && lane == Lane.RIGHT) //if dist2 < 2.7f I am in the right lane
{
linesUtilsAlt.CenterLineColor = linesUtilsAlt.ChangeMatByDistance(dist / 2.0f);
SetDashBoardColor(dist, 2.0f);
}
else if (dist >= 2.0f && lane == Lane.RIGHT)
{
linesUtilsAlt.CenterLineColor = new Color32(0x00, 0xFF, 0x00, 0x00);
laneState = LaneState.GREEN;
}
else if (lane == Lane.OPPOSITE) // this is to draw the redLine only when the PlayerCar is moving to the left, if it is moving to the right the line doesn't have to be red!
{
linesUtilsAlt.CenterLineColor = new Color32(0xFF, 0x00, 0x00, 0xFF);
laneState = LaneState.RED;
}
linesUtilsAlt.DrawCenterLine(gameObject, carTf, curvySpline, ResourceHandler.instance.sprites[36].texture);
}
}
else
{
laneState = LaneState.GREEN;
}
}
}
// Update is called once per frame
void Update()
{
if (Spline && Spline.IsInitialized && Lookup)
{
// convert Lookup position to Spline's local space
var lookupPos = Spline.transform.InverseTransformPoint(Lookup.position);
// get the nearest point's TF on spline
Timer.Start();
float nearestTF = Spline.GetNearestPointTF(lookupPos);
Timer.Stop();
// convert the spline pos back to world space and set
transform.position = Spline.transform.TransformPoint(Spline.Interpolate(nearestTF));
StatisticsText.text =
string.Format("Blue Curve Cache Points: {0} \nAverage Lookup (ms): {1:0.000}", Spline.CacheSize, Timer.AverageMS);
}
}
void DoFindPoint()
{
if (!mSpline.IsInitialized || SourcePoint.IsNone)
{
return;
}
if (StoreTF.IsNone && StorePosition.IsNone && StoreUpVector.IsNone && StoreRotation.IsNone && StoreTangent.IsNone)
{
return;
}
Vector3 pos = (Space == Space.Self) ? SourcePoint.Value : mSpline.transform.InverseTransformPoint(SourcePoint.Value);
float _tf = mSpline.GetNearestPointTF(pos);
if (StoreTF.IsNone == false)
{
StoreTF.Value = _tf;
}
if (StorePosition.IsNone == false)
{
StorePosition.Value = (Space == Space.Self) ? mSpline.Interpolate(_tf) : mSpline.transform.TransformPoint(mSpline.Interpolate(_tf));
}
if (StoreTangent.IsNone == false)
{
StoreTangent.Value = (Space == Space.Self) ? mSpline.GetTangent(_tf) : mSpline.transform.TransformDirection(mSpline.GetTangent(_tf));
}
if (StoreUpVector.IsNone == false)
{
StoreUpVector.Value = (Space == Space.Self) ? mSpline.GetOrientationUpFast(_tf) : mSpline.transform.TransformDirection(mSpline.GetOrientationUpFast(_tf));
}
if (StoreRotation.IsNone == false)
{
if (Space == Space.Self)
{
StoreRotation.Value = (StoreUpVector.IsNone) ? mSpline.GetOrientationFast(_tf) : Quaternion.LookRotation(mSpline.GetTangent(_tf), StoreUpVector.Value);
}
else
{
StoreRotation.Value = Quaternion.LookRotation(mSpline.transform.TransformDirection(mSpline.GetTangent(_tf)), mSpline.transform.TransformDirection(mSpline.GetOrientationUpFast(_tf)));
}
}
}
public CurvyMeshSegmentInfo(SplinePathMeshBuilder mb, float tf, float distance, Vector3 scale)
{
Spline = mb.Spline;
TF = tf;
mDistance = distance;
Vector3 p = (mb.FastInterpolation) ? Spline.InterpolateFast(TF) : Spline.Interpolate(TF);
if (mb.UseWorldPosition)
{
Matrix = Matrix4x4.TRS(mb.Transform.InverseTransformPoint(p), Spline.GetOrientationFast(TF), scale);
}
else
{
Matrix = Matrix4x4.TRS(Spline.Transform.InverseTransformPoint(p), Spline.GetOrientationFast(TF), scale);
}
}
void InitPosAndRot()
{
if (!Spline)
{
return;
}
// Get the TF for the current distance
float tf = Spline.DistanceToTF(InitialDistance);
// move Transform onto the spline
mTransform.position = Spline.Interpolate(tf);
// Rotate the transform to match the spline's orientation?
if (SetOrientation)
{
mTransform.rotation = Spline.GetOrientationFast(tf);
}
}
IEnumerator LaneKeeping(float waitTime)
{
while (true)
{
yield return(new WaitForSeconds(waitTime));
RaycastHit hit;
CurvySpline curvySpline = null;
CurvySpline pathEnhancedCurvySpline = null;
if (Physics.Raycast(rayCastPos.position, rayCastPos.TransformDirection(-Vector3.up), out hit, 10.0f, 1 << LayerMask.NameToLayer("Graphics")))
{
curvySpline = hit.collider.gameObject.GetComponent <CurvySpline>();
pathEnhancedCurvySpline = pathEnhanced.GetComponent <CurvySpline>();
if (curvySpline.IsInitialized && pathEnhancedCurvySpline.IsInitialized)
{
float carTf = curvySpline.GetNearestPointTF(transform.position); //determine the nearest t of the car with respect to the centerLine
float carTf2 = pathEnhancedCurvySpline.GetNearestPointTF(transform.position);
float dist = Vector3.Distance(transform.position, curvySpline.Interpolate(carTf));
Lane lane = MonitorLane(pathEnhancedCurvySpline.GetTangentFast(carTf2)); //this is to understand if I am partially in the oncoming lane
if (dist < 4.0f && lane == Lane.RIGHT)
{
linesUtilsAlt.CenterLineColor = linesUtilsAlt.ChangeMatByDistance(dist / 4.0f);
SetDashBoardColor(dist, 4.0f);
}
else if (dist >= 4.0f && lane == Lane.RIGHT)
{
linesUtilsAlt.CenterLineColor = new Color32(0x00, 0xFF, 0x00, 0x00);
laneState = LaneState.GREEN;
}
else if (lane == Lane.OPPOSITE)
{
linesUtilsAlt.CenterLineColor = new Color32(0xFF, 0x00, 0x00, 0xFF);
laneState = LaneState.RED;
}
linesUtilsAlt.DrawCenterLine(carTf, MonitorLane(curvySpline.GetTangentFast(carTf)), curvySpline, ResourceHandler.instance.sprites[33].texture);
}
}
else
{
laneState = LaneState.GREEN;
}
}
}
public void DrawLine(GameObject car, CurvySpline curvySpline, float carTf)
{
float increaseAmount = 1f / (curvySpline.Length * SPLINE_GIZMO_SMOOTHNESS);
int direction = 1;
float endTf = carTf;
curvySpline.MoveByLengthFast(ref endTf, ref direction, 75.0f, CurvyClamping.Clamp); //this is to determine a constant length of the curve drawn, since Tf isn't proportional to the curve length, so you can't use a constant value!
for (float i = carTf; i < endTf; i += increaseAmount)
{
Vector3 pos = curvySpline.Interpolate(i);
LinePoints.Add(pos);
}
lineRenderer.positionCount = LinePoints.Count;
lineRenderer.SetPositions(LinePoints.ToArray());
LinePoints.Clear();
} //NavigationLine of PlayerCar and TrafficCar in PCH
public void UpdateATL(ThirdPersonUserControl player_three, Crosshair crosshair, CurvySpline spline)
{
_targetDelay -= Time.deltaTime;
// aim through crosshair
Quaternion targetDirection = Quaternion.LookRotation(crosshair.transform.forward);
// passed the crosshair and delay
if (_targetDelay < 0.5f)
{
if (_speed > 10.0f)
{
_speed -= Time.deltaTime;
}
if (Vector3.Distance(gameObject.transform.position, player_three.transform.position) < 5.0f)
{
onceAround = true;
}
// going around track
if (!onceAround)
{
float t = spline.GetNearestPointTF(gameObject.transform.position);
t *= .95f;
Vector3 splineUp = spline.GetRotatedUpFast(t, 0);
Vector3 targetPosition = spline.Interpolate(t) + splineUp * 1.7f;
targetDirection = Quaternion.LookRotation((targetPosition - transform.position).normalized);
}
// circling player - should be the gun
else if (onceAround)
{
targetDirection = Quaternion.LookRotation(((player_three.transform.position + player_three.transform.up) - transform.position).normalized); //aim at heart
}
}
transform.rotation = Quaternion.Slerp(transform.rotation, targetDirection, Time.deltaTime);
Vector3 velocity = (transform.forward) * _speed;
GetComponent <Rigidbody>().MovePosition(transform.position + velocity * Time.deltaTime);
}
void Set()
{
float tf;
// First get the TF if needed
if (UseWorldUnits)
{
if (Distance >= Spline.Length)
{
Distance -= Spline.Length;
}
else if (Distance < 0)
{
Distance += Spline.Length;
}
tf = Spline.DistanceToTF(Distance);
}
else
{
if (Distance >= 1)
{
Distance -= 1;
}
else if (Distance < 0)
{
Distance += 1;
}
tf = Distance;
}
// Set the position
transform.position = Spline.Interpolate(tf);
// Set the rotation
if (SetOrientation)
{
transform.rotation = Spline.GetOrientationFast(tf);
}
}
public void UpdateATL(ThirdPersonUserControl player, CurvySpline spline)
{
if (!init && spline.IsInitialized)
{
init = true;
}
if (!init)
{
return;
}
//print("mouse x " + Input.GetAxis("Mouse X") + ", mouse y " + Input.GetAxis("Mouse Y"));
offset += new Vector3(-Input.GetAxisRaw("Mouse X"), Input.GetAxisRaw("Mouse Y"), 0.0f);
t = spline.GetNearestPointTF(player.transform.position);
Vector3 splineUp = spline.GetRotatedUpFast(t, 0);
//AxKDebugLines.AddLine (player.transform.position, player.transform.position + splineUp, Color.red, .001f);
Vector3 splineForward = spline.GetTangent(t);
Vector3 splineRight = Vector3.Cross(splineUp, splineForward);
Vector3 tempOffset = splineRight * offset.x + splineUp * offset.y; //changed from Vector3.up
float targetPositionT = t - offsetCrosshair / spline.Length;
Vector3 targetT = spline.Interpolate(targetPositionT);
Vector3 targetPosition = targetT + tempOffset;
transform.position = Vector3.Lerp(transform.position, targetPosition, Time.deltaTime * smooth * 3.0f);
//transform.localRotation = Quaternion.Slerp( transform.localRotation, Quaternion.LookRotation (-splineForward.normalized), Time.deltaTime * smooth );
//clamp the final position to this
Vector3 pos = Camera.main.WorldToViewportPoint(transform.position);
pos.x = Mathf.Clamp01(pos.x);
pos.y = Mathf.Clamp01(pos.y);
transform.position = Camera.main.ViewportToWorldPoint(pos);
//transform.position = targetPosition;
transform.localRotation = Camera.main.transform.localRotation;
if (fire) //fire is only true for one frame
{
_small.gameObject.GetComponent <Renderer> ().material = fireS;
_medium.gameObject.GetComponent <Renderer> ().material = fireM;
_large.gameObject.GetComponent <Renderer> ().material = fireL;
//print ("in fire, mat name = " + _medium.gameObject.GetComponent<Renderer> ().material.name);
StartCoroutine(Delay(.5f));
}
else if (aim && !fire)
{
_small.localRotation = Quaternion.Euler(transform.localRotation.y, transform.localRotation.x, tempOffset.x * 300.0f);
_medium.localRotation = Quaternion.Euler(transform.localRotation.y, transform.localRotation.x, tempOffset.y * 300.0f); //y = Time.time; // * 180.0f; // Quaternion.AngleAxis (Time.time * 180.0f , transform.forward);
_small.gameObject.GetComponent <Renderer> ().material = aimS;
_medium.gameObject.GetComponent <Renderer> ().material = aimM;
_large.gameObject.GetComponent <Renderer> ().material = aimL;
//print ("in aim, mat name = " + _medium.gameObject.GetComponent<Renderer> ().material.name);
}
else
{
//ease back. only call on return
_small.localRotation = Quaternion.Slerp(_small.localRotation, Quaternion.Euler(Vector3.zero), Time.deltaTime);
_medium.localRotation = Quaternion.Slerp(_medium.localRotation, Quaternion.Euler(Vector3.zero), Time.deltaTime);
_small.gameObject.GetComponent <Renderer> ().material = readyS;
_medium.gameObject.GetComponent <Renderer> ().material = readyM;
_large.gameObject.GetComponent <Renderer> ().material = readyL;
//print ("in ready, mat name = " + _medium.gameObject.GetComponent<Renderer> ().material.name);
}
}
void Calculate()
{
if (selcount == 0)
{
return;
}
pos = new UnityEngine.Vector3[selcount];
up = new UnityEngine.Vector3[selcount];
tan = new UnityEngine.Vector3[selcount];
for (int i = 0; i < selcount; i++)
{
pos[i] = (UseWorldUnits) ? Spline.InterpolateByDistance(StartOffset + Step * i) : Spline.Interpolate(StartOffset + Step * i);
up[i] = (UseWorldUnits) ? Spline.GetOrientationUpFast(Spline.DistanceToTF(StartOffset + Step * i)) : Spline.GetOrientationUpFast(StartOffset + Step * i);
tan[i] = (UseWorldUnits) ? Spline.GetTangentByDistance(StartOffset + Step * i) : Spline.GetTangent(StartOffset + Step * i);
}
}
protected CGData GetSplineData(CurvySpline spline, bool fullPath, CGDataRequestRasterization raster, CGDataRequestMetaCGOptions options)
{
if (spline == null || spline.Count == 0)
{
return(null);
}
List <ControlPointOption> optionsSegs = new List <ControlPointOption>();
int materialID = 0;
float maxStep = float.MaxValue;
var data = (fullPath) ? new CGPath() : new CGShape();
// calc start & end point (distance)
float startDist;
float endDist;
getRange(spline, raster, out startDist, out endDist);
float stepDist = (endDist - startDist) / (raster.Resolution - 1);
data.Length = endDist - startDist;
// initialize with start TF
float tf = spline.DistanceToTF(startDist);
float startTF = tf;
float endTF = (endDist > spline.Length && spline.Closed) ? spline.DistanceToTF(endDist - spline.Length) + 1 : spline.DistanceToTF(endDist);
// Set properties
data.SourceIsManaged = IsManagedResource(spline);
data.Closed = spline.Closed;
data.Seamless = spline.Closed && raster.Length == 1;
if (data.Length == 0)
{
return(data);
}
// Scan input spline and fetch a list of control points that provide special options (Hard Edge, MaterialID etc...)
if (options)
{
optionsSegs = CGUtility.GetControlPointsWithOptions(options,
spline,
startDist,
endDist,
raster.Mode == CGDataRequestRasterization.ModeEnum.Optimized,
out materialID,
out maxStep);
}
// Setup vars
List <SamplePointUData> extendedUVData = new List <SamplePointUData>();
List <Vector3> pos = new List <Vector3>();
List <float> relF = new List <float>();
List <float> sourceF = new List <float>();
List <Vector3> tan = new List <Vector3>();
List <Vector3> up = new List <Vector3>();
float curDist = startDist;
Vector3 curPos;
float curF;
Vector3 curTan = Vector3.zero;
Vector3 curUp = Vector3.zero;
List <int> softEdges = new List <int>();
int dead = 100000;
raster.Resolution = Mathf.Max(raster.Resolution, 2);
switch (raster.Mode)
{
case CGDataRequestRasterization.ModeEnum.Even:
#region --- Even ---
// we advance the spline using a fixed distance
bool dupe = false;
// we have at least one Material Group
SamplePointsMaterialGroup grp = new SamplePointsMaterialGroup(materialID);
// and at least one patch within that group
SamplePointsPatch patch = new SamplePointsPatch(0);
var clampMode = (data.Closed) ? CurvyClamping.Loop : CurvyClamping.Clamp;
while (curDist <= endDist && --dead > 0)
{
tf = spline.DistanceToTF(spline.ClampDistance(curDist, clampMode));
curPos = (UseCache) ? spline.InterpolateFast(tf) : spline.Interpolate(tf);
curF = (curDist - startDist) / data.Length;//curDist / endDist;
if (Mathf.Approximately(1, curF))
{
curF = 1;
}
pos.Add(curPos);
relF.Add(curF);
sourceF.Add(curDist / spline.Length);
if (fullPath) // add path values
{
curTan = (UseCache) ? spline.GetTangentFast(tf) : spline.GetTangent(tf, curPos);
curUp = spline.GetOrientationUpFast(tf);
tan.Add(curTan);
up.Add(curUp);
}
if (dupe) // HardEdge, IncludeCP, MaterialID changes etc. need an extra vertex
{
pos.Add(curPos);
relF.Add(curF);
sourceF.Add(curDist / spline.Length);
if (fullPath)
{
tan.Add(curTan);
up.Add(curUp);
}
dupe = false;
}
// Advance
curDist += stepDist;
// Check next Sample Point's options. If the next point would be past a CP with options
if (optionsSegs.Count > 0 && curDist >= optionsSegs[0].Distance)
{
if (optionsSegs[0].UVEdge || optionsSegs[0].UVShift)
{
extendedUVData.Add(new SamplePointUData(pos.Count, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
}
// clamp point at CP and maybe duplicate the next sample point
curDist = optionsSegs[0].Distance;
dupe = optionsSegs[0].HardEdge || optionsSegs[0].MaterialID != grp.MaterialID || (options.CheckExtendedUV && optionsSegs[0].UVEdge);
// end the current patch...
if (dupe)
{
patch.End = pos.Count;
grp.Patches.Add(patch);
// if MaterialID changes, we start a new MaterialGroup
if (grp.MaterialID != optionsSegs[0].MaterialID)
{
data.MaterialGroups.Add(grp);
grp = new SamplePointsMaterialGroup(optionsSegs[0].MaterialID);
}
// in any case we start a new patch
patch = new SamplePointsPatch(pos.Count + 1);
if (!optionsSegs[0].HardEdge)
{
softEdges.Add(pos.Count + 1);
}
// Extended UV
if (optionsSegs[0].UVEdge || optionsSegs[0].UVShift)
{
extendedUVData.Add(new SamplePointUData(pos.Count + 1, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
}
}
// and remove the CP from the options
optionsSegs.RemoveAt(0);
}
// Ensure last sample point position is at the desired end distance
if (curDist > endDist && curF < 1) // next loop curF will be 1
{
curDist = endDist;
}
}
if (dead <= 0)
{
Debug.LogError("[Curvy] He's dead, Jim! Deadloop in SplineInputModuleBase.GetSplineData (Even)! Please send a bug report!");
}
// store the last open patch
patch.End = pos.Count - 1;
grp.Patches.Add(patch);
// ExplicitU on last Vertex?
//if (optionsSegs.Count > 0 && optionsSegs[0].UVShift)
// extendedUVData.Add(new SamplePointUData(pos.Count - 1, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
// if path is closed and no hard edges involved, we need to smooth first normal
if (data.Closed && !spline[0].GetMetadata <MetaCGOptions>(true).HardEdge)
{
softEdges.Add(0);
}
data.MaterialGroups.Add(grp);
// fill data
data.SourceF = sourceF.ToArray();
data.F = relF.ToArray();
data.Position = pos.ToArray();
if (fullPath)
{
((CGPath)data).Direction = tan.ToArray();
data.Normal = up.ToArray();
}
#endregion
break;
case CGDataRequestRasterization.ModeEnum.Optimized:
#region --- Optimized ---
dupe = false;
// we have at least one Material Group
grp = new SamplePointsMaterialGroup(materialID);
// and at least one patch within that group
patch = new SamplePointsPatch(0);
float stepSizeTF = stepDist / spline.Length;
float maxAngle = raster.AngleThreshold;
float stopAt;
bool atStopPoint;
curPos = spline.Interpolate(tf);
curTan = spline.GetTangent(tf, curPos);
var addPoint = new System.Action <float>((float f) =>
{
sourceF.Add(curDist / spline.Length);
pos.Add(curPos);
relF.Add((curDist - startDist) / data.Length);
if (fullPath)
{
tan.Add(curTan);
up.Add(spline.GetOrientationUpFast(f));
}
});
while (tf < endTF && dead-- > 0)
{
addPoint(tf % 1);
// Advance
stopAt = (optionsSegs.Count > 0) ? optionsSegs[0].TF : endTF;
atStopPoint = spline.MoveByAngleExtINTERNAL(ref tf, Generator.MinDistance, maxStep, maxAngle, out curPos, out curTan, out stepDist, stopAt, data.Closed, stepSizeTF);
curDist += stepDist;
if (Mathf.Approximately(tf, endTF) || tf > endTF)
{
curDist = endDist;
endTF = (data.Closed) ? DTMath.Repeat(endTF, 1) : Mathf.Clamp01(endTF);
curPos = spline.Interpolate(endTF);
if (fullPath)
{
curTan = spline.GetTangent(endTF, curPos);
}
addPoint(endTF);
break;
}
if (atStopPoint)
{
if (optionsSegs.Count > 0)
{
if (optionsSegs[0].UVEdge || optionsSegs[0].UVShift)
{
extendedUVData.Add(new SamplePointUData(pos.Count, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
}
// clamp point at CP and maybe duplicate the next sample point
curDist = optionsSegs[0].Distance;
maxStep = (optionsSegs[0].MaxStepDistance);
dupe = optionsSegs[0].HardEdge || optionsSegs[0].MaterialID != grp.MaterialID || (options.CheckExtendedUV && optionsSegs[0].UVEdge);
if (dupe)
{
// end the current patch...
patch.End = pos.Count;
grp.Patches.Add(patch);
// if MaterialID changes, we start a new MaterialGroup
if (grp.MaterialID != optionsSegs[0].MaterialID)
{
data.MaterialGroups.Add(grp);
grp = new SamplePointsMaterialGroup(optionsSegs[0].MaterialID);
}
// in any case we start a new patch
patch = new SamplePointsPatch(pos.Count + 1);
if (!optionsSegs[0].HardEdge)
{
softEdges.Add(pos.Count + 1);
}
// Extended UV
if (optionsSegs[0].UVEdge || optionsSegs[0].UVShift)
{
extendedUVData.Add(new SamplePointUData(pos.Count + 1, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
}
addPoint(tf);
}
// and remove the CP from the options
optionsSegs.RemoveAt(0);
}
else
{
addPoint(tf);
break;
}
}
}
if (dead <= 0)
{
Debug.LogError("[Curvy] He's dead, Jim! Deadloop in SplineInputModuleBase.GetSplineData (Optimized)! Please send a bug report!");
}
// store the last open patch
patch.End = pos.Count - 1;
grp.Patches.Add(patch);
// ExplicitU on last Vertex?
if (optionsSegs.Count > 0 && optionsSegs[0].UVShift)
{
extendedUVData.Add(new SamplePointUData(pos.Count - 1, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
}
// if path is closed and no hard edges involved, we need to smooth first normal
if (data.Closed && !spline[0].GetMetadata <MetaCGOptions>(true).HardEdge)
{
softEdges.Add(0);
}
data.MaterialGroups.Add(grp);
// fill data
data.SourceF = sourceF.ToArray();
data.F = relF.ToArray();
data.Position = pos.ToArray();
data.Bounds = spline.Bounds;
if (fullPath)
{
((CGPath)data).Direction = tan.ToArray();
data.Normal = up.ToArray();
}
#endregion
break;
}
data.Map = (float[])data.F.Clone();
if (!fullPath)
{
data.RecalculateNormals(softEdges);
if (options && options.CheckExtendedUV)
{
CalculateExtendedUV(spline, startTF, endTF, extendedUVData, data);
}
}
return(data);
}
void DoInterpolate()
{
if (!mSpline.IsInitialized)
{
return;
}
System.Type metaDataType;
{
if (String.IsNullOrEmpty(MetaDataType.Value))
{
metaDataType = null;
}
else
{
#if NETFX_CORE
Type[] knownTypes = this.GetType().GetAllTypes();
#else
Type[] knownTypes = TypeExt.GetLoadedTypes();
#endif
metaDataType = knownTypes.FirstOrDefault(t => t.FullName == MetaDataType.Value);
}
}
bool calc = !Input.IsNone;
if (calc)
{
float f = (UseWorldUnits.Value) ? mSpline.DistanceToTF(Input.Value) : Input.Value;
if (StorePosition.IsNone == false)
{
StorePosition.Value = (UseCache.Value) ? mSpline.InterpolateFast(f) : mSpline.Interpolate(f);
}
if (StoreTangent.IsNone == false)
{
StoreTangent.Value = mSpline.GetTangent(f);
}
if (StoreUpVector.IsNone == false)
{
StoreUpVector.Value = mSpline.GetOrientationUpFast(f);
}
if (StoreRotation.IsNone == false)
{
StoreRotation.Value = (StoreUpVector.IsNone) ? mSpline.GetOrientationFast(f) : Quaternion.LookRotation(mSpline.GetTangent(f), StoreUpVector.Value);
}
if (StoreScale.IsNone == false)
{
float localF;
CurvySplineSegment segment = mSpline.TFToSegment(f, out localF);
CurvySplineSegment nextControlPoint = segment.Spline.GetNextControlPoint(segment);
if (ReferenceEquals(segment, null) == false)
{
StoreScale.Value = nextControlPoint
? Vector3.Lerp(segment.transform.lossyScale, nextControlPoint.transform.lossyScale, localF)
: segment.transform.lossyScale;
}
else
{
StoreScale.Value = Vector3.zero;
}
}
if (StoreTF.IsNone == false)
{
StoreTF.Value = f;
}
if (StoreDistance.IsNone == false)
{
StoreDistance.Value = (UseWorldUnits.Value) ? Input.Value : mSpline.TFToDistance(f);
}
if (metaDataType != null)
{
if (metaDataType.IsSubclassOf(typeof(CurvyMetadataBase)) == false)
{
//this if statement's branch does not exclude classes inheriting from CurvyMetadataBase but not from CurvyInterpolatableMetadataBase, but that's ok, those classes are handled below
Debug.LogError("Meta data type " + metaDataType.FullName + " should be a subclass of CurvyInterpolatableMetadataBase<T>");
}
else
{
if (StoreMetadata.IsNone == false)
{
MethodInfo genericMethodInfo = mSpline.GetType().GetMethod("GetMetadata").MakeGenericMethod(metaDataType);
StoreMetadata.Value = (Object)genericMethodInfo.Invoke(mSpline, new System.Object[] { f });
}
if (StoreInterpolatedMetadata.IsNone == false)
{
Type argumentType = GetInterpolatableMetadataGenericType(metaDataType);
if (argumentType == null)
{
Debug.LogError("Meta data type " + metaDataType.FullName + " should be a subclass of CurvyInterpolatableMetadataBase<T>");
}
else
{
MethodInfo genericMethodInfo = mSpline.GetType().GetMethod("GetInterpolatedMetadata").MakeGenericMethod(metaDataType, argumentType);
StoreInterpolatedMetadata.SetValue(genericMethodInfo.Invoke(mSpline, new System.Object[] { f }));
}
}
}
}
CurvySplineSegment seg = null;
float segF = 0;
if (StoreSegment.IsNone == false)
{
seg = getSegment(f, out segF);
StoreSegment.Value = seg.gameObject;
}
if (StoreSegmentF.IsNone == false)
{
if (!seg)
{
seg = getSegment(f, out segF);
}
StoreSegmentF.Value = segF;
}
if (StoreSegmentDistance.IsNone == false)
{
if (!seg)
{
seg = getSegment(f, out segF);
}
StoreSegmentDistance.Value = seg.LocalFToDistance(segF);
}
}
// General
if (StoreLength.IsNone == false)
{
StoreLength.Value = mSpline.Length;
}
if (StoreCount.IsNone == false)
{
StoreCount.Value = mSpline.Count;
}
}
public CurvyMeshSegmentInfo(SplinePathMeshBuilder mb, float tf, float distance, Vector3 scale)
{
Spline = mb.Spline;
TF = tf;
mDistance = distance;
Vector3 p = (mb.FastInterpolation) ? Spline.InterpolateFast(TF) : Spline.Interpolate(TF);
if (mb.UseWorldPosition)
Matrix = Matrix4x4.TRS(mb.Transform.InverseTransformPoint(p), Spline.GetOrientationFast(TF), scale);
else
Matrix = Matrix4x4.TRS(Spline.Transform.InverseTransformPoint(p), Spline.GetOrientationFast(TF), scale);
}
/// <summary>
/// Builds a mesh from a spline (2D), taking interpolated points based on curvation angle
/// </summary>
/// <param name="spline">the spline to use</param>
/// <param name="ignoreAxis">the axis to ignore (0=x,1=y,2=z)</param>
/// <param name="close">True to create a mesh with triangles, False to create a vertex line mesh</param>
/// <param name="angleDiff">the curvation angle used to interpolate points</param>
public static Mesh CreateSplineMesh(CurvySpline spline, int ignoreAxis, bool close, float angleDiff)
{
float tf = 0;
int dir = 1;
List<Vector3> verts = new List<Vector3>();
verts.Add(spline.Transform.worldToLocalMatrix.MultiplyPoint3x4(spline.Interpolate(0)));
while (tf < 1) {
verts.Add(spline.Transform.worldToLocalMatrix.MultiplyPoint3x4(spline.MoveByAngle(ref tf, ref dir, angleDiff, CurvyClamping.Clamp, 0.005f)));
}
return buildSplineMesh(verts.ToArray(), ignoreAxis, !close);
}
public void UpdateATL(ThirdPersonUserControl player, CurvySpline spline)
{
if (!init && spline.IsInitialized)
{
init = true;
t = spline.GetNearestPointTF(player.transform.position);
minT = t - (buffer / spline.Length) / 2.0f;
maxT = t + (buffer / spline.Length) / 2.0f;
}
if (!init)
{
return;
}
//print ("spline name = " + spline.name);
float playerT = spline.GetNearestPointTF(player.transform.position);
//print ("playerT = " + playerT);
//AxKDebugLines.AddSphere (player.transform.position, 0.3f, Color.green);
//AxKDebugLines.AddSphere (spline.Interpolate (player.transform.position), 0.3f, Color.magenta);
//AxKDebugLines.AddSphere (spline.Interpolate (playerT), 0.3f, Color.blue);
if (playerT > maxT)
{
maxT = playerT;
minT = maxT - (buffer / spline.Length);
t = playerT;
}
else if (playerT < minT)
{
minT = playerT;
maxT = minT + (buffer / spline.Length);
t = playerT;
}
//AxKDebugLines.AddSphere (spline.Interpolate (maxT), 0.3f, Color.green);
//AxKDebugLines.AddSphere (spline.Interpolate (minT), 0.3f, Color.magenta);
splineUp = spline.GetRotatedUpFast(t, 0);
splineForward = spline.GetTangent(t);
splineRight = Vector3.Cross(splineUp, splineForward);
//print ("offset = " + offset);
Vector3 rise = splineUp * offset.y + splineForward * offset.z + splineRight * offset.x * Mathf.Sin(Mathf.Sqrt(Time.time));
float targetPositionT = t + offsetCam / spline.Length;
Vector3 targetPosition = spline.Interpolate(targetPositionT) + rise;
float lookPositionT = t - offsetLook / spline.Length;
Vector3 lookPosition = spline.Interpolate(lookPositionT);
targetPosition = ((targetPosition * 4f) + player.transform.position) / 5f;
if (CUbool)
{
lookPosition = player.transform.position + player.transform.up * 2.55f;
targetPosition = lookPosition + player.transform.forward * .4f;
//print ("in bool");
}
else if (falling)
{
lookPosition = player.transform.position;
targetPosition = transform.position;
}
transform.position = Vector3.Lerp(transform.position, targetPosition, Time.deltaTime * smooth);
transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation((lookPosition - transform.position).normalized), Time.deltaTime * smooth);
}
public void UpdateATL(List <BoidFlocking> _boids, BoidLord boidLord, ThirdPersonUserControl player, CurvySpline spline, Crosshair crosshair)
{
if (destroyMe)
{
boidLord.RemoveBoid(this);
}
alignment = ComputeAlignment(_boids, boidLord) * boidLord.alignmentStrength;
cohesion = ComputeCohesion(_boids, boidLord) * boidLord.cohesionStrength;
separation = ComputeSeparation(_boids, boidLord) * boidLord.seperationStrength;
Vector3 wiggle = new Vector3(Mathf.Sin(Time.timeSinceLevelLoad + seed[2]), Mathf.Sin(Time.timeSinceLevelLoad + seed[1]), Mathf.Sin(Time.timeSinceLevelLoad + seed[0]));
// add variation of target
if ((iterator + 1) % 3 == 0)
{
Vector3 offset = crosshair.transform.position - player.transform.position;
target = crosshair.transform.position + offset * 5.0f + crosshair.transform.right * Mathf.Sin(Time.timeSinceLevelLoad + seed[0]) * 5.0f;
}
else if ((iterator + 1) % 2 == 0)
{
float d = Vector3.Distance(player.transform.position, Camera.main.transform.position);
target = Camera.main.transform.position + Camera.main.transform.forward * d * 7.0f + Camera.main.transform.up * d * 3.0f;
target += Camera.main.transform.right * Mathf.Cos(Time.timeSinceLevelLoad + seed[2]) * 15.0f;
}
else
{
float t = Camera.main.GetComponent <CameraController_three>().GetPlayerT();
//interpolate position on spline behind player
target = spline.Interpolate(t * .6f);
//vectors are taken from point on spline where the player is
target += Camera.main.GetComponent <CameraController_three>().GetSplineUp() * 8.0f;
target += Camera.main.GetComponent <CameraController_three>().GetSplineRight() * Mathf.Sin(Time.timeSinceLevelLoad + seed[1]) * 20.0f;
}
target -= transform.position; // make target position a vector from this boid to that position
Vector3 velocityChange = alignment + cohesion + separation + target;
GetComponent <Rigidbody>().AddForce(velocityChange * Time.deltaTime * 0.3f, ForceMode.VelocityChange); // changed from Acceleration
GetComponent <Rigidbody>().drag = 0.8f;
Quaternion look = Quaternion.LookRotation(player.transform.position - transform.position);
GetComponent <Rigidbody>().MoveRotation(Quaternion.Slerp(transform.rotation, look, Time.deltaTime * 3.0f));
GetComponent <Rigidbody>().AddForce(transform.forward * 0.2f, ForceMode.VelocityChange);
//AxKDebugLines.AddLine(transform.position, transform.position + cohesion, Color.cyan, 0);
//AxKDebugLines.AddLine(transform.position, transform.position + alignment, Color.green, 0);
//AxKDebugLines.AddLine(transform.position, transform.position + separation, Color.yellow, 0);
/*
* if ((iterator+1) % 3 == 0)
* {
* AxKDebugLines.AddLine(transform.position, transform.position + target, Color.white, 0);
* }
* else if ((iterator+1) % 2 == 0)
* {
* AxKDebugLines.AddLine(transform.position, transform.position + target, Color.red, 0);
* }
* else
* {
* AxKDebugLines.AddLine(transform.position, transform.position + target, Color.black, 0);
* }
*/
}
public void UpdateATL(ThirdPersonUserControl player, CurvySpline spline)
{
if (!init && spline.IsInitialized)
{
init = true;
}
if (!init)
{
return;
}
if (!Camera.main.GetComponent <CameraController_three> ().CUbool&& !wasdDone)
{
//player.GetComponentInChildren<MakeMesh> (true).enabled = true;
MakeTextGO("TO MOVE HOLD DOWN WASD"); //0-17 before "W"
wasdDone = true;
}
if (Input.GetKeyDown(KeyCode.W) && !wPressed)
{
SwapCharGO(' ', 14); // replace W with a space
wPressed = true;
}
if (Input.GetKeyDown(KeyCode.A) && !aPressed)
{
SwapCharGO(' ', 15);
aPressed = true;
}
if (Input.GetKeyDown(KeyCode.S) && !sPressed)
{
SwapCharGO(' ', 16);
sPressed = true;
}
if (Input.GetKeyDown(KeyCode.D) && !dPressed)
{
SwapCharGO(' ', 17);
dPressed = true;
}
// conditionals for which words to show
if (wPressed && sPressed && aPressed && dPressed && !wasdCleared)
{
Clear();
wasdCleared = true;
}
if (player.GetComponent <ThirdPersonCharacter> ().SeenGun() && !qDone && wasdCleared) //must evade intro wide with gun in view
{
MakeTextGO("PRESS Q TO PICKUP");
qDone = true;
}
if (player.GetComponent <ThirdPersonCharacter> ().m_pickup == true && !mouseAimDone)
{
MakeTextGO("PRESS LEFT MOUSE DOWN TO AIM");
mouseAimDone = true;
}
if (player.GetComponent <ThirdPersonCharacter> ().m_doneAim == true && !mouseFireDone)
{
MakeTextGO("RELEASE LEFT MOUSE TO FIRE");
mouseFireDone = true;
//StartCoroutine (Fade (4.0f)); //do on fireFlag below
}
if (player.GetComponent <ThirdPersonCharacter> ().m_fireFlag == true & !fireCleared)
{
Clear();
fireCleared = true;
}
float t = spline.GetNearestPointTF(player.transform.position);
//AxKDebugLines.AddSphere (spline.Interpolate (maxT), 0.3f, Color.green);
//AxKDebugLines.AddSphere (spline.Interpolate (minT), 0.3f, Color.magenta);
Vector3 splineUp = spline.GetRotatedUpFast(t, 0);
Vector3 splineForward = spline.GetTangent(t);
Vector3 splineRight = Vector3.Cross(splineUp, splineForward);
//Vector3 rise = splineRight * offset.x + splineUp * offset.y + splineForward * offset.z;
Vector3 lookPosition = Camera.main.transform.position;
//Vector3 targetPosition = player.transform.position + player.transform.right * 0.8f * textLength / 4 + player.transform.up * 4.0f - player.transform.forward * 3.0f;
Vector3 targetPosition = spline.Interpolate(t) + splineRight * 0.8f * textLength / 3 + splineUp * 4.0f - splineForward * 3.0f;
//AxKDebugLines.AddSphere (lookPosition, .1f, Color.red);
//AxKDebugLines.AddSphere (targetPosition, .1f, Color.blue);
transform.position = Vector3.Lerp(transform.position, targetPosition, Time.deltaTime * smooth);
transform.rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation((lookPosition - transform.position).normalized), Time.deltaTime * smooth);
}
protected CGData GetSplineData(CurvySpline spline, bool fullPath, CGDataRequestRasterization raster, CGDataRequestMetaCGOptions options)
{
if (spline == null || spline.Count == 0)
return null;
List<ControlPointOption> optionsSegs = new List<ControlPointOption>();
int materialID = 0;
float maxStep = float.MaxValue;
var data = (fullPath) ? new CGPath() : new CGShape();
// calc start & end point (distance)
float startDist;
float endDist;
getRange(spline, raster, out startDist, out endDist);
float stepDist = (endDist - startDist) / (raster.Resolution - 1);
data.Length = endDist - startDist;
// initialize with start TF
float tf = spline.DistanceToTF(startDist);
float startTF = tf;
float endTF = (endDist > spline.Length && spline.Closed) ? spline.DistanceToTF(endDist - spline.Length) + 1 : spline.DistanceToTF(endDist);
// Set properties
data.SourceIsManaged = IsManagedResource(spline);
data.Closed = spline.Closed;
data.Seamless = spline.Closed && raster.Length == 1;
if (data.Length == 0)
return data;
// Scan input spline and fetch a list of control points that provide special options (Hard Edge, MaterialID etc...)
if (options)
optionsSegs = CGUtility.GetControlPointsWithOptions(options,
spline,
startDist,
endDist,
raster.Mode == CGDataRequestRasterization.ModeEnum.Optimized,
out materialID,
out maxStep);
// Setup vars
List<SamplePointUData> extendedUVData = new List<SamplePointUData>();
List<Vector3> pos = new List<Vector3>();
List<float> relF = new List<float>();
List<float> sourceF = new List<float>();
List<Vector3> tan = new List<Vector3>();
List<Vector3> up = new List<Vector3>();
float curDist = startDist;
Vector3 curPos;
float curF;
Vector3 curTan = Vector3.zero;
Vector3 curUp = Vector3.zero;
List<int> softEdges = new List<int>();
int dead = 100000;
raster.Resolution = Mathf.Max(raster.Resolution, 2);
switch (raster.Mode)
{
case CGDataRequestRasterization.ModeEnum.Even:
#region --- Even ---
// we advance the spline using a fixed distance
bool dupe = false;
// we have at least one Material Group
SamplePointsMaterialGroup grp = new SamplePointsMaterialGroup(materialID);
// and at least one patch within that group
SamplePointsPatch patch = new SamplePointsPatch(0);
var clampMode=(data.Closed) ? CurvyClamping.Loop : CurvyClamping.Clamp;
while (curDist <= endDist && --dead>0)
{
tf = spline.DistanceToTF(spline.ClampDistance(curDist, clampMode));
curPos = spline.Interpolate(tf);
curF = (curDist-startDist) / data.Length;//curDist / endDist;
if (Mathf.Approximately(1, curF))
curF = 1;
pos.Add(curPos);
relF.Add(curF);
sourceF.Add(curDist / spline.Length);
if (fullPath) // add path values
{
curTan = spline.GetTangent(tf,curPos);
curUp = spline.GetOrientationUpFast(tf);
tan.Add(curTan);
up.Add(curUp);
}
if (dupe) // HardEdge, IncludeCP, MaterialID changes etc. need an extra vertex
{
pos.Add(curPos);
relF.Add(curF);
sourceF.Add(curDist / spline.Length);
if (fullPath)
{
tan.Add(curTan);
up.Add(curUp);
}
dupe = false;
}
// Advance
curDist += stepDist;
// Check next Sample Point's options. If the next point would be past a CP with options
if (optionsSegs.Count > 0 && curDist >= optionsSegs[0].Distance)
{
if (optionsSegs[0].UVEdge || optionsSegs[0].UVShift)
extendedUVData.Add(new SamplePointUData(pos.Count, optionsSegs[0].UVEdge,optionsSegs[0].FirstU, optionsSegs[0].SecondU));
// clamp point at CP and maybe duplicate the next sample point
curDist = optionsSegs[0].Distance;
dupe = optionsSegs[0].HardEdge || optionsSegs[0].MaterialID != grp.MaterialID || (options.CheckExtendedUV && optionsSegs[0].UVEdge);
// end the current patch...
if (dupe)
{
patch.End = pos.Count;
grp.Patches.Add(patch);
// if MaterialID changes, we start a new MaterialGroup
if (grp.MaterialID != optionsSegs[0].MaterialID)
{
data.MaterialGroups.Add(grp);
grp = new SamplePointsMaterialGroup(optionsSegs[0].MaterialID);
}
// in any case we start a new patch
patch = new SamplePointsPatch(pos.Count + 1);
if (!optionsSegs[0].HardEdge)
softEdges.Add(pos.Count + 1);
// Extended UV
if (optionsSegs[0].UVEdge || optionsSegs[0].UVShift)
extendedUVData.Add(new SamplePointUData(pos.Count + 1, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
}
// and remove the CP from the options
optionsSegs.RemoveAt(0);
}
// Ensure last sample point position is at the desired end distance
if (curDist > endDist && curF < 1) // next loop curF will be 1
curDist = endDist;
}
if (dead<= 0)
Debug.LogError("[Curvy] He's dead, Jim! Deadloop in SplineInputModuleBase.GetSplineData (Even)! Please send a bug report!");
// store the last open patch
patch.End = pos.Count - 1;
grp.Patches.Add(patch);
// ExplicitU on last Vertex?
//if (optionsSegs.Count > 0 && optionsSegs[0].UVShift)
// extendedUVData.Add(new SamplePointUData(pos.Count - 1, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
// if path is closed and no hard edges involved, we need to smooth first normal
if (data.Closed && !spline[0].GetMetadata<MetaCGOptions>(true).HardEdge)
softEdges.Add(0);
data.MaterialGroups.Add(grp);
// fill data
data.SourceF = sourceF.ToArray();
data.F = relF.ToArray();
data.Position = pos.ToArray();
if (fullPath)
{
((CGPath)data).Direction = tan.ToArray();
data.Normal = up.ToArray();
}
#endregion
break;
case CGDataRequestRasterization.ModeEnum.Optimized:
#region --- Optimized ---
dupe = false;
// we have at least one Material Group
grp = new SamplePointsMaterialGroup(materialID);
// and at least one patch within that group
patch = new SamplePointsPatch(0);
float stepSizeTF = stepDist / spline.Length;
float maxAngle = raster.AngleThreshold;
float stopAt;
bool atStopPoint;
curPos = spline.Interpolate(tf);
curTan = spline.GetTangent(tf, curPos);
var addPoint = new System.Action<float>((float f) =>
{
sourceF.Add(curDist/spline.Length);
pos.Add(curPos);
relF.Add((curDist -startDist) / data.Length);
if (fullPath)
{
tan.Add(curTan);
up.Add(spline.GetOrientationUpFast(f));
}
});
while (tf < endTF && dead-- > 0)
{
addPoint(tf%1);
// Advance
stopAt = (optionsSegs.Count > 0) ? optionsSegs[0].TF : endTF;
atStopPoint = spline.MoveByAngleExtINTERNAL(ref tf, Generator.MinDistance, maxStep, maxAngle, out curPos, out curTan, out stepDist, stopAt, data.Closed,stepSizeTF);
curDist += stepDist;
if (Mathf.Approximately(tf, endTF) || tf > endTF)
{
curDist = endDist;
endTF = (data.Closed) ? DTMath.Repeat(endTF,1) : Mathf.Clamp01(endTF);
curPos = spline.Interpolate(endTF);
if (fullPath)
curTan = spline.GetTangent(endTF, curPos);
addPoint(endTF);
break;
}
if (atStopPoint)
{
if (optionsSegs.Count > 0)
{
if (optionsSegs[0].UVEdge || optionsSegs[0].UVShift)
extendedUVData.Add(new SamplePointUData(pos.Count, optionsSegs[0].UVEdge,optionsSegs[0].FirstU, optionsSegs[0].SecondU));
// clamp point at CP and maybe duplicate the next sample point
curDist = optionsSegs[0].Distance;
maxStep = (optionsSegs[0].MaxStepDistance);
dupe = optionsSegs[0].HardEdge || optionsSegs[0].MaterialID != grp.MaterialID || (options.CheckExtendedUV && optionsSegs[0].UVEdge);
if (dupe)
{
// end the current patch...
patch.End = pos.Count;
grp.Patches.Add(patch);
// if MaterialID changes, we start a new MaterialGroup
if (grp.MaterialID != optionsSegs[0].MaterialID)
{
data.MaterialGroups.Add(grp);
grp = new SamplePointsMaterialGroup(optionsSegs[0].MaterialID);
}
// in any case we start a new patch
patch = new SamplePointsPatch(pos.Count + 1);
if (!optionsSegs[0].HardEdge)
softEdges.Add(pos.Count + 1);
// Extended UV
if (optionsSegs[0].UVEdge || optionsSegs[0].UVShift)
extendedUVData.Add(new SamplePointUData(pos.Count+1, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
addPoint(tf);
}
// and remove the CP from the options
optionsSegs.RemoveAt(0);
}
else
{
addPoint(tf);
break;
}
}
}
if (dead <= 0)
Debug.LogError("[Curvy] He's dead, Jim! Deadloop in SplineInputModuleBase.GetSplineData (Optimized)! Please send a bug report!");
// store the last open patch
patch.End = pos.Count - 1;
grp.Patches.Add(patch);
// ExplicitU on last Vertex?
if (optionsSegs.Count > 0 && optionsSegs[0].UVShift)
extendedUVData.Add(new SamplePointUData(pos.Count - 1, optionsSegs[0].UVEdge, optionsSegs[0].FirstU, optionsSegs[0].SecondU));
// if path is closed and no hard edges involved, we need to smooth first normal
if (data.Closed && !spline[0].GetMetadata<MetaCGOptions>(true).HardEdge)
softEdges.Add(0);
data.MaterialGroups.Add(grp);
// fill data
data.SourceF = sourceF.ToArray();
data.F = relF.ToArray();
data.Position = pos.ToArray();
data.Bounds = spline.Bounds;
if (fullPath)
{
((CGPath)data).Direction = tan.ToArray();
data.Normal = up.ToArray();
}
#endregion
break;
}
data.Map = (float[])data.F.Clone();
if (!fullPath)
{
data.RecalculateNormals(softEdges);
if (options && options.CheckExtendedUV)
CalculateExtendedUV(spline,startTF,endTF,extendedUVData, data);
}
return data;
}