public Degree(short degreePart, byte minutePart, double secondPart, AngleRange range, bool isPositive)
: base((isPositive ? 1 : -1) * (degreePart + minutePart / 60d + secondPart / 3600d), range)
{
if (minutePart >= 60 || secondPart >= 60)
{
minutePart += (byte)(secondPart / 60);
secondPart = secondPart % 60;
degreePart += (short)(minutePart / 60);
minutePart = (byte)(minutePart % 60);
}
this._sign = (isPositive ? 1 : -1);
//double value = m_Sign * (degreePart + minutePart / 60d + secondPart / 3600d);
//this.m_Value = this.Adapter.Adopt(value);
this._degreePart = (short)Math.Floor(_sign * this.Value);
this._minutePart = (byte)Math.Floor((_sign * this.Value - this._degreePart) * 60);
this._secondPart = (((_sign * this.Value - this._degreePart) * 60 - this._minutePart) * 60);
this.OnValueChanged += new ValueChangedEventHandler(Degree_OnValueChanged);
//this.m_Range = range;
}
private void radSpinEditor2_ValueChanged(object sender, EventArgs e)
{
AngleRange range = this.pieSeries.Range;
range.SweepAngle = Decimal.ToDouble(this.radSpinEditor2.Value);
this.pieSeries.Range = range;
}
public static AngularUnit BuildFromRadianValue(double value, AngleMode mode, AngleRange range)
{
switch (mode)
{
case AngleMode.Degree:
value = UnitConversion.RadianToDegree(value);
break;
case AngleMode.Grade:
value = UnitConversion.RadianToGrade(value);
break;
case AngleMode.Radian:
break;
default:
throw new NotImplementedException();
}
return(Build(value, mode, range));
}
private AngleRange GetSpawnLocation(float width)
{
for (int i = 0; i < 100; i++)
{
float center = Random.Range(0f, 360f);
AngleRange potentialAR = new AngleRange(center, width);
bool valid = true;
foreach (AngleRange ar in blockedRanges)
{
if (potentialAR.Intersects(ar))
{
valid = false;
break;
}
}
if (valid)
{
return(potentialAR);
}
}
return(null);
}
/// <summary>
/// Sets the <see cref="AngleRange"/> minimum value.
/// </summary>
/// <param name="value">The new minimum value.</param>
public virtual void SetAngleRangeMinimum(float value)
{
FloatRange newLimit = new FloatRange(AngleRange.ToVector2());
newLimit.minimum = value;
AngleRange = newLimit;
}
private IEnumerator Loop()
{
float timer = spawnRate;
float headTimer = 0;
while (true)
{
if (isSpawning && FirstPerson.GUN_AQUIRED)
{
timer += Time.deltaTime;
if (timer > spawnRate)
{
AngleRange ar = GetSpawnLocation(30f);
if (ar != null)
{
Spawn(tentaclePrefab, tentacleDistance, depthOverTime, ar, 10f);
}
timer = 0;
}
headTimer += Time.deltaTime;
if (headTimer > headSpawnRate)
{
AngleRange ar = GetSpawnLocation(45f);
if (ar != null)
{
Spawn(headPrefab, headDistance, headDepthOverTime, ar, 20f);
}
headTimer = 0;
}
}
yield return(null);
}
}
public double AngleTo(Vector v, AngleRange mode = AngleRange.ZeroToPi)
{
if (mode == AngleRange.ZeroToPi)
{
return(Vector.AngleBetween(this, v));
}
var dir0 = this.Heading();
var dir1 = v.Heading();
var angle = dir1 - dir0;
if (mode == AngleRange.ZeroTo2Pi)
{
if (angle < 0)
{
angle += 2 * Math.PI;
}
}
else if (mode == AngleRange.MinusPiToPi)
{
if (angle < -Math.PI)
{
angle += 2 * Math.PI;
}
else if (angle > Math.PI)
{
angle -= 2 * Math.PI;
}
}
return(angle);
}
public void CycleSpriteIndex()
{
ISelection selection = ShapeEditorCache.GetSelection();
if (selection.single == -1)
{
return;
}
int nextIndex = SplineUtility.NextIndex(selection.single, m_Spline.GetPointCount());
float angle = SpriteShapeHandleUtility.PosToAngle(m_Spline.GetPosition(selection.single), m_Spline.GetPosition(nextIndex), 0f);
int angleRangeIndex = SpriteShapeEditorUtility.GetRangeIndexFromAngle(m_SpriteShape, angle);
if (angleRangeIndex == -1)
{
return;
}
AngleRange angleRange = m_SpriteShape.angleRanges[angleRangeIndex];
int spriteIndex = (m_Spline.GetSpriteIndex(selection.single) + 1) % angleRange.sprites.Count;
Undo.RecordObject(m_CurrentEditor.target, "Edit Sprite Index");
m_Spline.SetSpriteIndex(selection.single, spriteIndex);
EditorUtility.SetDirty(m_CurrentEditor.target);
}
private void ValidateRange(AngleRange angleRange, float prevStart, float prevEnd)
{
var start = angleRange.start;
var end = angleRange.end;
foreach (var otherRange in cache.angleRanges)
{
var otherStart = otherRange.start;
var otherEnd = otherRange.end;
if (otherRange == angleRange)
{
if ((start > 180f && end > 180f) || (start < -180f && end < -180f))
{
start = Mathf.Repeat(start + 180f, 360f) - 180f;
end = Mathf.Repeat(end + 180f, 360f) - 180f;
}
otherStart = start + 360f;
otherEnd = end - 360f;
}
ValidateRangeStartEnd(ref start, ref end, prevStart, prevEnd, otherStart, otherEnd);
}
angleRange.start = start;
angleRange.end = end;
}
public Grade(short gradePart, byte minutePart, byte secondPart, AngleRange range, bool isPositive)
: base((isPositive ? 1 : -1) * (gradePart + minutePart / 60d + secondPart / 3600d), range)
{
if (minutePart >= 100 || secondPart >= 100)
{
minutePart += (byte)(secondPart / 100);
secondPart = (byte)(secondPart % 100);
gradePart += (short)(minutePart / 100);
minutePart = (byte)(minutePart % 100);
}
this.m_Sign = (isPositive ? 1 : -1);
//double value = m_Sign * (gradePart + minutePart / 100d + secondPart / 10000d);
//this.m_Value = this.Adapter.Adopt(value);
this.m_GradePart = (short)Math.Floor(m_Sign * this.Value);
this.m_MinutePart = (byte)Math.Floor((m_Sign * this.Value - this.m_GradePart) * 100);
this.m_SecondPart = (byte)Math.Round(((m_Sign * this.Value - this.m_GradePart) * 100 - this.m_MinutePart) * 100);
this.OnValueChanged += new ValueChangedEventHandler(Grade_OnValueChanged);
//this.m_Range = range;
}
public AngularCollection(double[] values, AngleRange range)
{
this.values = new List <double>(values);
this.m_Range = range;
this.AdaptValues();
}
private void OnSelectionChange()
{
CreateReorderableSpriteList();
EditorApplication.delayCall += () =>
{
m_CurrentAngleRange = controller.selectedAngleRange;
};
}
public bool Intersects(AngleRange other)
{
// Normal check
if (end > other.start && start < other.end)
{
return(true);
}
return(false);
}
private static AngleRange CreateAngleRange(float start, float end, int order)
{
AngleRange angleRange = new AngleRange();
angleRange.start = start;
angleRange.end = end;
angleRange.order = order;
return(angleRange);
}
public bool DoesIntersect(AngleRange angleRange, bool equalAnglesIntersect = true)
{
if (equalAnglesIntersect)
{
return((min.degrees >= angleRange.min.degrees && min.degrees <= angleRange.max.degrees) || (angleRange.min.degrees >= min.degrees && angleRange.min.degrees <= max.degrees) || (max.degrees <= angleRange.max.degrees && max.degrees >= angleRange.min.degrees) || (angleRange.max.degrees <= max.degrees && angleRange.max.degrees >= min.degrees));
}
else
{
return((min.degrees > angleRange.min.degrees && min.degrees < angleRange.max.degrees) || (angleRange.min.degrees > min.degrees && angleRange.min.degrees < max.degrees) || (max.degrees < angleRange.max.degrees && max.degrees > angleRange.min.degrees) || (angleRange.max.degrees < max.degrees && angleRange.max.degrees > min.degrees));
}
}
private void GenerateEcoSystem()
{
List <AngleRange> angles = new List <AngleRange>();
SpriteShape spriteShape = GetComponentInChildren <SpriteShapeController>().spriteShape;
bool isDone = false;
int acumSize = 0;
int remainingSize = 360;
int nextMaxSize;
int size;
AngleRange newAngle;
EEcosystem ecosystem;
while (!isDone)
{
nextMaxSize = Math.Min(_maxSize, remainingSize);
remainingSize = 360 - acumSize;
size = UnityEngine.Random.RandomRange(_minSize, nextMaxSize);
if ((acumSize + size) > 360)
{
size = (360 - acumSize);
}
if ((360 - (acumSize + size)) < _minSize)
{
size += (360 - (acumSize + size));
}
newAngle = new AngleRange();
newAngle.sprites = new List <Sprite>();
ecosystem = (EEcosystem)UnityEngine.Random.Range(0, 4);
newAngle.sprites.Add(_ecoSystem[(int)ecosystem]);
newAngle.start = acumSize;
newAngle.end = acumSize + size;
acumSize += size;
remainingSize -= size;
if (remainingSize <= 0)
{
isDone = true;
}
EcosystemAngles[ecosystem].Add(new PlanetControllerInfoEcosystem((int)newAngle.start, (int)newAngle.end, ecosystem));
angles.Add(newAngle);
}
spriteShape.angleRanges = angles;
}
private IEnumerable <AngleRange> GetInvalidRange(Entity from, Entity to)
{
var travelDirection = to.GetPosition() - from.GetPosition();
var centralAngle = travelDirection.ZPlaneAngle();
var angleRange = (float)(Math.Atan2(to.Radius, travelDirection.Length));
var min = centralAngle - angleRange;
var max = centralAngle + angleRange;
return(AngleRange.GetRanges(min, max));
}
public void 正しく角度の判定ができる()
{
AngleRange angleRange;
angleRange = AngleRange.CreateFromStartAngle(Angle.FromDegree(0), DeltaAngle.FromDegree(90));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(0)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(45)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(90)));
angleRange = AngleRange.CreateFromStartAngle(Angle.FromDegree(90), DeltaAngle.FromDegree(90));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(90)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(135)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(180)));
angleRange = AngleRange.CreateFromStartAngle(Angle.FromDegree(270), DeltaAngle.FromDegree(90));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(270)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(315)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(360)));
angleRange = AngleRange.CreateFromStartAngle(Angle.FromDegree(270), DeltaAngle.FromDegree(180));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(270)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(315)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(360)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(0)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(45)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(90)));
angleRange = AngleRange.CreateFromStartAngle(Angle.FromDegree(0), DeltaAngle.FromDegree(-90));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(-0)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(-45)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(-90)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(360)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(315)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(270)));
angleRange = AngleRange.CreateFromStartAngle(Angle.FromDegree(90), DeltaAngle.FromDegree(-90));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(90)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(45)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(0)));
angleRange = AngleRange.CreateFromStartAngle(Angle.FromDegree(90), DeltaAngle.FromDegree(-180));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(90)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(45)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(0)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(360)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(315)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(270)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(-0)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(-45)));
Assert.IsTrue(angleRange.IsInRange(Angle.FromDegree(-90)));
}
public Astronomical(string name, Matrix values, AxisType handedness, AngleRange horizontalRange)
{
if (values.NumberOfColumns != this.Dimension)
{
throw new NotImplementedException();
}
this.m_Name = name;
this.m_Handedness = handedness;
this.m_HorizontalAngle = new AngularCollection <TAngular>(values.GetColumn(0), horizontalRange);
this.m_VerticalAngle = new AngularCollection <TAngular>(values.GetColumn(1), AngleRange.MinusPiTOPi);
}
private void Spawn(GameObject prefab, float distance, Vector2 dot, AngleRange angleRange, float angleRangeLifespan)
{
GameObject obj = Instantiate(prefab, this.transform);
Transform xform = obj.transform;
xform.eulerAngles = Vector3.up * Random.Range(0f, 360f);
xform.localPosition = xform.forward * distance;
if (angleRange != null)
{
blockedRanges.Add(angleRange);
}
StartCoroutine(SpawnCR(obj, dot, angleRange, angleRangeLifespan));
}
public Polar(string name, Matrix values, AxisType handedness, AngleRange range)
{
if (values.NumberOfColumns != this.Dimension)
{
throw new NotImplementedException();
}
this.m_Name = name;
this.m_Handedness = handedness;
this.m_Radius = new LinearCollection <TLinear>(values.GetColumn(0));
this.m_Angle = new AngularCollection <TAngular>(values.GetColumn(1), range);
}
public void SetRange(AngleRange angleRange, float start, float end)
{
var prevStart = angleRange.start;
var prevEnd = angleRange.end;
angleRange.start = start;
angleRange.end = end;
ValidateRange(angleRange, prevStart, prevEnd);
if (angleRange == selectedAngleRange)
{
ClampPreviewAngle(start, end, prevStart, prevEnd);
}
}
public static Geodetic <TLinear, TAngular> AverageToGeodetic <TLinear, TAngular>(
ICartesian3D averageTerrestrial,
IEllipsoid ellipsoid,
AngleRange longitudinalRange)
where TLinear : LinearUnit, new()
where TAngular : AngularUnit, new()
{
//check if cartesian is not Right Handed, do the appropreate task!
ICartesian3D shiftedCoordinate = averageTerrestrial.Shift(ellipsoid.DatumTranslation);
Matrix rotationMatrix = Transformation.CalculateEulerElementMatrix(ellipsoid.DatumMisalignment).Transpose();
return(shiftedCoordinate.Rotate(rotationMatrix).ToGeodeticForm <TLinear, TAngular>(ellipsoid, longitudinalRange));
}
public static Astronomical <TAngular> OrbitalToApparentPlace <TAngular>(ICartesian3D orbital,
AngularUnit rightAscensionOfAscendingNode,
AngularUnit inclination,
AngularUnit argumentOfPerigee,
AngleRange horizontalAngleRange)
where TAngular : AngularUnit, new()
{
Matrix firstRZ = CalculateRotationMatrixAroundZ(rightAscensionOfAscendingNode.Negate());
Matrix rX = CalculateRotationMatrixAroundX(inclination.Negate());
Matrix secondRZ = CalculateRotationMatrixAroundZ(argumentOfPerigee.Negate());
return(orbital.Rotate(firstRZ * rX * secondRZ).ToAstronomicForm <TAngular>(horizontalAngleRange));
}
public Grade(double value, AngleRange range)
: base(value, range)
{
//this.m_Value = this.Adapter.Adopt(value);
this.m_Sign = Math.Sign(value);
this.m_GradePart = (short)Math.Floor(m_Sign * this.Value);
this.m_MinutePart = (byte)Math.Floor((m_Sign * this.Value - this.m_GradePart) * 100);
this.m_SecondPart = (byte)Math.Round(((m_Sign * this.Value - this.m_GradePart) * 100 - this.m_MinutePart) * 100);
this.OnValueChanged += new ValueChangedEventHandler(Grade_OnValueChanged);
//this.m_Range = range;
}
public PolarPoint <TRadius, TAngle> ToPolar <TRadius, TAngle>(AngleRange range)
where TRadius : LinearUnit, new()
where TAngle : AngularUnit, new()
{
TRadius radius = new TRadius();
double tempX = this.X.ChangeTo <TRadius>().Value;
double tempY = this.Y.ChangeTo <TRadius>().Value;
radius.Value = Math.Sqrt(tempX * tempX + tempY * tempY);
Radian angle = new Radian(Math.Atan2(tempY, tempX), range); //use tempX and tempY
return(new PolarPoint <TRadius, TAngle>(radius, angle.ChangeTo <TAngle>())); //do not need to cast!
}
public Degree(double value, AngleRange range)
: base(value, range)
{
//this.m_Value = this.Adapter.Adopt(value);
this._sign = Math.Sign(value);
this._degreePart = (short)Math.Floor(_sign * this.Value);
this._minutePart = (byte)Math.Floor((_sign * this.Value - this._degreePart) * 60);
this._secondPart = (((_sign * this.Value - this._degreePart) * 60 - this._minutePart) * 60);
this.OnValueChanged += new ValueChangedEventHandler(Degree_OnValueChanged);
//this.m_Range = range;
}
public Ellipsoidal(string name, Matrix values, AxisType handedness, AngleRange horizontalRange, IEllipsoid ellipsoid)
{
if (values.NumberOfColumns != this.Dimension)
{
throw new NotImplementedException();
}
this._name = name;
this._handedness = handedness;
this._datum = ellipsoid.ChangeTo <TLinear, TAngular>();
this._horizontalAngle = new AngularCollection <TAngular>(values.GetColumn(0), horizontalRange);
this._verticalAngle = new AngularCollection <TAngular>(values.GetColumn(1), AngleRange.MinusPiTOPi);
}
private void CreateRangeAtAngle(float angle)
{
var start = 0f;
var end = 0f;
if (GetNewRangeBounds(angle, out start, out end))
{
cache.RegisterUndo("Create Range");
var angleRange = new AngleRange();
angleRange.start = start;
angleRange.end = end;
cache.angleRanges.Add(angleRange);
ValidateRange(angleRange);
SetSelectedIndexFromPreviewAngle();
}
}
public void AngleRangeIntersections()
{
{
var s1 = new AngleRange(314, 90);
var s2 = new AngleRange(345, 110);
var inters = s1.Overlaps(s2);
Assert.AreEqual(1, inters.Count);
Assert.AreEqual(59, inters.ElementAt(0).Range);
}
{
var s1 = new AngleRange(0, 180);
var s2 = new AngleRange(75, 30);
var inters = s1.Overlaps(s2);
Assert.AreEqual(1, inters.Count);
Assert.AreEqual(30, inters.ElementAt(0).Range);
}
}
