void OnSceneGUI()
{
_spline = target as BezierSpline;
_splineT = _spline.transform;
_splineR = Tools.pivotRotation == PivotRotation.Local ? _splineT.rotation : Quaternion.identity;
// Draw curves
Vector3 p0 = ShowPoint(0);
for (int i = 1; i < _spline.ControlPointCount; i += 3) {
Vector3 p1 = ShowPoint(i);
Vector3 p2 = ShowPoint(i + 1);
Vector3 p3 = ShowPoint(i + 2);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
// Show velocity
if(_spline.showVelocity)
{
Vector3 lineStart = _spline.GetPoint(0f);
Handles.color = Color.green;
Handles.DrawLine(lineStart, lineStart + _spline.GetDirection(0f));
int steps = _spline.numIterations * _spline.CurveCount;
for (int i = 1; i <= steps; i++) {
Vector3 lineEnd = _spline.GetPoint(i / (float)steps);
Handles.DrawLine(lineEnd, lineEnd + _spline.GetDirection(i / (float)steps));
}
}
}
public SubTrackGroup(string id, BezierSpline spline, List<SubTrackNode> nodes)
{
Spline = spline;
Nodes = nodes;
Id = id;
foreach (SubTrackNode node in nodes) node.Group = this;
}
public Mesh ExtrudeAlong(BezierSpline spline, Vector3 down)
{
MeshBuilder meshBuilder = new MeshBuilder();
meshBuilder.BeforeNext(Matrix4x4.identity, new Vector3());
Vector3 lastTangent = spline.GetFirstDerivative(0, spline.pts[0]);
Quaternion quat = Quaternion.LookRotation(lastTangent, -down);
Vector3 up = down;
Vertex[] lastVerts = null;
for(int i = 0; i < spline.pts.Length; i ++)
{
BezierSpline.BezierPoint pt = spline.pts[i];
if (Vector3.Distance(pt.startPos, pt.endPos) > 0.001f)
{
int subdivisions = pt.numSubdivisions;
for (int div = 0; div <= subdivisions; div++)
{
float t = div / (float)pt.numSubdivisions;
Vector3 ptT = spline.GetPoint(t, pt);
Vector3 tangent = spline.GetFirstDerivative(t, pt).normalized;
quat = Quaternion.FromToRotation(lastTangent, tangent) * quat;
lastVerts = BuildNextSection(meshBuilder, ptT, tangent, quat, lastVerts);
lastTangent = tangent;
}
}
}
AddCap(meshBuilder, new Vector3[] { lastVerts[0].position, lastVerts[2].position, lastVerts[4].position, lastVerts[6].position }, true);
return meshBuilder.DoneCreateMesh();
}
void OnSceneGUI()
{
b_spline = target as BezierSpline;
handleTransform = b_spline.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ? handleTransform.rotation : Quaternion.identity;
Vector3 point0 = ShowPoint(0);
for (int i = 1; i < b_spline.ControlPointCount; i += 3)
{
Vector3 point1 = ShowPoint(i);
Vector3 point2 = ShowPoint(i + 1);
Vector3 point3 = ShowPoint(i + 2);
Handles.color = Color.gray;
Handles.DrawLine(point0, point1);
Handles.DrawLine(point2, point3);
Handles.DrawBezier(point0, point3, point1, point2, Color.white, null, 2f);
point0 = point3;
}
if (showDirections == true)
{
ShowDirections();
}
}
private void TestToStringWithCulture(CultureInfo culture)
{
CultureInfo originalCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = culture;
try
{
string listSeparator = culture.TextInfo.ListSeparator;
string decimalSeparator = culture.NumberFormat.NumberDecimalSeparator;
var o = new BezierSpline();
var controlPoint1 = new Vec3F(1.1f, 2.2f, 3.3f);
var controlPoint2 = new Vec3F(4.4f, 5.5f, 6.6f);
var controlPoint3 = new Vec3F(7.7f, 8.8f, 9.9f);
var incomingTangent = new Vec3F(-1.0f, -2.0f, -3.0f);
var outgoingTangent = new Vec3F(1.0f, 2.0f, 3.0f);
o.Add(new BezierPoint(controlPoint1, incomingTangent, outgoingTangent));
o.Add(new BezierPoint(controlPoint2, incomingTangent, outgoingTangent));
o.Add(new BezierPoint(controlPoint3, incomingTangent, outgoingTangent));
string s = o.ToString(null, null);
TestToStringResults(o, s, listSeparator, decimalSeparator);
string s2 = o.ToString();
Assert.AreEqual(s, s2);
s = o.ToString("G", culture);
TestToStringResults(o, s, listSeparator, decimalSeparator);
s = o.ToString("R", culture);
TestToStringResults(o, s, listSeparator, decimalSeparator);
}
finally
{
Thread.CurrentThread.CurrentCulture = originalCulture;
}
}
public override void OnInspectorGUI()
{
b_spline = target as BezierSpline;
//showDirections = GUILayout.Toggle(showDirections, "Show Direction");
EditorGUI.BeginChangeCheck();
showDirections = EditorGUILayout.Toggle("Show Directions", b_spline.showDirections);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(b_spline, "Toogle Show Directions");
EditorUtility.SetDirty(b_spline);
b_spline.showDirections = showDirections;
}
EditorGUI.BeginChangeCheck();
bool looped = EditorGUILayout.Toggle("Loop", b_spline.IsLooped);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(b_spline, "Toogle Loop");
EditorUtility.SetDirty(b_spline);
b_spline.IsLooped = looped;
}
if (selectedIndex >= 0 && selectedIndex < b_spline.ControlPointCount)
{
DrawSelectedPointInspector();
}
if (GUILayout.Button("Add Curve"))
{
Undo.RecordObject(b_spline, "Add Curve");
b_spline.AddCurve();
EditorUtility.SetDirty(b_spline);
}
}
private void OnSceneGUI()
{
spline = target as BezierSpline;
handleTransform = spline.transform;
handleRotation = handleTransform.rotation;
Vector3 p0 = ShowPoint (0);
for (int i = 1; i < spline.ControlPointCount; i += 3) {
Vector3 p1 = ShowPoint (i);
Vector3 p2 = ShowPoint (i+1);
Vector3 p3 = ShowPoint (i+2);
Handles.color = Color.gray;
Handles.DrawLine (p0, p1);
Handles.DrawLine (p2, p3);
Handles.DrawBezier (p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
// Handles.color = Color.white;
// Vector3 lineStart = curve.GetPoint (0f);
//
// for (int i = 1; i <= lineSteps; i++) {
// Vector3 lineEnd = curve.GetPoint((float) i/lineSteps);
// Handles.DrawLine(lineStart, lineEnd);
// lineStart = lineEnd;
// }
}
private void OnSceneGUI()
{
spline = target as BezierSpline;
handleTransform = spline.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ?
handleTransform.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0);
for (int i = 1; i < spline.GetControlPointCount(); i += 3)
{
Vector3 p1 = ShowPoint(i);
Vector3 p2 = ShowPoint(i + 1);
Vector3 p3 = ShowPoint(i + 2);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
Handles.color = Color.white;
Vector3 lineStart = spline.GetPoint(i);
for (int step = 0; step <= spline.GetSmoothness(); step++)
{
Vector3 lineEnd = spline.GetPoint(step / (float)spline.GetSmoothness());
Handles.DrawLine(lineStart, lineEnd);
lineStart = lineEnd;
}
//Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 5f);
p0 = p3;
}
//ShowDirections();
}
public override void OnInspectorGUI()
{
spline = target as BezierSpline;
EditorGUI.BeginChangeCheck();
bool loop = EditorGUILayout.Toggle("Loop", spline.Loop);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "Toogle Loop");
EditorUtility.SetDirty(spline);
spline.Loop = loop;
}
if (selectedIndex >= 0 && selectedIndex < spline.ControlPointCount)
{
DrawSelectedPointInspector();
}
if (GUILayout.Button("Add Curve"))
{
Undo.RecordObject(spline, "Add Curve");
spline.AddCurve();
EditorUtility.SetDirty(spline);
}
if (GUILayout.Button("Flip Spline"))
{
Undo.RecordObject(spline, "Add Curve");
EditorUtility.SetDirty(spline);
spline.ReverseSpline();
}
}
public override void OnInspectorGUI()
{
DrawDefaultInspector();
spline = target as BezierSpline;
EditorGUI.BeginChangeCheck();
bool loop = EditorGUILayout.Toggle("Loop Last Point", spline.GetLoop());
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "Loop Last Point");
EditorUtility.SetDirty(spline);
spline.SetLoop(loop);
}
if (selectedIndex >= 0 && selectedIndex < spline.GetControlPointCount())
{
DrawSelectedPointInspector();
}
if (GUILayout.Button("Add Curve"))
{
Undo.RecordObject(spline, "Add Curve");
spline.AddCurve();
EditorUtility.SetDirty(spline);
}
if (GUILayout.Button("Remove Curve"))
{
Undo.RecordObject(spline, "Remove Curve");
spline.RemoveCurve();
EditorUtility.SetDirty(spline);
}
}
void Awake()
{
// Make sure I have the thigs I need to get the data to deform text
if (m_TextComponent == null)
m_TextComponent = gameObject.GetComponent<TextMeshPro>();
if (vertexCurve == null)
vertexCurve = gameObject.GetComponent<BezierSpline>();
UpdateTextPosition();
}
internal void init(RaycastModel rm)
{
raycastModel = rm;
pointerCurve = transform.Find("PointerCurve").gameObject;
pointerCurve.SetActive(false);
pointerSpline = pointerCurve.GetComponent<BezierSpline>();
cardCanvasHelper = GameObject.Find(Constants.cardCanvas).GetComponent<CardCanvasHelperView>();
}
// Use this for initialization
void Start()
{
if (track == null)
{
BezierSpline[] tracks = GameObject.FindObjectsOfType<BezierSpline>();
track = tracks[Random.Range(0, tracks.Length)];
}
t = 0.0f;
transform.position = track.GetPoint(t);
offset = Random.Range(minOffset, maxOffset);
}
public BezierSpline CreateSpline()
{
IList<IControlPoint> points = GetChildList<IControlPoint>(Schema.bezierType.pointChild);
BezierSpline spline = new BezierSpline();
spline.IsClosed = GetAttribute<bool>(Schema.bezierType.isClosedAttribute);
BezierPoint bpt = new BezierPoint();
foreach (var cpt in points)
{
bpt.Position = cpt.Translation;
spline.Add(bpt);
}
return spline;
}
private void TestToStringResults(BezierSpline o, string s, string listSeparator, string decimalSeparator)
{
string[] results = s.Split(new[] { listSeparator }, StringSplitOptions.RemoveEmptyEntries);
// {# of points}, {control point #1}, {cp #2}, {cp #3} where each control point has 3 vectors, each with 3 floats
Assert.AreEqual(results.Length, 1 + 3*3*3);
Assert.True(results[1].Contains(decimalSeparator));
Assert.True(results[2].Contains(decimalSeparator));
Assert.True(results[3].Contains(decimalSeparator));
Assert.AreEqual(int.Parse(results[0]), 3); //3 control points
Assert.AreEqual(float.Parse(results[1]), 1.1f);
Assert.AreEqual(float.Parse(results[2]), 2.2f);
Assert.AreEqual(float.Parse(results[3]), 3.3f);
}
public void Initialize()
{
GuyManager.RegisterGuy( this );
BezierSpline[] splines = FindObjectsOfType<BezierSpline>();
_bezierSpline = splines[ Random.Range( 0, splines.Length ) ];
collider2D.enabled = true;
rigidbody2D.isKinematic = true;
transform.position = _bezierSpline.GetPoint( 0f );
_appliedMoveSpeed = _catchupSpeed;
_percentAlongSpline = 0f;
enabled = true;
}
private void OnSceneGUI () {
spline = target as BezierSpline;
handleTransform = spline.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ?
handleTransform.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0);
for (int i = 1; i < spline.ControlPointCount; i += 3) {
Vector3 p1 = ShowPoint(i);
Vector3 p2 = ShowPoint(i + 1);
Vector3 p3 = ShowPoint(i + 2);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
ShowDirections();
}
private void OnSceneGUI()
{
spline = target as BezierSpline;
handleTransform = spline.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ?
handleTransform.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0);
for (int i = 1; i < spline.ControlPointCount; i += 3)
{
Vector3 p1 = ShowPoint(1);
Vector3 p2 = ShowPoint(2);
Vector3 p3 = ShowPoint(3);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
ShowDirections();
Handles.color = Color.white;
Vector3 lineStart = spline.GetPoint(0f);
Handles.color = Color.green;
Handles.DrawLine(lineStart, lineStart + spline.GetDirection(0f));
for (int i = 1; i <= lineSteps; i++)
{
Vector3 lineEnd = spline.GetPoint(i / (float)lineSteps);
Handles.color = Color.white;
Handles.DrawLine(lineStart, lineEnd);
Handles.color = Color.green;
Handles.DrawLine(lineEnd, lineEnd + spline.GetDirection(i / (float)lineSteps));
lineStart = lineEnd;
}
}
public OrientedPoint[] GeneratePath()
{
BezierSpline bezierSpline = GetComponent <BezierSpline> ();
if (bezierSpline == null)
{
Debug.Log("No bezier spline curve assigned to the game object");
return(null);
}
int numPoints = (int)Mathf.Ceil(bezierSpline.GetSplineLenght() / pathIncrementSize);
float realIncrementSize = bezierSpline.GetSplineLenght() / numPoints;
OrientedPoint[] path = new OrientedPoint[numPoints];
for (int i = 0; i < numPoints; i++)
{
path [i].position = bezierSpline.GetPointFromParametricValue(i * realIncrementSize);
path [i].rotation = bezierSpline.GetOrientationFromParametricValue(i * realIncrementSize);
path [i].cumulDistance = i * realIncrementSize;
}
return(path);
}
// Use a spline to move from point A to point B
public void moveBySpline(BezierSpline _spline, Vector3 _pointA, Vector3 _pointB, float _duration)
{
spline = Instantiate(_spline.gameObject).GetComponent <BezierSpline>();
duration = _duration;
moving = true;
progress = 0f;
// Compute some necessary vectors
Vector3 splineStart = spline.GetPoint(0f);
Vector3 splineEnd = spline.GetPoint(1f);
Vector3 desiredAtoB = _pointB - _pointA;
Vector3 splineAtoB = splineEnd - splineStart;
// Scale as necessary
float scale = desiredAtoB.magnitude / splineAtoB.magnitude;
spline.transform.localScale *= scale;
// Rotate as necessary
Vector3 orthogonalAxis = Vector3.Cross(desiredAtoB, splineAtoB);
const float min_ortho_magnitude = 0.00001f;
if (orthogonalAxis.magnitude < min_ortho_magnitude)
{
orthogonalAxis = Vector3.up; // TODO - is this the right default? And is this ever being called?
}
float angleBetween = Vector3.SignedAngle(splineAtoB, desiredAtoB, orthogonalAxis);
// TODO - is this supposed to be around spline.transform.position? Need to move to origin first?
spline.transform.RotateAround(spline.transform.position, orthogonalAxis, angleBetween);
// Move starting position to pointA
splineStart = spline.GetPoint(0f);
spline.transform.position += transform.position - splineStart;
}
private void OnSceneGUI()
{
spline = target as BezierSpline;
handleTransform = spline.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ?
handleTransform.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0);
for (int i = 1; i < spline.ControlPointCount; i += 3)
{
Vector3 p1 = ShowPoint(i);
Vector3 p2 = ShowPoint(i + 1);
Vector3 p3 = ShowPoint(i + 2);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
ShowDirections();
}
public override void OnInspectorGUI()
{
spline = target as BezierSpline;
EditorGUI.BeginChangeCheck();
bool loop = EditorGUILayout.Toggle("Loop", spline.Loop);
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "Toggle Loop");
EditorUtility.SetDirty(spline);
spline.Loop = loop;
}
if (selectedIndex >= 0 && selectedIndex < spline.ControlPointCount)
{
DrawSelectedPointInspector();
}
if (GUILayout.Button("Add Curve"))
{
Undo.RecordObject(spline, "Add Curve");
spline.AddCurve();
EditorUtility.SetDirty(spline);
}
}
private void OnSceneGUI()
{
BezierSpline spline = (BezierSpline)target;
Transform handle = spline.transform;
Quaternion handleRotation = Tools.pivotRotation == PivotRotation.Local ? handle.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0, spline, handle, handleRotation);
for (int i = 1; i < spline.ControlPointCount; i += 3)
{
Vector3 p1 = ShowPoint(i, spline, handle, handleRotation);
Vector3 p2 = ShowPoint(i + 1, spline, handle, handleRotation);
Vector3 p3 = ShowPoint(i + 2, spline, handle, handleRotation);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
ShowDirections(spline);
}
// ######################## UNITY EVENT FUNCTIONS ######################## //
protected override void OnSceneGUI()
{
base.OnSceneGUI();
_spline = target as BezierSpline;
// draw the spline
Vector3 p0 = ShowPoint(0, MODE_COLORS[(int)_spline.GetControlPointMode(0)]);
for (int i = 1; i < _spline.ControlPointCount; i += 3)
{
Vector3 p1 = ShowPoint(i, MODE_COLORS[(int)_spline.GetControlPointMode(i)]);
Vector3 p2 = ShowPoint(i + 1, MODE_COLORS[(int)_spline.GetControlPointMode(i + 1)]);
Vector3 p3 = ShowPoint(i + 2, MODE_COLORS[(int)_spline.GetControlPointMode(i + 2)]);
Handles.color = Color.gray;
Handles.DrawLine(p0, p1);
Handles.DrawLine(p2, p3);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
ShowDirections();
}
public void GenerateTrack()
{
trackPoints.Clear();
Vector3 point = Vector3.zero;
float radiusAmount = 0f;
centerTrackPoints = new Vector3[curvePoints];
// Set Curves on Bezier Spline
bezierSpline = GetComponent<BezierSpline> ();
bezierSpline.Reset ();
// bezierSpline.ClearControlPoints ();
bezierSpline.Loop = true;
bezierSpline.OnBezierPointChanged = UpdateTrackMesh;
for (int i = 0; i < curvePoints; i++)
{
radiusAmount = ((float)i / curvePoints) * (2*Mathf.PI);
point = new Vector3(radius.x * Mathf.Cos (frequency.x * radiusAmount), 0f, radius.y * Mathf.Sin (frequency.y * radiusAmount));
point = point * radiusSizeFactor;
centerTrackPoints[i] = point;
trackPoints.Add (point);
// Set points in the Bezier curve
if (i > 0 && i % 3 == 0)
bezierSpline.AddCurve ();
bezierSpline.SetControlPoint (i, point);
}
UpdateTrackMesh ();
}
// 绘制贝塞尔点的面板，返回值为是否刷新检视面板
private static bool DrawBezierPointInspector(BezierSpline bs, int index, ref int insertID, ref int removeID, ref int selectedID)
{
bool refreshSv = false;
GUI.backgroundColor = index == selectedID ? Color.yellow : Color.cyan;
if (bs != null && bs.Count > index)
{
EditorGUILayout.BeginVertical(EditorStyles.textField);
BezierPoint point = bs[index];
if (point == null)
{
Undo.RecordObject(bs, "add bezier point");
bs[index] = new BezierPoint();
EditorUtility.SetDirty(bs);
point = bs[index];
refreshSv = true;
}
Vector3 pos = point.Position;
pos = EditorGUILayout.Vector3Field("Postion", pos);
if (point.Position != pos)
{
point.Position = pos;
refreshSv = true;
}
EditorGUILayout.BeginHorizontal();
point.type = (BezierPoint.PointType)EditorGUILayout.EnumPopup("Type", point.type);
point.Percent = EditorGUILayout.FloatField("Percent", point.Percent);
EditorGUILayout.EndHorizontal();
EditorGUILayout.BeginHorizontal();
if (selectedID == index)
{
if (GUILayout.Button("UnSelect", EditorStyles.miniButtonLeft))
{
selectedID = -1; refreshSv = true;
}
}
else
{
if (GUILayout.Button("Select", EditorStyles.miniButtonLeft))
{
selectedID = index; refreshSv = true;
}
}
if (GUILayout.Button("Focus", EditorStyles.miniButtonMid))
{
SceneView.lastActiveSceneView.LookAt(pos);
}
if (GUILayout.Button("Insert", EditorStyles.miniButtonMid))
{
insertID = index; refreshSv = true;
}
if (GUILayout.Button("Remove", EditorStyles.miniButtonRight))
{
removeID = index; refreshSv = true;
}
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
GUI.backgroundColor = BackgroundColor;
return(refreshSv);
}
private void OnSceneGUI()
{
BezierSpline spline = (BezierSpline)target;
Transform transform = spline.transform;
Quaternion handleRot = Tools.pivotRotation == PivotRotation.Local ? transform.rotation : Quaternion.identity;
/* Transform points of each curve into world space */
List <Vector3[]> worldCurves = new List <Vector3[]>();
//foreach(Vector3[] curve in spline.curves)
foreach (Points curve in spline.curves)
{
Vector3[] worldCurve = new Vector3[curve.points.Length];
for (int i = 0; i < curve.points.Length; i++)
{
worldCurve[i] = transform.TransformPoint(curve.points[i]);
}
worldCurves.Add(worldCurve);
}
/* Loop through each world space curve in the spline and update handles/lines/curves for it */
for (int i = 0; i < worldCurves.Count; i++)
{
Vector3[] curve = worldCurves[i];
/* Draw handle line */
Handles.color = i == selectedCurveIndex ? SplineUIParams.selectedHandleLineColour : SplineUIParams.handleLineColour;
for (int j = 1; j < curve.Length; j++)
{
Handles.DrawLine(curve[j - 1], curve[j]);
}
/* show handle for and update each point on curve */
for (int j = 0; j < curve.Length; j++)
{
Vector3 p = curve[j];
//display dot button for each curve point; only display handle of selected point
//selectedIndex must persist between OnSceneGUI() calls or the handle will only appear for one call
float size = HandleUtility.GetHandleSize(p);
Handles.color = SplineUIParams.handleColour;
if (Handles.Button(p, handleRot, size * SplineUIParams.handleSize,
size * SplineUIParams.handlePickSize, Handles.DotHandleCap))
{
selectedCurveIndex = i;
selectedPointIndex = j;
}
//display move handle for selected point
if (i == selectedCurveIndex && j == selectedPointIndex)
{
EditorGUI.BeginChangeCheck();
p = Handles.DoPositionHandle(p, handleRot); //DoPositionHandle creates an editor Handle at position and rotation
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "Move Bezier Curve Point"); //allow handle move to be undone with Undo
EditorUtility.SetDirty(spline); //set line to dirty so Unity knows a change was made and asks to save before closing etc.
//Transform moved world point back to local position and update selected point with it
Vector3 localPoint = transform.InverseTransformPoint(p);
spline.curves[i].points[j] = localPoint;
//If selected point is the last point of non-last curve in the spline, move first point of next curve to match;
//if selected point is the first point of non-first curve in the spline, move last point of previous curve to match
if (j == spline.curves[i].points.Length - 1 && i < spline.curves.Count - 1)
{
spline.curves[i + 1].points[0] = localPoint;
}
else if (j == 0 && i > 0)
{
spline.curves[i - 1].points[spline.curves[i - 1].points.Length - 1] = localPoint;
}
}
}
}
/* draw curve as line segments */
float segmentLength = SplineUIParams.GetCurveSegmentLength(curve);
Color curveCol = i == selectedCurveIndex ? SplineUIParams.selectedCurveColour : SplineUIParams.curveColour;
for (float t = segmentLength; t <= 1; t += segmentLength)
{
Handles.color = curveCol;
Handles.DrawLine(spline.GetWorldPoint(i, t - segmentLength), spline.GetWorldPoint(i, t));
if (showTangents)
{
Handles.color = SplineUIParams.tanColour;
//Handles.DrawLine(spline.)
}
if (showNormals)
{
Handles.color = SplineUIParams.normalColour;
//show normals
}
}
}
}
void ReallocateNodeOverSpline(Transform node, BezierSpline spline, int depth)
{
float newPosition;
// Collide with spline that can belong to 2 possible objects, biffurcation or curve
Curve curve = spline.transform.parent.GetComponent <Curve>();
Bifurcation bifurcation = spline.transform.parent.GetComponent <Bifurcation>();
if (curve != null)
{// we are in a curve
Debug.DrawLine(transform.position, nodeToFollow.position, Color.cyan);
}
if (bifurcation != null)
{// we are in a bifurcation
if (bifurcation.splines[0].isPath)
{
spline = bifurcation.splines[0];
}
else
{
spline = bifurcation.splines[1];
}
}
newPosition = spline.GetClosestPoint(transform.position + transform.forward * distToNode, 0.01f);
nodeToFollow.position = spline.GetPoint(newPosition);
nodeToFollow.rotation = spline.GetOrientation(newPosition, transform.up);
// end or beggining of spline reached, check next/previous spline
if (newPosition == 2)
{ // jump to previous spline
if (depth == 1)
{ // avoid infinite recursive loops
nodeToFollow.position = spline.startNode.transform.position;
nodeToFollow.rotation = spline.startNode.transform.rotation;
return;
}
RaycastHit hit;
Vector3 dir = -spline.startNode.transform.forward;
//if (spline.startNode.reverse == true) dir *= -1;
if (Physics.Raycast(spline.startNode.position + dir + new Vector3(0, 2, 0), -transform.up, out hit, 30))
{
spline = hit.collider.transform.GetComponent <BezierSpline>();
}
ReallocateNodeOverSpline(nodeToFollow, spline, 1);
}
if (newPosition == 3)
{ // jump to next spline
if (depth == 1)
{ // avoid infinite recursive loops
nodeToFollow.position = spline.endNode.transform.position;
nodeToFollow.rotation = spline.endNode.transform.rotation;
return;
}
RaycastHit hit;
Vector3 dir = spline.endNode.transform.forward;
//if (spline.endNode.reverse == true)
// dir *= -1;
if (Physics.Raycast(spline.endNode.position + dir + new Vector3(0, 2, 0), -transform.up, out hit, 30))
{
spline = hit.collider.transform.GetComponent <BezierSpline>();
}
ReallocateNodeOverSpline(nodeToFollow, spline, 1);
}
}
public SplineInterpolator(IEnumerable <Vector3> points)
{
_spline = new BezierSpline(points.ToList());
}
void Awake()
{
float xCenterOffset = _bodyScale * (float)(_horizontalQuads - 1) / 2f;
// Generate mesh from piece info
MeshFilter meshFilter = GetComponent <MeshFilter>();
List <Vector3> vertices = new List <Vector3>();
List <Vector2> uvs = new List <Vector2>();
List <int> triangles = new List <int>();
int appliedVerticalQuads = _verticalQuads * _bodyLength;
for (int y = 0; y < appliedVerticalQuads; y++)
{
for (int x = 0; x < _horizontalQuads; x++)
{
vertices.Add(new Vector3(x * _bodyScale - xCenterOffset, y * _bodyScale));
uvs.Add(new Vector2(x / (float)(_horizontalQuads - 1), y / (float)(appliedVerticalQuads - 1)));
if (x != 0 && y != 0)
{
int topRight = y * _horizontalQuads + x;
int topLeft = y * _horizontalQuads + x - 1;
int bottomRight = (y - 1) * _horizontalQuads + x;
int bottomLeft = (y - 1) * _horizontalQuads + x - 1;
triangles.Add(bottomLeft);
triangles.Add(topLeft);
triangles.Add(topRight);
triangles.Add(bottomRight);
triangles.Add(bottomLeft);
triangles.Add(topRight);
}
}
}
Mesh mesh = meshFilter.mesh;
mesh.Clear();
mesh.vertices = vertices.ToArray();
mesh.uv = uvs.ToArray();
mesh.triangles = triangles.ToArray();
mesh.UploadMeshData(false);
// Generate texture from pieces
List <Texture2D> texturesToStitch = new List <Texture2D>();
texturesToStitch.Add(_feetTextures[Random.Range(0, _feetTextures.Length)]);
for (int i = 0; i < _bodyLength - 2; i++)
{
texturesToStitch.Add(_bodyTextures[Random.Range(0, _bodyTextures.Length)]);
}
texturesToStitch.Add(_topTextures[Random.Range(0, _topTextures.Length)]);
int totalHeight = _bodyLength * texturesToStitch[0].height;
int prevY = 0;
_stitchedTexture = new Texture2D(texturesToStitch[0].width, totalHeight);
for (int i = 0; i < texturesToStitch.Count; i++)
{
_stitchedTexture.SetPixels(0, prevY, texturesToStitch[i].width, texturesToStitch[i].height, texturesToStitch[i].GetPixels());
prevY += texturesToStitch[i].height;
}
_stitchedTexture.Apply();
renderer.material.SetTexture("_MainTex", _stitchedTexture);
int colorPairIndex = Random.Range(0, _colorPairs.Length);
renderer.material.SetColor("_FurColor", _colorPairs[colorPairIndex].furColor);
renderer.material.SetColor("_SkinColor", _colorPairs[colorPairIndex].skinColor);
Renderer handRenderer = FindObjectOfType <MonsterArmTag>().renderer;
handRenderer.material.SetColor("_FurColor", _colorPairs[colorPairIndex].furColor);
handRenderer.material.SetColor("_SkinColor", _colorPairs[colorPairIndex].skinColor);
// Generate paths for guys to travel along
// F**k this forever
for (int i = 0; i < _numPathsToCreate; i++)
{
GameObject guyPathObj = new GameObject("GuyPath", typeof(BezierSpline));
guyPathObj.transform.parent = transform;
BezierSpline guyPathSpline = guyPathObj.GetComponent <BezierSpline>();
guyPathSpline.Reset();
for (int j = 0; j < texturesToStitch.Count - 1; j++)
{
guyPathSpline.AddCurve();
}
for (int j = 0; j < guyPathSpline.ControlPointCount; j++)
{
if (j == 0)
{
// Set at one of the foot points
guyPathSpline.SetControlPoint(j, Vector3.zero + Vector3.right * _footSpawnXOffset * Mathf.Sign(Random.value - 0.5f));
guyPathSpline.SetControlPoint(j + 1, guyPathSpline.GetControlPoint(j) + Vector3.up);
}
else if (j == guyPathSpline.ControlPointCount - 1)
{
// Last point
guyPathSpline.SetControlPoint(j, Vector3.up * _bodyScale * (appliedVerticalQuads - _verticalQuads / 2f));
guyPathSpline.SetControlPoint(j - 1, guyPathSpline.GetControlPoint(j) - Vector3.up);
}
else if (j % 3 == 0)
{
guyPathSpline.SetControlPoint(j, Vector3.up * j / 3f * _verticalQuads * _bodyScale + Vector3.right * Random.Range(-_spawnXOffset, _spawnXOffset));
guyPathSpline.SetControlPointMode(j, BezierControlPointMode.Mirrored);
guyPathSpline.SetControlPoint(j + 1, guyPathSpline.GetControlPoint(j) + Vector3.up);
}
}
}
// Setup collider
BoxCollider2D boxCollider = gameObject.AddComponent <BoxCollider2D>();
Vector2 boxScale = boxCollider.size;
boxScale.Scale(_boxSizeScale);
boxCollider.size = boxScale;
}
void OnEnable()
{
spline = (BezierSpline)target;
}
//Function called from Update to get the position where the player ship will be
private Vector3 LeadShipPosition()
{
//The vec3 position that we return
Vector3 targetPos = this.targetPlayer.transform.position;
//Float that holds the position between our muzzle and the player ship
float distToTarget = Vector3.Distance(this.ourWeapon.muzzleAudio.transform.position, targetPos);
//Finding the amount of time it would take for our weapon's projectile would take to cover that distance
//Using the formula Velocity = Distance / Time ===> Time = Distance / Velocity
float projectileTime = distToTarget / this.ourWeapon.firedProjectile.forwardVelocity;
//Now that we know about how long it will take for the projectile to reach the player's CURRENT position,
//We need to guess how far along they will be using their current velocity
//If the ship is in a free movement zone, we use their forward velocity
if (this.targetPlayer.ourFreeMovement.enabled)
{
//Getting the direction and magnitude that the velocity is facing
Vector3 velocityOffset = this.targetPlayer.ourRailMovement.railParentObj.ourRigidbody.velocity;
//Multiplying the velocity
velocityOffset = velocityOffset * projectileTime;
//Adding the forward velocity offset to the target position
targetPos += velocityOffset;
}
//If the ship is in a rail movement zone, we need to use the rail position
else if (this.targetPlayer.ourRailMovement.enabled && this.targetPlayer.ourRailMovement.railParentObj.ourSplineMoveRB.splineToFollow != null)
{
//Getting the reference to the spline that the target ship is moving on
BezierSpline shipSpline = this.targetPlayer.ourRailMovement.railParentObj.ourSplineMoveRB.splineToFollow;
//Getting the current amount of time that the ship has already traveled
float currentSplineTime = this.targetPlayer.ourRailMovement.railParentObj.ourSplineMoveRB.CurrentSplineTime;
//Getting the total time that the player will have to travel along the spline
float totalSplineTime = this.targetPlayer.ourRailMovement.railParentObj.ourSplineMoveRB.timeToComplete;
//Getting the speed multiplier that the player is moving at
float speedMultiplier = this.targetPlayer.ourRailMovement.railParentObj.ourSplineMoveRB.speedMultiplier;
//Getting the adjusted percent along the spline that the player is currently at
float adjustedCurrentPercent = currentSplineTime / totalSplineTime;
adjustedCurrentPercent = shipSpline.GetAdjustedPercentFromTime(adjustedCurrentPercent);
//Getting the adjusted percent along the spline that the player is going to be at
float adjustedTargetPercent = projectileTime * (speedMultiplier);
adjustedTargetPercent += currentSplineTime;
adjustedTargetPercent = adjustedTargetPercent / totalSplineTime;
adjustedTargetPercent = shipSpline.GetAdjustedPercentFromTime(adjustedTargetPercent);
//Getting the position along the spline that the ship will be at when taking into account the projectile time
targetPos = shipSpline.GetPoint(adjustedTargetPercent);
//Finding the offset that the player ship is from the rail center
Vector3 currentOffset = this.targetPlayer.transform.InverseTransformPoint(shipSpline.GetPoint(adjustedCurrentPercent));
currentOffset = new Vector3(-currentOffset.x, -currentOffset.y, -currentOffset.z);
//Adding the offset that the player ship is from the target position
targetPos += shipSpline.GetQuaternionAtPercent(adjustedTargetPercent) * currentOffset;
}
//Returning our target pos
return(targetPos);
}
public void SetTrack(BezierSpline track, float t, bool reverse)
{
this.track = track;
this.t = t;
}
// Use this for initialization
void Start()
{
spline = GetComponent<BezierSpline>();
}
private void AssertSplinePt(BezierSpline.BezierPoint pt, Vector3 expectedStartPos, Vector3 expectedEndPos, Vector3? expectedAnchor1 = null, Vector3? expectedAnchor2 = null)
{
Assert.That(pt.startPos, Is.EqualTo(expectedStartPos));
Assert.That(pt.endPos, Is.EqualTo(expectedEndPos));
if (expectedAnchor1 != null)
{
Assert.That(pt.anchor1, Is.EqualTo(expectedAnchor1));
}
if (expectedAnchor2 != null)
{
Assert.That(pt.anchor2, Is.EqualTo(expectedAnchor2));
}
}
// Use this for initialization
void Start()
{
t = 0;
currentSpline = startingSpline;
transform.position = currentSpline.GetPoint(t);
transform.rotation = currentSpline.GetOrientation(t, Vector3.Lerp(currentSpline.startNode.transform.up, currentSpline.endNode.transform.up, t));
lastForward = transform.forward;
}
void ChangeToNextSpline()
{
TrackElement currentCurve = currentSpline.curve;
if (currentSpline.curve.GetType() == typeof(Curve))
{// If we are in a Curve
int currentSplineIndex = currentCurve.splines.IndexOf(currentSpline);
if (!reverse)
{
// If there are more splines in the current curve, change to next
if (currentSplineIndex + 1 <= currentCurve.splines.Count - 1)
{
currentSpline = currentCurve.splines[currentSplineIndex + 1];
t = t - 1;
return;
}
else
{ // Jump to next TrackElement
if (((Curve)currentCurve).nextCurve.GetType() == typeof(Curve))
{// Jump from curve to curve
Curve nextCurve = (Curve)((Curve)currentCurve).nextCurve;
if (nextCurve.nextCurve == currentCurve)
{// --->/<---
currentSpline = nextCurve.splines[nextCurve.splines.Count - 1];
reverse = true;
// Update t
t = 1 - (t - 1);
}
else if (nextCurve.previousCurve == currentCurve)
{// --->/--->
currentSpline = nextCurve.splines[0];
reverse = false;
// Update t
t = t - 1;
}
}
if (((Curve)currentCurve).nextCurve.GetType() == typeof(Bifurcation))
{// Jump from curve to bifurcation.
Bifurcation nextBifurcation = (Bifurcation)((Curve)currentCurve).nextCurve;
if (nextBifurcation.nextCurveRight == currentCurve)
{// --->/---> (From Right path to Start)
currentSpline = nextBifurcation.splines[0];
reverse = true;
// Update t
t = 1 - (t - 1);
}
else if (nextBifurcation.nextCurveLeft == currentCurve)
{// --->/---> (From Left path to Start)
currentSpline = nextBifurcation.splines[1];
reverse = true;
// Update t
t = 1 - (t - 1);
}
// Here we are sure that we are entering the bifurcation from the start node.
else if (nextBifurcation.splines[0].isPath)
{// --->/---> (From Start to Right path)
currentSpline = nextBifurcation.splines[0];
reverse = false;
// Update t
t = t - 1;
}
else if (nextBifurcation.splines[1].isPath)
{// --->\---> (From Start to Left path)
currentSpline = nextBifurcation.splines[1];
reverse = false;
// Update t
t = t - 1;
}
}
}
}
else // reverse mode
{
// If there are more splines in the current curve, change to previous spline
if (currentSplineIndex - 1 >= 0)
{
currentSpline = currentCurve.splines[currentSplineIndex - 1];
t = 1 + t;
return;
}
else
{ // Jump to next TrackElement
if (((Curve)currentCurve).previousCurve.GetType() == typeof(Curve))
{// Jump to curve
Curve previousCurve = (Curve)((Curve)currentCurve).previousCurve;
if (previousCurve.nextCurve == currentCurve)
{// <---/<---
currentSpline = previousCurve.splines[((Curve)currentCurve).previousCurve.splines.Count - 1];
reverse = true;
// Update t
t = t + 1;
}
else if (previousCurve.previousCurve == currentCurve)
{// <---/--->
currentSpline = previousCurve.splines[0];
reverse = false;
// Update t
t = 1 - (t + 1);
}
}
if (((Curve)currentCurve).previousCurve.GetType() == typeof(Bifurcation))
{// Jump from curve to bifurcation.
Bifurcation nextBifurcation = (Bifurcation)(((Curve)currentCurve).previousCurve);
if (nextBifurcation.nextCurveRight == currentCurve)
{// --->/---> (From Right path to Start)
currentSpline = nextBifurcation.splines[0];
reverse = true;
// Update t
t = 1 + t;
}
else if (nextBifurcation.nextCurveLeft == currentCurve)
{// --->\---> (From Left path to Start)
currentSpline = nextBifurcation.splines[1];
reverse = true;
// Update t
t = 1 + t;
}
else if (nextBifurcation.previousCurve == currentCurve)
{// --->\---> (From Start to..)
if (nextBifurcation.splines[0].isPath)
{// --->/---> (From Start to Right path)
currentSpline = nextBifurcation.splines[0];
reverse = false;
// Update t
t = 1 - (1 - t);
}
else if (nextBifurcation.splines[1].isPath)
{// --->\---> (From Start to Left path)
currentSpline = nextBifurcation.splines[1];
reverse = false;
// Update t
t = 1 - (1 - t);
}
}
}
}
}
}
else if(currentSpline.curve.GetType() == typeof(Bifurcation))
{// If we are in a Bifurcation
Bifurcation bifurcation = (Bifurcation)currentSpline.curve;
if (!reverse)
{
// Start to Right
if (currentSpline == bifurcation.splines[0] && bifurcation.nextCurveRight.previousCurve == bifurcation)
{// Start to Straight Right
if (bifurcation.nextCurveRight.GetType() == typeof(Bifurcation))
{// bifurcation to bifurcation
Bifurcation nextBifurcation = (Bifurcation)(bifurcation.nextCurveRight);
if (nextBifurcation.splines[0].isPath) currentSpline = nextBifurcation.splines[0];
else if (nextBifurcation.splines[1].isPath) currentSpline = nextBifurcation.splines[1];
reverse = false;
// Update t
t = t - 1;
}
else
{// bifurcation to Straight curve
currentSpline = bifurcation.nextCurveRight.splines[0];
reverse = false;
// Update t
t = t - 1;
}
}
else if (currentSpline == bifurcation.splines[0])
{// Start to Reverse Curve
currentSpline = bifurcation.nextCurveRight.splines[bifurcation.nextCurveRight.splines.Count - 1];
reverse = true;
// Update t
t = 1 - (1 - t);
}
// Start to Left
if (currentSpline == bifurcation.splines[1] && bifurcation.nextCurveLeft.previousCurve == bifurcation)
{// Start to Straight Left
if (bifurcation.nextCurveLeft.GetType() == typeof(Bifurcation))
{// bifurcation to bifurcation
Bifurcation nextBifurcation = (Bifurcation)(bifurcation.nextCurveLeft);
if (nextBifurcation.splines[0].isPath) currentSpline = nextBifurcation.splines[0];
else if (nextBifurcation.splines[1].isPath) currentSpline = nextBifurcation.splines[1];
reverse = false;
// Update t
t = t - 1;
}
else
{// bifurcation to Straight curve
currentSpline = bifurcation.nextCurveLeft.splines[0];
reverse = false;
// Update t
t = t - 1;
}
}
else if (currentSpline == bifurcation.splines[1])
{// Start to Reverse Curve
currentSpline = bifurcation.nextCurveLeft.splines[bifurcation.nextCurveLeft.splines.Count - 1];
reverse = true;
// Update t
t = 1 - (1 - t);
}
}
else
{// Reverse mode
if (bifurcation.previousCurve.GetType() == typeof(Bifurcation))
{// back to another bifurcation
Bifurcation previousBif = (Bifurcation)bifurcation.previousCurve;
if (previousBif.nextCurveRight == bifurcation) currentSpline = previousBif.splines[0];
if (previousBif.nextCurveLeft == bifurcation) currentSpline = previousBif.splines[1];
reverse = true;
t = t + 1;
}
else
{// back to a Curve
currentSpline = bifurcation.previousCurve.splines[bifurcation.previousCurve.splines.Count-1];
reverse = true;
t = t + 1;
}
}
}
return;
}
void SetOrder()
{
lastHead = 0;
splineNumber = 0;
for (int i = 1; i < segments.Length-1; i++) {
// spline = segments [current].GetComponent<RailComponent> ().rail;
spline = segments[i].GetComponent<RailComponent>().rail;
// Debug.Log (spline);
segments[i].GetComponent<RailComponent>().railNumber = splineNumber;
if(segments[i+1].GetComponent<RailComponent>().rail == segments[i].GetComponent<RailComponent>().rail){
segments[i].GetComponent<RailComponent>().next = segments[i+1].GetComponent<RailComponent>().transform;
} else {
segments[i].GetComponent<RailComponent>().tail = true;
segments[i].GetComponent<RailComponent>().GetComponent<Collider>().enabled = false;
lastTail = i;
// tails[splineNumber] = i;
splineNumber++;
// Debug.Log(spline.Loop);
if(spline.Loop){
Debug.Log("Loop me!");
segments[i].GetComponent<RailComponent>().next = segments[lastHead].GetComponent<RailComponent>().transform;
segments[lastHead].GetComponent<RailComponent>().last = segments[i].GetComponent<RailComponent>().transform;
}
segments[i+1].GetComponent<RailComponent>().head = true;
segments[i+1].GetComponent<RailComponent>().GetComponent<Collider>().enabled = false;
lastHead = i+1;
// Debug.Log("LH: "+lastHead);
// heads[splineNumber] = i+1;
}
if(segments[i-1].GetComponent<RailComponent>().rail == segments[i].GetComponent<RailComponent>().rail){
segments[i].GetComponent<RailComponent>().last = segments[i-1].GetComponent<RailComponent>().transform;
}
}
segments[0].GetComponent<RailComponent>().next = segments[1].GetComponent<RailComponent>().transform;
segments[0].GetComponent<RailComponent>().head = true;
segments[0].GetComponent<RailComponent>().GetComponent<Collider>().enabled = false;
segments [0].GetComponent<RailComponent> ().railNumber = 0;
segments[segments.Length-1].GetComponent<RailComponent>().tail = true;
segments[segments.Length-1].GetComponent<RailComponent>().GetComponent<Collider>().enabled = false;
segments[segments.Length-1].GetComponent<RailComponent>().last = segments[segments.Length - 2].GetComponent<RailComponent>().transform;
segments[segments.Length-1].GetComponent<RailComponent>().railNumber = splineNumber;
spline = segments [segments.Length - 1].GetComponent<RailComponent> ().rail;
if (spline.Loop) {
segments[segments.Length - 1].GetComponent<RailComponent>().next = segments[lastHead].GetComponent<RailComponent>().transform;
segments[lastHead].GetComponent<RailComponent>().last = segments[segments.Length - 1].GetComponent<RailComponent>().transform;
}
// Debug.Log (segments [segments.Length - 1].GetComponent<RailComponent> ().next);
// segments[0].GetComponent<RailComponent>().last = segments[segments.Length].GetComponent<RailComponent>().transform;
}
void Update()
{
if (applicationExiting)
{
return;
}
if (cameraTexture == null || predictionTexture == null || carController == null)
{
return;
}
ogmaneo.Vec2i pixelPos = new Vec2i();
// Remember currently active render texture
RenderTexture currentActiveRT = RenderTexture.active;
// Transfer the camera capture into the prediction texture (temporarily)
RenderTexture.active = cameraTexture;
predictionTexture.ReadPixels(new Rect(0, 0, _inputWidth, _inputHeight), 0, 0);
predictionTexture.Apply();
// Restore active render texture
RenderTexture.active = currentActiveRT;
// Transfer the RGB camera texture into ValueField2D fields
Color actualPixel = new Color();
Color yuvPixel = new Color(0.0f, 0.0f, 0.0f);
for (int x = 0; x < _inputWidth; x++)
{
for (int y = 0; y < _inputHeight; y++)
{
actualPixel = predictionTexture.GetPixel(x, y);
// SDTV (BT.601) Y'UV conversion
yuvPixel.r = actualPixel.r * 0.299f + actualPixel.g * 0.587f + actualPixel.b * 0.114f; // Y' luma component
// Chrominance
// U = r * -0.14713 + g * -0.28886 + b * 0.436
//yuvPixel.g = 0.0f;
// V = r * 0.615 + g * -0.51499 + b * -0.10001
//yuvPixel.b = 0.0f;
predictionTexture.SetPixel(x, y, yuvPixel);
}
}
// Edge Detection Convolution methods:
// Laplacian of the Gaussian (LoG) - https://en.wikipedia.org/wiki/Blob_detection#The_Laplacian_of_Gaussian
// - Sobel-Feldman and Sharr operators - https://en.wikipedia.org/wiki/Sobel_operator
// - Prewitt operator - https://en.wikipedia.org/wiki/Prewitt_operator
// Kirch operator - https://en.wikipedia.org/wiki/Kirsch_operator
Texture2D horzTexture = ConvolutionFilter.Apply(predictionTexture, ConvolutionFilter.Sobel3x3Horizontal); // ConvolutionFilter.Prewitt3x3Horizontal);
Texture2D vertTexture = ConvolutionFilter.Apply(predictionTexture, ConvolutionFilter.Sobel3x3Vertical); // ConvolutionFilter.Prewitt3x3Vertical);
Texture2D convolvedTexture = new Texture2D(_inputWidth, _inputHeight, predictionTexture.format, false);
Color tempPixel = new Color(0.0f, 0.0f, 0.0f);
for (int x = 0; x < _inputWidth; x++)
{
for (int y = 0; y < _inputHeight; y++)
{
Color horzPixel = horzTexture.GetPixel(x, y);
Color vertPixel = vertTexture.GetPixel(x, y);
tempPixel.r = Mathf.Sqrt((horzPixel.r * horzPixel.r) + (vertPixel.r * vertPixel.r));
tempPixel.g = tempPixel.r; // Mathf.Sqrt((horzPixel.g * horzPixel.g) + (vertPixel.g * vertPixel.g));
tempPixel.b = tempPixel.r; // Mathf.Sqrt((horzPixel.b * horzPixel.b) + (vertPixel.b * vertPixel.b));
convolvedTexture.SetPixel(x, y, tempPixel);
}
}
predictionTexture.SetPixels(convolvedTexture.GetPixels());
predictionTexture.Apply();
// Transfer the RGB camera texture into ValueField2D fields
for (int x = 0; x < _inputWidth; x++)
{
for (int y = 0; y < _inputHeight; y++)
{
actualPixel = predictionTexture.GetPixel(x, y);
pixelPos.x = x;
pixelPos.y = y;
_inputField.setValue(pixelPos, actualPixel.r);
previousImage[x, y] = sourceImage[x, y];
sourceImage[x, y] = actualPixel.r;// * 0.299f + actualPixel.g * 0.587f + actualPixel.b * 0.114f;
}
}
// Encode scalar values from the car controller
Steer = carController.CurrentSteerAngle / carController.m_MaximumSteerAngle;
Accel = carController.AccelInput;
Brake = carController.BrakeInput;
pixelPos.x = 0;
pixelPos.y = 0;
_inputValues.setValue(pixelPos, Steer);
// Setup the hierarchy input vector
vectorvf inputVector = new vectorvf();
inputVector.Add(_inputField);
inputVector.Add(_inputValues);
// Step the hierarchy
_hierarchy.activate(inputVector);
if (Training)
{
_hierarchy.learn(inputVector);
}
// Grab the predictions vector
vectorvf prediction = _hierarchy.getPredictions();
// Transfer the ValueField2D fields into the RGB prediction texture
Color predictedPixel = new Color();
for (int x = 0; x < _inputWidth; x++)
{
for (int y = 0; y < _inputHeight; y++)
{
pixelPos.x = x;
pixelPos.y = y;
predictedPixel.r = prediction[0].getValue(pixelPos);
predictedPixel.g = predictedPixel.r; // prediction[1].getValue(pixelPos);
predictedPixel.b = predictedPixel.r; // prediction[2].getValue(pixelPos);
predictionTexture.SetPixel(x, y, predictedPixel);
predictedImage[x, y] = predictedPixel.r;// * 0.299f + predictedPixel.g * 0.587f + predictedPixel.b * 0.114f;
}
}
predictionTexture.Apply();
// Wait for physics to settle
if (_time < 1.0f)
{
_time += Time.deltaTime;
// Apply hand brake
carSteer = 0.0f;
carAccel = 0.0f;
carBrake = -1.0f;
HandBrake = 1.0f;
}
else
{
// Release hand brake
HandBrake = 0.0f;
Accel = -1.0f;
Brake = Accel;
pixelPos.x = 0;
pixelPos.y = 0;
// Update the car controller
PredictedSteer = prediction[1].getValue(pixelPos);
PredictedAccel = Accel;
PredictedBrake = Brake;
carSteer = PredictedSteer;// * carController.m_MaximumSteerAngle;
carAccel = PredictedAccel;
carBrake = PredictedBrake;
// Search along the spline for the closest point to the current car position
float bestT = 0.0f, minDistance = 100000.0f;
Vector3 carPosition = carController.gameObject.transform.localPosition;
// When not training use the track spline
BezierSpline spline = trackSpline;
if (Training)
{
spline = splineList[SplineIndex];
}
float totalDistance = 0.0f;
for (float t = 0.0f; t <= 1.0f; t += 0.001f)
{
Vector3 position = spline.GetPoint(t);
Vector3 positionPrev = spline.GetPoint(t - 0.001f);
float distance = Vector3.Distance(position, carPosition);
totalDistance += Vector3.Distance(position, positionPrev);
if (distance <= minDistance)
{
minDistance = distance;
bestT = t;
}
}
// Reset car position and direction?
if (Input.GetKeyUp(KeyCode.R) || carController.Collided)
{
if (ForcePredictionMode == false)
{
Training = true;
}
carController.ResetCollided();
// Spline 0 is usually set as the spline used to create the track
SplineIndex = 0;
Vector3 position = spline.GetPoint(bestT);
carController.gameObject.transform.localPosition = position;
Vector3 splineDirection = spline.GetDirection(bestT).normalized;
carController.gameObject.transform.forward = -splineDirection;
}
// Determine the difference between the input image (t) and predicted image (t+1)
CalculateNormalizedCrossCorrelation();
// Toggle training on iff too divergent?
if (Training == false && ForcePredictionMode == false && NCC < 0.25f)
{
Training = true;
}
// Toggle training off iff quite confident?
if (Training == true && NCC > 0.85f && LapCount >= initialTrainingLaps)
{
Training = false;
}
if (carController.CurrentSpeed < 2.0f)
{
Training = true;
}
if (Training)
{
_trainingCount++;
}
else
{
_predictingCount++;
}
if (Training && spline != null)
{
Vector3 carDirection = -carController.gameObject.transform.forward.normalized;
Vector3 targetPosition = spline.GetPoint(bestT + SteerAhead / totalDistance);
//Vector3 splineDirection = spline.GetDirection(bestT).normalized;
Vector3 targetDirection = (targetPosition - carPosition).normalized;
float angle = (1.0f - Vector3.Dot(carDirection, targetDirection));// * Mathf.Rad2Deg;
Vector3 right = Vector3.Cross(carDirection, Vector3.up);
float angle2 = Vector3.Dot(right, targetDirection);
float newCarSteer = Mathf.Exp(256.0f * angle) - 1.0f;
if (Mathf.Abs(minDistance) > 0.01f)//newCarSteer > Mathf.PI / 64.0f)
{
newCarSteer += angle2 * Mathf.Abs(minDistance);
}
if (angle2 > 0.0f)
{
newCarSteer = -newCarSteer;
}
if (newCarSteer > 1.0f)
{
newCarSteer = 1.0f;
}
else
if (newCarSteer < -1.0f)
{
newCarSteer = -1.0f;
}
float steerBlend = 0.75f;
carSteer = (steerBlend * newCarSteer) + ((1.0f - steerBlend) * carSteer);
if (enableDebugLines)
{
debugLinePositions[0] = carController.gameObject.transform.localPosition;
debugLinePositions[1] = debugLinePositions[0] + carDirection * 10.0f;
debugLinePositions[2] = carController.gameObject.transform.localPosition;
debugLinePositions[3] = debugLinePositions[2] + targetDirection * 10.0f;
debugLine.SetPositions(debugLinePositions);
}
}
float totalCount = _trainingCount + _predictingCount;
if (totalCount == 0.0f)
{
TrainingPercent = 1.0f;
PredictionPercent = 0.0f;
}
else
{
TrainingPercent = (float)_trainingCount / totalCount;
PredictionPercent = (float)_predictingCount / totalCount;
}
if (bestT < prevBestT)
{
LapCount++;
_trainingCount = 0;
_predictingCount = 0;
if ((LapCount % lapsPerSpline) == 0)
{
SplineIndex++;
if (SplineIndex >= splineList.Length)
{
SplineIndex = 0;
}
}
}
prevBestT = bestT;
}
if (userControl)
{
// Control overides
// pass the input to the car!
float h = CrossPlatformInputManager.GetAxis("Horizontal");
float v = CrossPlatformInputManager.GetAxis("Vertical");
#if !MOBILE_INPUT
float handbrake = CrossPlatformInputManager.GetAxis("Jump");
#endif
carSteer = h;
carAccel = v;
carBrake = v;
HandBrake = handbrake;
}
// Toggle training?
if (Input.GetKeyUp(KeyCode.T))
{
Training = !Training;
ForcePredictionMode = false;
}
else
// Force prediction mode?
if (Input.GetKeyUp(KeyCode.F))
{
Training = false;
ForcePredictionMode = true;
}
// Save out the current state of the hierarchy?
if (Input.GetKeyUp(KeyCode.O) && hierarchyFileName.Length > 0)
{
_hierarchy.save(_res.getComputeSystem(), hierarchyFileName);
print("Saved OgmaNeo hierarchy to " + hierarchyFileName);
}
}
private IEnumerable <Shape> _addSerieAsBezier(Point[] points, Color color, double storkeThickness,
bool animate = true)
{
var addedFigures = new List <Shape>();
Point[] cp1, cp2;
BezierSpline.GetCurveControlPoints(points, out cp1, out cp2);
var lines = new PathSegmentCollection();
var areaLines = new PathSegmentCollection {
new LineSegment(points[0], true)
};
var l = 0d;
for (var i = 0; i < cp1.Length; ++i)
{
lines.Add(new BezierSegment(cp1[i], cp2[i], points[i + 1], true));
areaLines.Add(new BezierSegment(cp1[i], cp2[i], points[i + 1], true));
//it would be awesome to use a better formula to calculate bezier lenght
l += Math.Sqrt(
Math.Pow(Math.Abs(cp1[i].X - cp2[i].X), 2) +
Math.Pow(Math.Abs(cp1[i].Y - cp2[i].Y), 2));
l += Math.Sqrt(
Math.Pow(Math.Abs(cp2[i].X - points[i + 1].X), 2) +
Math.Pow(Math.Abs(cp2[i].Y - points[i + 1].Y), 2));
}
//aprox factor, it was calculated by aproximation.
//the more line is curved, the more it fails.
l = l * .65;
areaLines.Add(new LineSegment(new Point(points.Max(x => x.X), ToPlotArea(_chart.Min.Y, AxisTags.Y)), true));
var f = new PathFigure(points[0], lines, false);
var fa = new PathFigure(ToPlotArea(new Point(_chart.Min.X, _chart.Min.Y)), areaLines, false);
var g = new PathGeometry(new[] { f });
var ga = new PathGeometry(new[] { fa });
var path = new Path
{
Stroke = new SolidColorBrush {
Color = color
},
StrokeThickness = storkeThickness,
Data = g,
StrokeEndLineCap = PenLineCap.Round,
StrokeStartLineCap = PenLineCap.Round,
StrokeDashOffset = l,
StrokeDashArray = new DoubleCollection {
l, l
},
ClipToBounds = true
};
var patha = new Path
{
StrokeThickness = 0,
Data = ga,
Fill = new SolidColorBrush {
Color = color, Opacity = .05
},
ClipToBounds = true
};
_chart.Canvas.Children.Add(path);
addedFigures.Add(path);
if (_chart.IncludeArea)
{
_chart.Canvas.Children.Add(patha);
addedFigures.Add(patha);
}
var draw = new DoubleAnimationUsingKeyFrames
{
BeginTime = TimeSpan.FromSeconds(0),
KeyFrames = new DoubleKeyFrameCollection
{
new SplineDoubleKeyFrame
{
KeyTime = TimeSpan.FromMilliseconds(1),
Value = l
},
new SplineDoubleKeyFrame
{
KeyTime = TimeSpan.FromMilliseconds(750),
Value = 0
}
}
};
Storyboard.SetTarget(draw, path);
Storyboard.SetTargetProperty(draw, new PropertyPath(Shape.StrokeDashOffsetProperty));
var sbDraw = new Storyboard();
sbDraw.Children.Add(draw);
var animated = false;
if (!_chart.DisableAnimation)
{
if (animate)
{
sbDraw.Begin();
animated = true;
}
}
if (!animated)
{
path.StrokeDashOffset = 0;
}
return(addedFigures);
}
public void init(float speed, float hoverHeight, float hoverVariance, float hoverSpeed, float rotationSpeed, float startPoint, float startdistance, float endDistance, BezierSpline spline,
Transform boy)
{
this.speed = speed;
this.hoverHeight = hoverHeight;
this.hoverVariance = hoverVariance;
this.hoverSpeed = hoverSpeed;
this.rotationSpeed = rotationSpeed;
this.spline = spline;
this.boy = boy;
this.endDistance = endDistance;
randValue = Random.Range(0.1f, 0.9f);
randDir = (int)Random.Range(0f, 2f);
randDir = (randDir == 0) ? -1 : randDir;
splineLength = spline.GetSplineLength();
transform.Rotate(0, Random.Range(0, 180), 0);
t = startdistance / splineLength + startPoint;
t = (t > 1f) ? 1f : t;
transform.position = spline.GetPoint(t);
}
public void CreateTube()
{
spline = GetComponent <BezierSpline>();
StartCoroutine(Generate());
}
public override void AddVertex(Spline vertex2D)
{
points.Add(vertex2D);
vertex2Ds.Clear();
vertex2Ds = new BezierSpline(points).GenerateSpline(50);
}
private void OnSceneGUI()
{
if (spline == null)
{
spline = master.spline;
}
handleTransform = spline.transform;
handleRotation = Tools.pivotRotation == PivotRotation.Local ?
handleTransform.rotation : Quaternion.identity;
Vector3 p0 = ShowPoint(0);
for (int i = 1; i < spline.ControlPointCount; i += 3)
{
Vector3 p1 = ShowPoint(i);
Vector3 p2 = ShowPoint(i + 1);
Vector3 p3 = ShowPoint(i + 2);
Handles.color = modeColors[(int)spline.GetControlPointMode(i)];
Handles.DrawLine(p0, p1);
Handles.color = modeColors[(int)spline.GetControlPointMode(i + 2)];
Handles.DrawLine(p2, p3);
Handles.DrawBezier(p0, p3, p1, p2, Color.white, null, 2f);
p0 = p3;
}
/*
* for (int i = 0; i < 1; i++)
* {
* float t = (i) / (float)(master.LenghtSegmentsCount - 1);
*
* Vector3 startPoint = master.transform.TransformPoint(spline.GetPoint(t));
* Vector3 normal = spline.GetDirection(t);
*
* float A = normal.x;
* float B = normal.y;
* float C = normal.z;
*
* //Vector3 scale = CreateCylinder.RotateVector(spline.GetScale(t), normal, spline.GetRotationZ(t));
* Vector3 scale = spline.GetScale(t);
* scale = new Vector3(scale.x - 1, scale.y - 1, scale.z - 1);
*
*
* for (int j = 0; j <= master.WidthSegmentsCount; j++)
* {
* float n = (j / (float)(master.WidthSegmentsCount) * 360f + spline.GetRotationZ(t)) * Mathf.Deg2Rad;
*
* float x = startPoint.x + master.radius1 / Mathf.Sqrt(A * A + C * C)
* (C * Mathf.Cos(n) - A * B * Mathf.Sin(n)
* / Mathf.Sqrt(A * A + B * B + C * C));
*
* float y = startPoint.y + master.radius1 * Mathf.Sqrt(A * A + C * C)
* / Mathf.Sqrt(A * A + B * B + C * C) * Mathf.Sin(n);
*
* float z = startPoint.z - master.radius1 / Mathf.Sqrt(A * A + C * C)
* (A * Mathf.Cos(n) + B * C * Mathf.Sin(n)
* / Mathf.Sqrt(A * A + B * B + C * C));
*
* Vector3 result = new Vector3(x, y, z);
*
* Handles.color = Color.blue;
* Handles.DrawLine(startPoint, result);
*
* Vector3 _normal = result - startPoint;
* _normal = _normal.normalized;
*
*
*
* Handles.color = Color.white;
* Handles.DrawLine(result, result +_normal);
*
* //var res = result;
* //Vector3 perpendicular = Vector3.Cross( normal ,_normal);
* Handles.color = Color.blue;
* //Handles.DrawLine(result, result + perpendicular);
* //Vector3 offset = Vector3.Project(scale, _normal);
*
* Handles.color = Color.green;
* //Handles.DrawLine(result, result + offset);
*
* Vector3 offset = new Vector3(_normal.x * scale.x, _normal.y * scale.y, _normal.z * scale.z);
* offset = Vector3.ProjectOnPlane(offset, normal);
* //offset *= scale.magnitude;
*
* //result += offset * offset.magnitude;
*
* Handles.color = Color.red;
* Handles.DrawLine(result, result + offset);
*
*
*
*
* Handles.color = Color.green;
* //Handles.DrawLine(result, result + scale);
* // Debug.Log(scale.sqrMagnitude);
*
* //scale = CreateCylinder.RotateVector(scale, normal, spline.GetRotationZ(t));
*
* //Debug.Log(scale.sqrMagnitude);
*
* }
* }
*/
//ShowVelocity();
}
public void parsePDB()
{
// for determining hydrogen bonds
List <Vector3> hBondAcceptors = new List <Vector3> ();
List <Vector3> hBondDonors = new List <Vector3> ();
parseMol: // iteration start if multiple input files are used
BezierSpline[] ribbonSplineList = new BezierSpline[30]; //for drawing protein lines (30 is max number of chains)
int numAtoms = (int)mol.NumAtoms() + 1;
atoms = new GameObject[numAtoms];
int maxHelix = 500;
radius = new float[maxHelix, numAtoms];
int ribbonChainIndex = 0;
OBElementTable table = new OBElementTable();
int currentChain = -1;
OBAtom[] alphaCarbons = new OBAtom[numAtoms / 4];
int alphaCarbonCount = 0;
List <Vector3> atomPositions = new List <Vector3> ();
List <string> atomElements = new List <string> ();
for (int i = 1; i < numAtoms; i++)
{
OBAtom atom = mol.GetAtom(i);
string tag;
OBResidue res = atom.GetResidue();
Vector3 position = new Vector3((float)atom.GetX(), (float)atom.GetY(), (float)atom.GetZ());
string elem = table.GetSymbol((int)atom.GetAtomicNum()).ToUpper();
//checks for pharmacophore labels
if (res.GetName() == "ACC" || res.GetName() == "FOB" || res.GetName() == "POS" || res.GetName() == "NEG" || res.GetName() == "RNG" || res.GetName() == "DON")
{
if (atom.IsHydrogen()) //added hydrogens gets the same resName and has to be ignored
{
continue;
}
renderPharmacophore = true;
}
else
{
renderPharmacophore = false;
}
// pharmacophores
if (res.GetName() == "EXC")
{
if (atom.IsHydrogen()) //added hydrogens gets the same resName and has to be ignored
{
continue;
}
renderEXC = true;
renderPharmacophore = true;
}
else
{
renderEXC = false;
}
//creates the atom object
atoms[i] = createAtomType(elem, position);
int n;
if (int.TryParse(res.GetName(), out n))
{
if (CollectionOfLigands == null)
{
CollectionOfLigands = new List <List <GameObject> >();
CollectionOfLigands.Add(new List <GameObject>());
}
while (n + 1 > CollectionOfLigands.Count)
{
CollectionOfLigands.Add(new List <GameObject>());
}
CollectionOfLigands[n].Add(atoms[i]);
}
if (res.GetResidueProperty(9)) //water
{
tag = "water";
}
else if (res.GetAtomProperty(atom, 4) || (atom.IsHydrogen() && !res.GetResidueProperty(5))) //ligand
{
if (res.GetResidueProperty(5)) //ion (should be 3 but a bug in openbabel labels ions as protein, thats why the check has to be done inside the ligand check)
{
tag = "ion";
}
else
{
TextMesh lText = atoms [i].transform.Find("Text").GetComponent <TextMesh> ();
lText.color = textColor;
if (renderPharmacophore)
{
tag = "hetatms"; //make sure pharmacophores always show
lText.text = res.GetName() + ":" + res.GetIdx();
lText.fontSize = labelFontSize;
}
else
{
tag = "hetatmbs";
if (ligandText)
{
lText.text = elem + ":" + i.ToString();
lText.fontSize = labelFontSize;
}
}
if (sphere)
{
atoms [i].transform.localScale *= 4;
}
if (atom.IsHbondAcceptor())
{
foreach (Vector3 candidatePos in hBondDonors)
{
checkHBond(candidatePos, position);
}
}
if (atom.IsHbondDonor())
{
foreach (Vector3 candidatePos in hBondAcceptors)
{
checkHBond(candidatePos, position);
}
}
}
}
else //protein
{
tag = "balls";
atomPositions.Add(position);
atomElements.Add(elem);
if (atom.IsHbondAcceptor())
{
hBondAcceptors.Add(position);
}
else
{
hBondDonors.Add(position);
}
if (res.GetAtomProperty(atom, 0)) //alpha carbon
{
alphaCarbons[alphaCarbonCount] = atom;
if (alphaCarbonCount > 6) //check if the ribbon is alpha helix using torsion angles
{
double torsion = mol.GetTorsion(atom, alphaCarbons[alphaCarbonCount - 1], alphaCarbons[alphaCarbonCount - 2], alphaCarbons[alphaCarbonCount - 3]);
double prevTorsion = mol.GetTorsion(alphaCarbons[alphaCarbonCount - 4], alphaCarbons[alphaCarbonCount - 5], alphaCarbons[alphaCarbonCount - 6], alphaCarbons[alphaCarbonCount - 7]);
double torsionSum = torsion + prevTorsion;
if (torsionSum > 99 && torsionSum < 111)
{
for (int j = ribbonChainIndex - 7; j <= ribbonChainIndex; j++)
{
radius [currentChain, j] = 1.5f; //alpha helix
}
}
else
{
radius [currentChain, ribbonChainIndex] = 0.5f;
}
}
alphaCarbonCount++;
if (proteinText) //only displays text on alpha carbons
{
TextMesh pText = atoms [i].transform.Find("Text").GetComponent <TextMesh> ();
pText.color = textColor;
pText.text = res.GetName() + " -" + res.GetNumString();
pText.fontSize = labelFontSize;
}
int tempChain = (int)res.GetChainNum();
if (tempChain != currentChain)
{
currentChain = tempChain;
ribbonChainIndex = 0;
}
//add points for ribbon rendering
addBezierPoint(ribbonSplineList, currentChain, ribbonChainIndex, position);
ribbonChainIndex++;
}
}
atoms[i].transform.tag = tag;
centerPos += position;
centerCount++;
}
//createSurface (atomPositions,atomElements);
Debug.Log(hBondAcceptors.Count + " " + hBondDonors.Count);
//evaluate bonds
for (int i = 0; i < mol.NumBonds(); i++)
{
OBBond bond = mol.GetBond(i);
OBAtom atom = mol.GetAtom((int)bond.GetBeginAtomIdx());
OBResidue res = atom.GetResidue();
bool ligand = res.GetAtomProperty(atom, 4) || (atom.IsHydrogen() && !res.GetResidueProperty(5));
if (ligand && sphere) //no ligand bonds if display mode is CPK sphere
{
continue;
}
try {
connect(atoms[bond.GetBeginAtomIdx()], atoms[bond.GetEndAtomIdx()], bond);
} catch (System.Exception e) {
Debug.Log(e);
}
}
//handle pharmacophore vectors
if (mol.HasData("VECTOR"))
{
string[] vectors = mol.GetData("VECTOR").GetValue().Split(new string[] { "\n" }, StringSplitOptions.None);
foreach (string vector in vectors)
{
string[] idx = vector.Split((char[])null, StringSplitOptions.RemoveEmptyEntries);
try {
Vector3 pos = new Vector3(float.Parse(idx[1]), float.Parse(idx[2]), float.Parse(idx[3]));
int id = int.Parse(idx[0]);
drawVector(atoms[id], pos, mol.GetAtom(id).GetResidue().GetName());
} catch (System.Exception e) {
Debug.Log(e);
}
}
}
//render protein ribbons
drawRibbons(ribbonSplineList, "ribbons"); //must be before alpha due to indexing
drawRibbons(ribbonSplineList, "alpha");
// check for separate ligand file
if (file.Contains("protein"))
{
file = file.Replace("protein", "ligand");
string file1 = file.Replace("." + extension, ".sdf"); // .+extension incase the format would also appear in the file name
string file2 = file.Replace("." + extension, ".mol2");
if (File.Exists(file1))
{
readMol(file);
goto parseMol;
}
else if (File.Exists(file2))
{
readMol(file);
goto parseMol;
}
}
center = createObject(new GameObject(), centerPos / centerCount); //the center of the pdb
show();
}
public override void OnInspectorGUI()
{
spline = target as BezierSpline;
EditorGUI.BeginChangeCheck();
float lengthTimeStep = EditorGUILayout.FloatField("Length Calculation Time Step", spline.GetLengthCalculationTimeStep());
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "LengthCalculationTimeStepChange");
spline.SetLengthCalculationTimeStep(lengthTimeStep);
EditorUtility.SetDirty(spline);
}
EditorGUILayout.LabelField("Spline Length", spline.GetSplineLength().ToString());
EditorGUI.BeginChangeCheck();
bool loop = EditorGUILayout.Toggle("Loop Spline", spline.GetLoop());
if (EditorGUI.EndChangeCheck())
{
Undo.RecordObject(spline, "ToggleLoopSpline");
spline.SetLoop(loop);
EditorUtility.SetDirty(spline);
}
bool foldoutAll = Event.current.type == EventType.MouseUp && Event.current.modifiers == EventModifiers.Alt;
EditorGUILayout.BeginHorizontal();
EditorGUI.BeginChangeCheck();
bool foldoutPoints = EditorGUILayout.Foldout(spline.GetFoldout(0), "Points", true);
if (EditorGUI.EndChangeCheck() && foldoutAll)
{
spline.SetAllFoldouts(foldoutPoints);
}
GUIStyle buttonStyle = new GUIStyle(GUI.skin.button)
{
fixedWidth = 20,
fixedHeight = 20,
fontStyle = FontStyle.Bold,
fontSize = 20,
clipping = TextClipping.Overflow,
contentOffset = new Vector2(1, -1)
};
DrawAddButton(-1, buttonStyle);
EditorGUILayout.EndHorizontal();
if (foldoutPoints)
{
EditorGUI.indentLevel++;
for (int i = 0; i < spline.GetPointCount(); i += 3)
{
if (i != spline.GetPointCount() - 1 || !loop)
{
EditorGUILayout.BeginHorizontal();
int foldoutNumber = (i / 3) + 1;
bool foldoutPoint = EditorGUILayout.Foldout(spline.GetFoldout(foldoutNumber), "Point " + foldoutNumber, true);
if (spline.GetPointCount() > 4 && (!loop || spline.GetPointCount() > 7))
{
if (GUILayout.Button("-", buttonStyle))
{
Undo.RecordObject(spline, "RemoveSplineCurve");
spline.RemovePoint(i);
EditorUtility.SetDirty(spline);
break;
}
}
DrawAddButton(i, buttonStyle);
EditorGUILayout.EndHorizontal();
if (foldoutPoint)
{
EditorGUI.indentLevel++;
DrawPointPositionField(i, "Local Position");
if (i == 0)
{
if (loop)
{
DrawPointPositionField(i + 1, "Handle 1");
DrawPointPositionField(spline.GetPointCount() - 2, "Handle 2");
}
else
{
DrawPointPositionField(i + 1, "Handle");
}
}
else if (i == spline.GetPointCount() - 1)
{
DrawPointPositionField(i - 1, "Handle");
}
else
{
DrawPointPositionField(i - 1, "Handle 1");
DrawPointPositionField(i + 1, "Handle 2");
}
DrawPointModeField(i, "Mode");
EditorGUI.indentLevel--;
}
spline.SetFoldout(foldoutNumber, foldoutPoint);
}
}
EditorGUI.indentLevel--;
}
spline.SetFoldout(0, foldoutPoints);
if (selectedIndex >= 0 && selectedIndex < spline.GetPointCount())
{
GUILayout.Label("Selected Point", EditorStyles.boldLabel);
EditorGUI.indentLevel++;
EditorGUI.BeginChangeCheck();
DrawPointPositionField(selectedIndex, "Local Position");
DrawPointModeField(selectedIndex, "Mode");
}
}
public ColorSpline()
{
spline = new BezierSpline();
}
public void Init()
{
moveSpline = GameObject.Find("PieceMoveSpline").GetComponent<BezierSpline>();
}
void ReallocateNodeOverSpline(Transform node, BezierSpline spline, int depth)
{
float newPosition;
// Collide with spline that can belong to 2 possible objects, biffurcation or curve
Curve curve = spline.transform.parent.GetComponent<Curve>();
Bifurcation bifurcation = spline.transform.parent.GetComponent<Bifurcation>();
if (curve != null)
{// we are in a curve
Debug.DrawLine(transform.position, nodeToFollow.position, Color.cyan);
}
if (bifurcation != null)
{// we are in a bifurcation
if (bifurcation.splines[0].isPath) spline = bifurcation.splines[0];
else spline = bifurcation.splines[1];
}
newPosition = spline.GetClosestPoint(transform.position + transform.forward * distToNode, 0.01f);
nodeToFollow.position = spline.GetPoint(newPosition);
nodeToFollow.rotation = spline.GetOrientation(newPosition, transform.up);
// end or beggining of spline reached, check next/previous spline
if (newPosition == 2)
{// jump to previous spline
if (depth == 1)
{// avoid infinite recursive loops
nodeToFollow.position = spline.startNode.transform.position;
nodeToFollow.rotation = spline.startNode.transform.rotation;
return;
}
RaycastHit hit;
Vector3 dir = -spline.startNode.transform.forward;
//if (spline.startNode.reverse == true) dir *= -1;
if (Physics.Raycast(spline.startNode.position + dir + new Vector3(0, 2, 0), -transform.up, out hit, 30))
{
spline = hit.collider.transform.GetComponent<BezierSpline>();
}
ReallocateNodeOverSpline(nodeToFollow, spline, 1);
}
if (newPosition == 3)
{// jump to next spline
if (depth == 1)
{// avoid infinite recursive loops
nodeToFollow.position = spline.endNode.transform.position;
nodeToFollow.rotation = spline.endNode.transform.rotation;
return;
}
RaycastHit hit;
Vector3 dir = spline.endNode.transform.forward;
//if (spline.endNode.reverse == true)
// dir *= -1;
if (Physics.Raycast(spline.endNode.position + dir + new Vector3(0, 2, 0), -transform.up, out hit, 30))
{
spline = hit.collider.transform.GetComponent<BezierSpline>();
}
ReallocateNodeOverSpline(nodeToFollow, spline, 1);
}
}
public void SplitPath(BezierSpline spline)
{
Array.Resize(ref bezierSplines, bezierSplines.Length + 1);
createNewBezierSpline(bezierSplines.Length - 1, spline.Points[spline.Points.Length - 1]);
spline.addConnectionTospline(bezierSplines[bezierSplines.Length - 1]);
}
// 画点，返回值为是否刷新检视面板
private static bool DrawPoint(BezierSpline bs, int index, ref int selectedIndex)
{
if (bs.points == null || bs.Count < 1)
{
return(false);
}
bool refreshInspector = false;
BezierPoint point = bs[index];
float size = HandleUtility.GetHandleSize(point.Position);
Handles.color = Color.blue;
if (Handles.Button(point.Position, Quaternion.identity, size * HANDLE_SIZE, size * PICK_SIZE, Handles.DotHandleCap))
{
selectedIndex = index;
refreshInspector = true;
}
if (_showHandles)
{
Handles.color = Color.gray;
if (Handles.Button(point.HandleL, Quaternion.identity, size * HANDLE_SIZE, size * PICK_SIZE, Handles.DotHandleCap) || Handles.Button(point.HandleR, Quaternion.identity, size * HANDLE_SIZE, size * PICK_SIZE, Handles.DotHandleCap))
{
selectedIndex = index;
refreshInspector = true;
}
}
if (selectedIndex == index)
{
Vector3 p = point.Position;
Vector3 pl = point.HandleL;
Vector3 pr = point.HandleR;
p = Handles.PositionHandle(p, Quaternion.identity);
if (_showHandles)
{
pl = Handles.PositionHandle(pl, Quaternion.identity);
pr = Handles.PositionHandle(pr, Quaternion.identity);
}
if (p != point.Position)
{
Undo.RecordObject(bs, "change pos");
point.Position = p;
EditorUtility.SetDirty(bs);
refreshInspector = true;
}
else if (pl != point.HandleL)
{
Undo.RecordObject(bs, "change left handler");
point.HandleL = pl;
EditorUtility.SetDirty(bs);
refreshInspector = true;
}
else if (pr != point.HandleR)
{
Undo.RecordObject(bs, "change right handler");
point.HandleR = pr;
EditorUtility.SetDirty(bs);
refreshInspector = true;
}
}
if (_showHandles)
{
Handles.DrawLine(point.Position, point.HandleL);
Handles.DrawLine(point.Position, point.HandleR);
}
return(refreshInspector);
}
void Start()
{
spline = GameObject.FindWithTag("CustomerQueue").GetComponent <BezierSpline>();
}
private void OnGUI()
{
bool refreshSv = false;
EditorGUILayout.BeginHorizontal();
BezierSpline tmpBs = (BezierSpline)EditorGUILayout.ObjectField("相机路径", _cameraBSpline, typeof(BezierSpline), false);
if (_cameraBSpline != tmpBs)
{
_cameraBSpline = tmpBs;
refreshSv = true;
}
tmpBs = (BezierSpline)EditorGUILayout.ObjectField("焦点路径", _targetBSpline, typeof(BezierSpline), false);
if (_targetBSpline != tmpBs)
{
_targetBSpline = tmpBs;
refreshSv = true;
}
EditorGUILayout.EndHorizontal();
GUILayout.Space(10f);
_scrollViewPos = EditorGUILayout.BeginScrollView(_scrollViewPos, false, false);
int insertID_C = -1; int insertID_T = -1;
int removeID_C = -1; int removeID_T = -1;
int rowCount = -1;
if (_cameraBSpline != null)
{
rowCount = _cameraBSpline.Count;
}
if (_targetBSpline != null)
{
rowCount = Mathf.Max(rowCount, _targetBSpline.Count);
}
for (int i = 0; i < rowCount; i++)
{
EditorGUILayout.BeginHorizontal();
// 相机贝塞尔点
refreshSv |= DrawBezierPointInspector(_cameraBSpline, i, ref insertID_C, ref removeID_C, ref _cameraSelectedID);
// 焦点贝塞尔点
refreshSv |= DrawBezierPointInspector(_targetBSpline, i, ref insertID_T, ref removeID_T, ref _targetSelectedID);
EditorGUILayout.EndHorizontal();
GUILayout.Space(10f);
}
EditorGUILayout.EndScrollView();
if (_cameraBSpline != null)
{
if (insertID_C > -1)
{
Point p = _cameraBSpline.GetResult((insertID_C - 0.5f) / (_cameraBSpline.Count - 1));
Undo.RecordObject(_cameraBSpline, "insert bezier point");
Vector3 pp = p.position;
Vector3 pn = p.velocity.normalized;
_cameraBSpline.Insert(insertID_C, new BezierPoint(pp, pp - pn, pp + pn, BezierPoint.PointType.Smooth));
EditorUtility.SetDirty(_cameraBSpline);
}
if (removeID_C > -1)
{
Undo.RecordObject(_cameraBSpline, "remove bezier point");
_cameraBSpline.RemoveAt(removeID_C);
EditorUtility.SetDirty(_cameraBSpline);
}
}
if (_targetBSpline != null)
{
if (insertID_T > -1)
{
Point p = _targetBSpline.GetResult((insertID_T - 0.5f) / (_targetBSpline.Count - 1));
Undo.RecordObject(_targetBSpline, "insert bezier point");
Vector3 pp = p.position;
Vector3 pn = p.velocity.normalized;
_targetBSpline.Insert(insertID_T, new BezierPoint(pp, pp - pn, pp + pn, BezierPoint.PointType.Smooth));
EditorUtility.SetDirty(_targetBSpline);
}
if (removeID_T > -1)
{
Undo.RecordObject(_targetBSpline, "remove bezier point");
_targetBSpline.RemoveAt(removeID_T);
EditorUtility.SetDirty(_targetBSpline);
}
}
EditorGUILayout.BeginHorizontal();
if (_cameraBSpline != null)
{
if (GUILayout.Button("Add", EditorStyles.miniButtonLeft, GUILayout.MinWidth(20f)))
{
Undo.RecordObject(_cameraBSpline, "add bezier point");
_cameraBSpline.Insert(_cameraBSpline.Count, new BezierPoint(GetSceneView().camera.transform.position));
EditorUtility.SetDirty(_cameraBSpline);
refreshSv = true;
}
if (GUILayout.Button("Set", EditorStyles.miniButtonMid, GUILayout.MinWidth(20f)))
{
if (_cameraSelectedID > -1)
{
Undo.RecordObject(_cameraBSpline, "change pos");
_cameraBSpline[_cameraSelectedID].Position = GetSceneView().camera.transform.position;
EditorUtility.SetDirty(_cameraBSpline);
refreshSv = true;
}
}
if (GUILayout.Button("Set SceneView", EditorStyles.miniButtonRight, GUILayout.MinWidth(20f)))
{
if (_cameraSelectedID > -1)
{
SceneView sv = GetSceneView();
sv.FixNegativeSize();
Vector3 pivot = sv.pivot;
Vector3 pos = pivot;
Quaternion quaternion = Quaternion.LookRotation(pivot - _cameraBSpline[_cameraSelectedID].Position);
#region 要打开
MethodInfo mf = typeof(SceneView).GetMethod("CalcCameraDist", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance);
if (mf != null)
{
pos -= (quaternion * Vector3.forward).normalized * (float)mf.Invoke(sv, null);// 这个位置一直不对
}
#endregion 要打开
sv.LookAtDirect(pos, quaternion);
sv.pivot = pivot;
}
}
}
if (_targetBSpline != null)
{
if (GUILayout.Button("Add", EditorStyles.miniButtonLeft, GUILayout.MinWidth(20f)))
{
Undo.RecordObject(_targetBSpline, "add bezier point");
_targetBSpline.Insert(_targetBSpline.Count, new BezierPoint(GetSceneView().pivot));
EditorUtility.SetDirty(_targetBSpline);
refreshSv = true;
}
if (GUILayout.Button("Set", EditorStyles.miniButtonMid, GUILayout.MinWidth(20f)))
{
if (_targetSelectedID > -1)
{
Undo.RecordObject(_targetBSpline, "change pos");
_targetBSpline[_targetSelectedID].Position = GetSceneView().pivot;
EditorUtility.SetDirty(_targetBSpline);
refreshSv = true;
}
}
if (GUILayout.Button("Set SceneTarget", EditorStyles.miniButtonRight, GUILayout.MinWidth(20f)))
{
if (_targetSelectedID > -1)
{
SceneView sv = GetSceneView();
sv.FixNegativeSize();
sv.pivot = _targetBSpline[_targetSelectedID].Position;
// sv.size = 10f;
// sv.LookAt(_targetBSpline[_targetSelectedID].Point);
}
}
}
EditorGUILayout.EndHorizontal();
var showHandles = GUILayout.Toggle(_showHandles, _showHandles ? "Hide Control Handles" : "Show Control Handles", EditorStyles.toolbarButton);
if (_showHandles != showHandles)
{
_showHandles = showHandles;
refreshSv = true;
}
EditorGUILayout.Space();
if (GUILayout.Button("Sort", EditorStyles.miniButton, GUILayout.MinWidth(20f)))
{
_cameraBSpline.Sort();
if (_cameraBSpline.Count > 0)
{
_cameraBSpline[0].Percent = 0f;
_cameraBSpline[_cameraBSpline.Count - 1].Percent = 1f;
}
_targetBSpline.Sort();
if (_targetBSpline.Count > 0)
{
_targetBSpline[0].Percent = 0f;
_targetBSpline[_targetBSpline.Count - 1].Percent = 1f;
}
AssetDatabase.SaveAssets();
}
if (refreshSv)
{
GetSceneView().Repaint();
}
EditorGUILayout.Space();
_showPreviewCamera = GUILayout.Toggle(_showPreviewCamera, _showPreviewCamera ? "Hide Preview Camera" : "ShowPreview Camera", EditorStyles.toolbarButton);
if (_showPreviewCamera)
{
EditorGUILayout.BeginHorizontal();
_previewDuration = EditorGUILayout.FloatField(_previewDuration, EditorStyles.toolbarTextField);
if (_previewDuration <= 0f)
{
_previewDuration = 5f;
}
_autoPreview = GUILayout.Toggle(_autoPreview, _autoPreview ? "Stop" : "Go", EditorStyles.toolbarButton);
_percent = EditorGUILayout.Slider(_percent, 0f, 1f);
EditorGUILayout.EndHorizontal();
EditorGUI.DrawPreviewTexture(GUILayoutUtility.GetRect(PREVIEW_WIDTH, PREVIEW_HEIGHT), _previewRenderTexture, null, ScaleMode.ScaleToFit);
}
}
protected void Awake()
{
onPathCalculation += GetApproximateSplineLength;
spline = GetComponent <BezierSpline>();
}
// Use this for initialization
void Start()
{
spline = GetComponent <BezierSpline>();
}
// Use this for initialization
void Start()
{
t = 0;
currentSpline = startingSpline;
transform.position = currentSpline.GetPoint(t);
transform.rotation = currentSpline.GetOrientation(t, Vector3.Lerp(currentSpline.startNode.transform.up, currentSpline.endNode.transform.up, t));
lastForward = transform.forward;
//currentSpline.GetComponent<MeshCollider>().enabled = true;
}
void DrawEditBezierPatch(BezierSpline patch, int segs)
{
Sprite targetSprite = (Sprite)target;
Vector3 fixedPoint;
float distance;
Camera cam = SceneView.currentDrawingSceneView.camera;
//Tangent Handles
if (!patch.linear) {
Vector3 originalTangent0 = patch.tangetPos0;
Vector3 originalTangent1 = patch.tangetPos1;
distance = Vector3.Distance(patch.tangetPos0,cam.transform.position);
fixedPoint = Handles.FreeMoveHandle(patch.tangetPos0,Quaternion.identity,0.01f*distance,Vector3.zero,Handles.RectangleCap);
//Debug.Log(fixedPoint);
if (originalTangent0 != fixedPoint) {
//needsUndo = true;
if (targetSprite.lock2D) {
fixedPoint = targetSprite.transform.InverseTransformPoint(fixedPoint);
fixedPoint.z = 0.0f;
fixedPoint = targetSprite.transform.TransformPoint(fixedPoint);
}
patch.tangetPos0 = fixedPoint;
if (Event.current.control) {
patch.localNormal0 = SnapVector3(patch.localNormal0,SpriteWorldManager.current.gridSize*0.5f);
patch.localNormal0.Normalize();
}
if (targetSprite.lock2D) {
patch.localNormal0.z = 0.0f;
}
}
distance = Vector3.Distance(patch.tangetPos1,cam.transform.position);
fixedPoint = Handles.FreeMoveHandle(patch.tangetPos1,Quaternion.identity,0.01f*distance,Vector3.zero,Handles.RectangleCap);
if (originalTangent1 != fixedPoint) {
//needsUndo = true;
if (targetSprite.lock2D) {
fixedPoint = targetSprite.transform.InverseTransformPoint(fixedPoint);
fixedPoint.z = 0.0f;
fixedPoint = targetSprite.transform.TransformPoint(fixedPoint);
}
patch.tangetPos1 = fixedPoint;
if (Event.current.control) {
patch.localNormal1 = SnapVector3(patch.localNormal1,SpriteWorldManager.current.gridSize*0.5f);
patch.localNormal0.Normalize();
}
if (targetSprite.lock2D) {
patch.localNormal1.z = 0.0f;
}
}
}
DrawBezierPatch(patch,segs);
}
public BezierPoint(BezierSpline spline) : this(spline, Vector3.zero)
{
}
public void ChangeSpline(BezierSpline newSpline)
{
spline = newSpline;
position = newSpline.GetClosestPosition(transform.position);
}
void SetTarget()
{
if (goingForward) {
if (segments [current].GetComponent<RailComponent> ().next != null) {
Debug.Log(current);
target = segments [current].GetComponent<RailComponent> ().next;
spline = segments [current].GetComponent<RailComponent> ().rail;
// if(spline.Loop && (segments[current].GetComponent<RailComponent>().head)){
// lastHead = current;
//// Debug.Log("LH: "+lastHead);
// current ++;
// }else if(spline.Loop && (segments[current].GetComponent<RailComponent>().tail)){
// lastTail = current;
// current = lastHead;
// }else{
current = segments[current].GetComponent<RailComponent> ().next.GetComponent<RailComponent>().segNum;
// }
} else {
Debug.Log("FEELS LIKE FALLING");
player.playerMode = PlayerMode.Jump;
GetComponent<Rigidbody>().AddForce(segments[current].transform.forward*(8000f));
GetComponent<Rigidbody>().AddForce(this.transform.up*(9000f));
}
} else {
if (segments [current].GetComponent<RailComponent> ().last != null) {
// Debug.Log(current);
// DeDebugbug.Log("LT: "+lastTail);
target = segments [current].GetComponent<RailComponent> ().last;
spline = segments [current].GetComponent<RailComponent> ().rail;
// if(spline.Loop && (segments[current].GetComponent<RailComponent>().head)){
// lastHead = current;
// current = lastTail;
// } else if(spline.Loop && (segments[current].GetComponent<RailComponent>().tail)){
// Debug.Log("LT: "+lastTail);
// lastTail = current;
// current --;
// } else{
// Debug.Log("Still Happening");
current = segments[current].GetComponent<RailComponent> ().last.GetComponent<RailComponent>().segNum;
// }
} else {
Debug.Log("FEELS LIKE FALLING");
player.playerMode = PlayerMode.Jump;
GetComponent<Rigidbody>().AddForce(segments[current].transform.forward*(-8000f));
GetComponent<Rigidbody>().AddForce(this.transform.up*(9000f));
}
}
}
