Net.Like.Xue.Tokyo/Assets/Plugins/Draw XXL/scripts/components/internal utilities/InternalDXXL_BezierControlP...

794 lines
47 KiB
C#
Raw Normal View History

2025-02-24 23:03:39 +08:00
namespace DrawXXL
{
using System;
using UnityEngine;
[Serializable]
public class InternalDXXL_BezierControlPointTriplet2D
{
public bool isHighlighted;
public int i_ofThisPoint_insideControlPointsList;
public BezierSplineDrawer2D bezierSplineDrawer_thisPointIsPartOf;
[SerializeField] public bool alignedHelperPoints_areOnTheSameSideOfTheAnchor;
[SerializeField] public float progress0to1_ofPlusButtonPosition_inUpcomingBezierSegment;
public InternalDXXL_BezierControlAnchorSubPoint2D anchorPoint;
public InternalDXXL_BezierControlHelperSubPoint2D forwardHelperPoint;
public InternalDXXL_BezierControlHelperSubPoint2D backwardHelperPoint;
InternalDXXL_BezierPointShapeConfig2D pointShape_afterSpaceChange_inUnitsOfGlobalSpace;
InternalDXXL_BezierPointShapeConfig2D pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace;
public Rect inspectorRect_reservedForThisTriplet;
public bool minusButtonAtThisListItem_hasBeenClickedInInspector = false;
public void Initialize(BezierSplineDrawer2D containingSplineDrawer, Vector2 initialPos_inUnitsOfGlobalSpace, Vector2 initialForwardDir_inUnitsOfGlobalSpace_normalized, InternalDXXL_BezierControlAnchorSubPoint.JunctureType junctureType)
{
bezierSplineDrawer_thisPointIsPartOf = containingSplineDrawer;
isHighlighted = false; //-> the caller has to decide whether and take care of highlighting newly created control points after this initialization
alignedHelperPoints_areOnTheSameSideOfTheAnchor = false;
progress0to1_ofPlusButtonPosition_inUpcomingBezierSegment = 0.5f;
anchorPoint = new InternalDXXL_BezierControlAnchorSubPoint2D();
anchorPoint.InitializeValuesThatAreIndependentFromOtherSubPoints(this);
anchorPoint.subPointType = InternalDXXL_BezierControlSubPoint.SubPointType.anchor;
anchorPoint.isUsed = true;
anchorPoint.junctureType = junctureType;
anchorPoint.SetPos_inUnitsOfGlobalSpace(initialPos_inUnitsOfGlobalSpace, false, null);
forwardHelperPoint = new InternalDXXL_BezierControlHelperSubPoint2D();
forwardHelperPoint.InitializeValuesThatAreIndependentFromOtherSubPoints(this);
forwardHelperPoint.subPointType = InternalDXXL_BezierControlSubPoint.SubPointType.forwardHelper;
forwardHelperPoint.isForward_notBackward = true;
forwardHelperPoint.isUsed = true;
forwardHelperPoint.Set_direction_fromMountingAnchorToThisHelperPoint_inUnitsOfGlobalSpace_normalized(initialForwardDir_inUnitsOfGlobalSpace_normalized, false, null);
float initial_forwardWeightDistance_inUnitsOfGlobalSpace = bezierSplineDrawer_thisPointIsPartOf.TransformLength_fromUnitsOfActiveDrawSpace_toGlobalSpace(bezierSplineDrawer_thisPointIsPartOf.forwardWeightDistance_ofNewlyCreatedPoints_inUnitsOfActiveDrawSpace);
Vector2 initialPos_ofForwardHelperPoint_inUnitsOfGlobalSpace = initialPos_inUnitsOfGlobalSpace + initialForwardDir_inUnitsOfGlobalSpace_normalized * initial_forwardWeightDistance_inUnitsOfGlobalSpace;
forwardHelperPoint.SetPos_inUnitsOfGlobalSpace(initialPos_ofForwardHelperPoint_inUnitsOfGlobalSpace, false, null);
forwardHelperPoint.Set_absDistanceToAnchorPoint_inUnitsOfGlobalSpace(initial_forwardWeightDistance_inUnitsOfGlobalSpace, false, null);
backwardHelperPoint = new InternalDXXL_BezierControlHelperSubPoint2D();
backwardHelperPoint.InitializeValuesThatAreIndependentFromOtherSubPoints(this);
backwardHelperPoint.subPointType = InternalDXXL_BezierControlSubPoint.SubPointType.backwardHelper;
backwardHelperPoint.isForward_notBackward = false;
backwardHelperPoint.isUsed = true;
backwardHelperPoint.Set_direction_fromMountingAnchorToThisHelperPoint_inUnitsOfGlobalSpace_normalized(-initialForwardDir_inUnitsOfGlobalSpace_normalized, false, null);
float initial_backwardWeightDistance_inUnitsOfGlobalSpace = bezierSplineDrawer_thisPointIsPartOf.TransformLength_fromUnitsOfActiveDrawSpace_toGlobalSpace(bezierSplineDrawer_thisPointIsPartOf.backwardWeightDistance_ofNewlyCreatedPoints_inUnitsOfActiveDrawSpace);
Vector2 initialPos_ofBackwardHelperPoint_inUnitsOfGlobalSpace = initialPos_inUnitsOfGlobalSpace - initialForwardDir_inUnitsOfGlobalSpace_normalized * initial_backwardWeightDistance_inUnitsOfGlobalSpace;
backwardHelperPoint.SetPos_inUnitsOfGlobalSpace(initialPos_ofBackwardHelperPoint_inUnitsOfGlobalSpace, false, null);
backwardHelperPoint.Set_absDistanceToAnchorPoint_inUnitsOfGlobalSpace(initial_backwardWeightDistance_inUnitsOfGlobalSpace, false, null);
}
public void ReassignIndexInsideControlPointsList(int new_i)
{
i_ofThisPoint_insideControlPointsList = new_i;
if (anchorPoint != null) //-> skipping newly created points (whose sub points don't exist yet). They get the value in the "controlPointTriplet.Initialize()" function
{
anchorPoint.ReassignIndexInsideControlPointsList(new_i);
}
if (forwardHelperPoint != null) //-> skipping newly created points (whose sub points don't exist yet). They get the value in the "controlPointTriplet.Initialize()" function
{
forwardHelperPoint.ReassignIndexInsideControlPointsList(new_i);
}
if (backwardHelperPoint != null) //-> skipping newly created points (whose sub points don't exist yet). They get the value in the "controlPointTriplet.Initialize()" function
{
backwardHelperPoint.ReassignIndexInsideControlPointsList(new_i);
}
}
public InternalDXXL_BezierControlHelperSubPoint2D GetAHelperPoint(bool requestedHelperPoint_isForward_notBackward)
{
if (requestedHelperPoint_isForward_notBackward)
{
return forwardHelperPoint;
}
else
{
return backwardHelperPoint;
}
}
public InternalDXXL_BezierControlSubPoint2D GetASubPoint(InternalDXXL_BezierControlSubPoint.SubPointType typeOfRequestedSubPoint)
{
switch (typeOfRequestedSubPoint)
{
case InternalDXXL_BezierControlSubPoint.SubPointType.backwardHelper:
return backwardHelperPoint;
case InternalDXXL_BezierControlSubPoint.SubPointType.anchor:
return anchorPoint;
case InternalDXXL_BezierControlSubPoint.SubPointType.forwardHelper:
return forwardHelperPoint;
default:
return anchorPoint;
}
}
public bool IsFirstControlPoint()
{
return bezierSplineDrawer_thisPointIsPartOf.IsFirstControlPoint(this);
}
public bool IsLastControlPoint()
{
return bezierSplineDrawer_thisPointIsPartOf.IsLastControlPoint(this);
}
public InternalDXXL_BezierControlPointTriplet2D GetNextControlPointTripletAlongSplineDir(bool allowRequestingControlPointAsResult_inCaseOfRingSplineOfOnlyOneControlPointTriplet)
{
return bezierSplineDrawer_thisPointIsPartOf.GetNextControlPointTriplet(this, allowRequestingControlPointAsResult_inCaseOfRingSplineOfOnlyOneControlPointTriplet);
}
public InternalDXXL_BezierControlPointTriplet2D GetPreviousControlPointTripletAlongSplineDir(bool allowRequestingControlPointAsResult_inCaseOfRingSplineOfOnlyOneControlPointTriplet)
{
return bezierSplineDrawer_thisPointIsPartOf.GetPreviousControlPointTriplet(this, allowRequestingControlPointAsResult_inCaseOfRingSplineOfOnlyOneControlPointTriplet);
}
public void Save_currentPosConfigInUnitsOfGlobalSpace_as_posConfigAfterSpaceChangeInUnitsOfGlobalSpace()
{
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.anchorPos = anchorPoint.GetPos_inUnitsOfGlobalSpace();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.direction_toForward_normalized = anchorPoint.Get_direction_toForward_inUnitsOfGlobalSpace_normalized();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.direction_toBackward_normalized = anchorPoint.Get_direction_toBackward_inUnitsOfGlobalSpace_normalized();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.forwardHelperPos = forwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.absDistanceToForwardAnchorPoint = forwardHelperPoint.Get_absDistanceToAnchorPoint_inUnitsOfGlobalSpace();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.backwardHelperPos = backwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.absDistanceToBackwardAnchorPoint = backwardHelperPoint.Get_absDistanceToAnchorPoint_inUnitsOfGlobalSpace();
}
public void Save_currentPosConfigInUnitsOfActiveDrawSpace_as_posConfigAfterSpaceChangeInUnitsOfActiveDrawSpace()
{
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.anchorPos = anchorPoint.GetPos_inUnitsOfActiveDrawSpace();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.direction_toForward_normalized = anchorPoint.Get_direction_toForward_inUnitsOfActiveDrawSpace_normalized();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.direction_toBackward_normalized = anchorPoint.Get_direction_toBackward_inUnitsOfActiveDrawSpace_normalized();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.forwardHelperPos = forwardHelperPoint.GetPos_inUnitsOfActiveDrawSpace();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.absDistanceToForwardAnchorPoint = forwardHelperPoint.Get_absDistanceToAnchorPoint_inUnitsOfActiveDrawSpace();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.backwardHelperPos = backwardHelperPoint.GetPos_inUnitsOfActiveDrawSpace();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.absDistanceToBackwardAnchorPoint = backwardHelperPoint.Get_absDistanceToAnchorPoint_inUnitsOfActiveDrawSpace();
}
public void Save_currentPosConfigInUnitsOfActiveDrawSpace_as_posConfigAfterSpaceChangeInUnitsOfGlobalSpace()
{
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.anchorPos = anchorPoint.GetPos_inUnitsOfActiveDrawSpace();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.direction_toForward_normalized = anchorPoint.Get_direction_toForward_inUnitsOfActiveDrawSpace_normalized();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.direction_toBackward_normalized = anchorPoint.Get_direction_toBackward_inUnitsOfActiveDrawSpace_normalized();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.forwardHelperPos = forwardHelperPoint.GetPos_inUnitsOfActiveDrawSpace();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.absDistanceToForwardAnchorPoint = forwardHelperPoint.Get_absDistanceToAnchorPoint_inUnitsOfActiveDrawSpace();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.backwardHelperPos = backwardHelperPoint.GetPos_inUnitsOfActiveDrawSpace();
pointShape_afterSpaceChange_inUnitsOfGlobalSpace.absDistanceToBackwardAnchorPoint = backwardHelperPoint.Get_absDistanceToAnchorPoint_inUnitsOfActiveDrawSpace();
}
public void Save_currentPosConfigInUnitsOfGlobalSpace_as_posConfigAfterSpaceChangeInUnitsOfActiveDrawSpace()
{
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.anchorPos = anchorPoint.GetPos_inUnitsOfGlobalSpace();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.direction_toForward_normalized = anchorPoint.Get_direction_toForward_inUnitsOfGlobalSpace_normalized();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.direction_toBackward_normalized = anchorPoint.Get_direction_toBackward_inUnitsOfGlobalSpace_normalized();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.forwardHelperPos = forwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.absDistanceToForwardAnchorPoint = forwardHelperPoint.Get_absDistanceToAnchorPoint_inUnitsOfGlobalSpace();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.backwardHelperPos = backwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.absDistanceToBackwardAnchorPoint = backwardHelperPoint.Get_absDistanceToAnchorPoint_inUnitsOfGlobalSpace();
}
public void ApplySaved_posConfigAfterSpaceChangeInUnitsOfGlobalSpace()
{
anchorPoint.SetPos_inUnitsOfGlobalSpace(pointShape_afterSpaceChange_inUnitsOfGlobalSpace.anchorPos, false, null);
anchorPoint.Set_direction_toForward_inUnitsOfGlobalSpace_normalized(pointShape_afterSpaceChange_inUnitsOfGlobalSpace.direction_toForward_normalized, false, null);
anchorPoint.Set_direction_toBackward_inUnitsOfGlobalSpace_normalized(pointShape_afterSpaceChange_inUnitsOfGlobalSpace.direction_toBackward_normalized, false, null);
forwardHelperPoint.SetPos_inUnitsOfGlobalSpace(pointShape_afterSpaceChange_inUnitsOfGlobalSpace.forwardHelperPos, false, null);
forwardHelperPoint.Set_absDistanceToAnchorPoint_inUnitsOfGlobalSpace(pointShape_afterSpaceChange_inUnitsOfGlobalSpace.absDistanceToForwardAnchorPoint, false, null);
backwardHelperPoint.SetPos_inUnitsOfGlobalSpace(pointShape_afterSpaceChange_inUnitsOfGlobalSpace.backwardHelperPos, false, null);
backwardHelperPoint.Set_absDistanceToAnchorPoint_inUnitsOfGlobalSpace(pointShape_afterSpaceChange_inUnitsOfGlobalSpace.absDistanceToBackwardAnchorPoint, false, null);
}
public void ApplySaved_posConfigAfterSpaceChangeInUnitsOfActiveDrawSpace()
{
anchorPoint.SetPos_inUnitsOfActiveDrawSpace(pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.anchorPos, false, null);
anchorPoint.Set_direction_toForward_inUnitsOfActiveDrawSpace_normalized(pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.direction_toForward_normalized, false, null);
anchorPoint.Set_direction_toBackward_inUnitsOfActiveDrawSpace_normalized(pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.direction_toBackward_normalized, false, null);
forwardHelperPoint.SetPos_inUnitsOfActiveDrawSpace(pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.forwardHelperPos, false, null);
forwardHelperPoint.Set_absDistanceToAnchorPoint_inUnitsOfActiveDrawSpace(pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.absDistanceToForwardAnchorPoint, false, null);
backwardHelperPoint.SetPos_inUnitsOfActiveDrawSpace(pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.backwardHelperPos, false, null);
backwardHelperPoint.Set_absDistanceToAnchorPoint_inUnitsOfActiveDrawSpace(pointShape_afterSpaceChange_inUnitsOfActiveDrawSpace.absDistanceToBackwardAnchorPoint, false, null);
}
public bool IsEndPointToVoid_atStartOrEndOfAnUnclosedSpline()
{
if (bezierSplineDrawer_thisPointIsPartOf.gapFromEndToStart_isClosed == false)
{
if (IsFirstControlPoint() || IsLastControlPoint())
{
return true;
}
}
return false;
}
public bool IsPartOfThisTriplet(InternalDXXL_BezierControlSubPoint2D subPointToCheckIfItIsPartOfThisTriplet)
{
if (subPointToCheckIfItIsPartOfThisTriplet == backwardHelperPoint)
{
return true;
}
if (subPointToCheckIfItIsPartOfThisTriplet == anchorPoint)
{
return true;
}
if (subPointToCheckIfItIsPartOfThisTriplet == forwardHelperPoint)
{
return true;
}
return false;
}
public bool CheckIf_foldableHelperPoints_areUnfolded_inTheInspectorList()
{
if (backwardHelperPoint.IsUnusedHelperPointAtStartOrEndOfUnclosedSplines_onTheControlPointSideTowardsVoid())
{
//-> not foldable
}
else
{
if (backwardHelperPoint.isOutfoldedInInspector == false)
{
return false;
}
}
if (forwardHelperPoint.IsUnusedHelperPointAtStartOrEndOfUnclosedSplines_onTheControlPointSideTowardsVoid())
{
//-> not foldable
}
else
{
if (forwardHelperPoint.isOutfoldedInInspector == false)
{
return false;
}
}
return true;
}
public bool CheckIf_foldableHelperPoints_areCollapsed_inTheInspectorList()
{
if (backwardHelperPoint.IsUnusedHelperPointAtStartOrEndOfUnclosedSplines_onTheControlPointSideTowardsVoid())
{
//-> not foldable
}
else
{
if (backwardHelperPoint.isOutfoldedInInspector)
{
return false;
}
}
if (forwardHelperPoint.IsUnusedHelperPointAtStartOrEndOfUnclosedSplines_onTheControlPointSideTowardsVoid())
{
//-> not foldable
}
else
{
if (forwardHelperPoint.isOutfoldedInInspector)
{
return false;
}
}
return true;
}
public void UnfoldBothHelperPointInTheInspectorList()
{
backwardHelperPoint.isOutfoldedInInspector = true;
forwardHelperPoint.isOutfoldedInInspector = true;
}
public void CollapseBothHelperPointInTheInspectorList()
{
backwardHelperPoint.isOutfoldedInInspector = false;
forwardHelperPoint.isOutfoldedInInspector = false;
}
public Vector2 GetPosAtPlusButton_onUpcomingBezierSegment_inUnitsOfGlobalSpace()
{
return GetAPos_onUpcomingBezierSegment_inUnitsOfGlobalSpace(progress0to1_ofPlusButtonPosition_inUpcomingBezierSegment);
}
public Vector2 GetAPos_onUpcomingBezierSegment_inUnitsOfGlobalSpace(float progress0to1_inUpcomingBezierSegment)
{
InternalDXXL_BezierControlPointTriplet2D nextControlPointTriplet = GetNextControlPointTripletAlongSplineDir(true);
if (nextControlPointTriplet == null)
{
return anchorPoint.GetPos_inUnitsOfGlobalSpace();
}
else
{
Vector2 segmentStartPos = anchorPoint.GetPos_inUnitsOfGlobalSpace();
Vector2 segmentEndPos = nextControlPointTriplet.anchorPoint.GetPos_inUnitsOfGlobalSpace();
if (forwardHelperPoint.isUsed == true)
{
Vector2 firstControlPosInBetween = forwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
if (nextControlPointTriplet.backwardHelperPoint.isUsed == true)
{
Vector2 secondControlPosInBetween = nextControlPointTriplet.backwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
return GetPos_onCubicBezierSegment(progress0to1_inUpcomingBezierSegment, segmentStartPos, firstControlPosInBetween, secondControlPosInBetween, segmentEndPos);
}
else
{
return GetPos_onQuadraticBezierSegment(progress0to1_inUpcomingBezierSegment, segmentStartPos, firstControlPosInBetween, segmentEndPos);
}
}
else
{
if (nextControlPointTriplet.backwardHelperPoint.isUsed == true)
{
Vector2 theSingleControlPosInBetween = nextControlPointTriplet.backwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
return GetPos_onQuadraticBezierSegment(progress0to1_inUpcomingBezierSegment, segmentStartPos, theSingleControlPosInBetween, segmentEndPos);
}
else
{
//straight line:
Vector2 fromStart_toEnd = segmentEndPos - segmentStartPos;
return (segmentStartPos + fromStart_toEnd * progress0to1_inUpcomingBezierSegment);
}
}
}
}
Vector2 GetPos_onQuadraticBezierSegment(float progress_0to1, Vector2 segmentStartPos, Vector2 controlPosInBetween, Vector2 segmentEndPos)
{
float oneMinusProgress0to1 = 1.0f - progress_0to1;
float factor1 = oneMinusProgress0to1 * oneMinusProgress0to1;
float factor2 = 2.0f * oneMinusProgress0to1 * progress_0to1;
float factor3 = progress_0to1 * progress_0to1;
return (factor1 * segmentStartPos + factor2 * controlPosInBetween + factor3 * segmentEndPos);
}
Vector2 GetPos_onCubicBezierSegment(float progress_0to1, Vector2 segmentStartPos, Vector2 firstControlPosInBetween, Vector2 secondControlPosInBetween, Vector2 segmentEndPos)
{
float progress_0to1_sqr = progress_0to1 * progress_0to1;
float oneMinusProgress0to1 = 1.0f - progress_0to1;
float oneMinusProgress0to1_sqr = oneMinusProgress0to1 * oneMinusProgress0to1;
float factor1 = oneMinusProgress0to1 * oneMinusProgress0to1_sqr;
float factor2 = 3.0f * oneMinusProgress0to1_sqr * progress_0to1;
float factor3 = 3.0f * oneMinusProgress0to1 * progress_0to1_sqr;
float factor4 = progress_0to1 * progress_0to1_sqr;
return (factor1 * segmentStartPos + factor2 * firstControlPosInBetween + factor3 * secondControlPosInBetween + factor4 * segmentEndPos);
}
public Vector2 GetTangentAtPlusButton_onUpcomingBezierSegment_inUnitsOfGlobalSpace(bool normalized)
{
return GetATangent_onUpcomingBezierSegment_inUnitsOfGlobalSpace(progress0to1_ofPlusButtonPosition_inUpcomingBezierSegment, normalized);
}
public Vector2 GetATangent_onUpcomingBezierSegment_inUnitsOfGlobalSpace(float progress0to1_inUpcomingBezierSegment, bool normalized)
{
InternalDXXL_BezierControlPointTriplet2D nextControlPointTriplet = GetNextControlPointTripletAlongSplineDir(true);
if (nextControlPointTriplet == null)
{
return bezierSplineDrawer_thisPointIsPartOf.Get_forwardTangent_ofControlPointThatDoesntKnowOfANextOne_inUnitsOfGlobalSpace_normalized(this);
}
else
{
Vector2 tangent_notNormalized;
Vector2 segmentStartPos = anchorPoint.GetPos_inUnitsOfGlobalSpace();
Vector2 segmentEndPos = nextControlPointTriplet.anchorPoint.GetPos_inUnitsOfGlobalSpace();
if (forwardHelperPoint.isUsed == true)
{
Vector2 firstControlPosInBetween = forwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
if (nextControlPointTriplet.backwardHelperPoint.isUsed == true)
{
Vector2 secondControlPosInBetween = nextControlPointTriplet.backwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
tangent_notNormalized = GetTangent_onCubicBezierSegment(progress0to1_inUpcomingBezierSegment, segmentStartPos, firstControlPosInBetween, secondControlPosInBetween, segmentEndPos);
}
else
{
tangent_notNormalized = GetTangent_onQuadraticBezierSegment(progress0to1_inUpcomingBezierSegment, segmentStartPos, firstControlPosInBetween, segmentEndPos);
}
}
else
{
if (nextControlPointTriplet.backwardHelperPoint.isUsed == true)
{
Vector2 theSingleControlPosInBetween = nextControlPointTriplet.backwardHelperPoint.GetPos_inUnitsOfGlobalSpace();
tangent_notNormalized = GetTangent_onQuadraticBezierSegment(progress0to1_inUpcomingBezierSegment, segmentStartPos, theSingleControlPosInBetween, segmentEndPos);
}
else
{
//straight line:
Vector2 fromStart_toEnd = segmentEndPos - segmentStartPos;
if (UtilitiesDXXL_Math.ApproximatelyZero(fromStart_toEnd))
{
return bezierSplineDrawer_thisPointIsPartOf.Get_forwardTangent_ofControlPointThatDoesntKnowOfANextOne_inUnitsOfGlobalSpace_normalized(this);
}
else
{
tangent_notNormalized = fromStart_toEnd;
}
}
}
if (normalized)
{
Vector2 tangent_normalized = UtilitiesDXXL_Math.GetNormalized_afterScalingIntoRegionOfFloatPrecicion(tangent_notNormalized);
if (UtilitiesDXXL_Math.CheckIfNormalizationFailed_meaningLineStayedTooShort(tangent_normalized))
{
return bezierSplineDrawer_thisPointIsPartOf.Get_right_ofActiveDrawSpace_inUnitsOfGlobalSpace_normalized();
}
else
{
return tangent_normalized;
}
}
else
{
return tangent_notNormalized;
}
}
}
Vector2 GetTangent_onQuadraticBezierSegment(float progress_0to1, Vector2 segmentStartPos, Vector2 controlPosInBetween, Vector2 segmentEndPos)
{
return (2.0f * (1.0f - progress_0to1) * (controlPosInBetween - segmentStartPos) + 2.0f * progress_0to1 * (segmentEndPos - controlPosInBetween));
}
Vector2 GetTangent_onCubicBezierSegment(float progress_0to1, Vector2 segmentStartPos, Vector2 firstControlPosInBetween, Vector2 secondControlPosInBetween, Vector2 segmentEndPos)
{
float progress_0to1_sqr = progress_0to1 * progress_0to1;
float oneMinusProgress0to1 = 1.0f - progress_0to1;
return (3.0f * oneMinusProgress0to1 * oneMinusProgress0to1 * (firstControlPosInBetween - segmentStartPos) + (6.0f * oneMinusProgress0to1 * progress_0to1) * (secondControlPosInBetween - firstControlPosInBetween) + 3.0f * progress_0to1_sqr * (segmentEndPos - secondControlPosInBetween));
}
public void Invert_alignedHelperPoints_areOnTheSameSideOfTheAnchor()
{
alignedHelperPoints_areOnTheSameSideOfTheAnchor = !alignedHelperPoints_areOnTheSameSideOfTheAnchor;
}
public void DrawValuesToInspector()
{
TryHighlightThisControlPoint_dueToMouseClickOnItInInspector();
DrawBackgroundArea_forInspector();
DrawSubPoints_forInspector();
}
void TryHighlightThisControlPoint_dueToMouseClickOnItInInspector()
{
Event currentEvent = Event.current;
if (currentEvent.type == EventType.MouseDown)
{
if (inspectorRect_reservedForThisTriplet.Contains(currentEvent.mousePosition))
{
bezierSplineDrawer_thisPointIsPartOf.SetSelectedListSlot(i_ofThisPoint_insideControlPointsList);
bezierSplineDrawer_thisPointIsPartOf.SheduleSceneViewRepaint();
}
}
}
void DrawBackgroundArea_forInspector()
{
Rect space_ofBigBackgroundColorRect = new Rect(Get_xPos_ofBackgroundRect(inspectorRect_reservedForThisTriplet), Get_yPos_ofBackgroundRect(inspectorRect_reservedForThisTriplet), Get_width_ofBackgroundRect(inspectorRect_reservedForThisTriplet), inspectorRect_reservedForThisTriplet.height - 2.0f * Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox() - Get_inspectorVertSpace_ofMinusButtonOnEachControlPoint());
float alphaFactor_ofBackgroundColor = isHighlighted ? InternalDXXL_BezierControlPointTriplet.alpha_ofInspectorBackgroundColor_highlighted : InternalDXXL_BezierControlPointTriplet.alpha_ofInspectorBackgroundColor_nonHighlighted;
Color backgroundColor = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(bezierSplineDrawer_thisPointIsPartOf.color_ofAnchorPoints, alphaFactor_ofBackgroundColor);
DrawBackgroundColor_forInspector(space_ofBigBackgroundColorRect, backgroundColor);
//See also "Get_xPos_ofPlusAndMinusButtonRect()":
//float y_of_minusButton = position.y + position.height - inspectorVertSpace_from_mainRect_to_backgroundColorBox - inspectorVertSpace_ofMinusButtonOnEachControlPoint; //-> float calculation imprecision errors seems to introduce overlap offsets of 1 pixel when calculated like this
//float y_of_minusButton = space_ofBigBackgroundColorRect.y + space_ofBigBackgroundColorRect.height; //-> this also is not solving the 1 pixel overlap offset
//float y_of_minusButton = space_ofBigBackgroundColorRect.yMax; //-> this also is not solving the 1 pixel overlap offset
float y_of_minusButton = space_ofBigBackgroundColorRect.yMax + 1.0f; //-> fixing it manually (with the risk of adding an empty pixel line if there are situations where the problem doesn't occur)
DrawMinusButton_forInspector(backgroundColor, y_of_minusButton);
DrawIndexNumber_forInspector(backgroundColor, y_of_minusButton);
}
void DrawBackgroundColor_forInspector(Rect space_ofBigBackgroundColorRect, Color backgroundColor)
{
#if UNITY_EDITOR
UnityEditor.EditorGUI.DrawRect(space_ofBigBackgroundColorRect, backgroundColor);
#endif
}
void DrawMinusButton_forInspector(Color backgroundColor, float y_of_minusButton)
{
#if UNITY_EDITOR
Rect space_ofMinusButtonBackground = new Rect(Get_xPos_ofPlusAndMinusButtonRect(inspectorRect_reservedForThisTriplet), y_of_minusButton, Get_width_ofPlusAndMinusButtons(), Get_inspectorVertSpace_ofMinusButtonOnEachControlPoint());
UnityEditor.EditorGUI.DrawRect(space_ofMinusButtonBackground, backgroundColor);
GUIContent minusSymbolIcon = UnityEditor.EditorGUIUtility.TrIconContent("Toolbar Minus", "Delete control point");
GUIStyle style_ofMinusButton = "RL FooterButton";
minusButtonAtThisListItem_hasBeenClickedInInspector = GUI.Button(space_ofMinusButtonBackground, minusSymbolIcon, style_ofMinusButton);
#endif
}
void DrawIndexNumber_forInspector(Color backgroundColor, float y_of_minusButton)
{
#if UNITY_EDITOR
float horizSpace_betweenSlotIndexNumber_and_minusButton = 0.5f * UnityEditor.EditorGUIUtility.singleLineHeight;
float horizPadding_besideIndexNumberInsideNumberRect_perSide = 0.5f * UnityEditor.EditorGUIUtility.singleLineHeight;
float horizPadding_besideIndexNumberInsideNumberRect_forBothSides = 2.0f * horizPadding_besideIndexNumberInsideNumberRect_perSide;
float width_perNumberDigit = 0.6f * UnityEditor.EditorGUIUtility.singleLineHeight;
float width_ofSlotIndexNumberRect = horizPadding_besideIndexNumberInsideNumberRect_forBothSides + width_perNumberDigit * GetNumberOfDigitsInIndexNumber();
Rect space_ofSlotIndexNumberBackground = new Rect(inspectorRect_reservedForThisTriplet.x + inspectorRect_reservedForThisTriplet.width - Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox() - Get_width_ofPlusAndMinusButtons() - horizSpace_betweenSlotIndexNumber_and_minusButton - width_ofSlotIndexNumberRect, y_of_minusButton, width_ofSlotIndexNumberRect, Get_inspectorVertSpace_ofMinusButtonOnEachControlPoint());
UnityEditor.EditorGUI.DrawRect(space_ofSlotIndexNumberBackground, backgroundColor);
GUIStyle style_ofNumber = new GUIStyle();
Color color_ofNumber;
if (isHighlighted)
{
color_ofNumber = UtilitiesDXXL_Colors.GetSimilarColorWithOtherBrightnessValue(bezierSplineDrawer_thisPointIsPartOf.color_ofAnchorPoints, 0.375f);
}
else
{
color_ofNumber = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(bezierSplineDrawer_thisPointIsPartOf.color_ofAnchorPoints, 0.725f);
}
string textString_ofNumber = "<size=16><color=#" + ColorUtility.ToHtmlStringRGBA(color_ofNumber) + "><b>" + i_ofThisPoint_insideControlPointsList + "</b></color></size>";
float y_offset_ofSlotIndexNumber = -0.1f * UnityEditor.EditorGUIUtility.singleLineHeight;
Rect space_ofSlotIndexNumber = new Rect(space_ofSlotIndexNumberBackground.x + horizPadding_besideIndexNumberInsideNumberRect_perSide, space_ofSlotIndexNumberBackground.y + y_offset_ofSlotIndexNumber, space_ofSlotIndexNumberBackground.width - horizPadding_besideIndexNumberInsideNumberRect_forBothSides, space_ofSlotIndexNumberBackground.height);
UnityEditor.EditorGUI.LabelField(space_ofSlotIndexNumber, textString_ofNumber, style_ofNumber);
#endif
}
int GetNumberOfDigitsInIndexNumber()
{
if (i_ofThisPoint_insideControlPointsList >= 10000)
{
return 5;
}
else
{
if (i_ofThisPoint_insideControlPointsList >= 1000)
{
return 4;
}
else
{
if (i_ofThisPoint_insideControlPointsList >= 100)
{
return 3;
}
else
{
if (i_ofThisPoint_insideControlPointsList >= 10)
{
return 2;
}
else
{
return 1;
}
}
}
}
}
void DrawSubPoints_forInspector()
{
float height_ofBackwardHelper = backwardHelperPoint.GetPropertyHeightForInspectorList();
float height_ofAnchor = anchorPoint.GetPropertyHeightForInspectorList();
float height_ofForwardHelper = forwardHelperPoint.GetPropertyHeightForInspectorList();
float x_ofHelperPointsColorBox = inspectorRect_reservedForThisTriplet.x + Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox() + Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge();
float width_ofHelperPointsColorBox = inspectorRect_reservedForThisTriplet.width - 2.0f * Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox() - 2.0f * Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge();
float currentHeightOffset = 0.0f;
currentHeightOffset += Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox();
currentHeightOffset += Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge();
Rect rect_of_backwardHelperPoint = new Rect(x_ofHelperPointsColorBox, inspectorRect_reservedForThisTriplet.y + currentHeightOffset, width_ofHelperPointsColorBox, height_ofBackwardHelper);
currentHeightOffset += height_ofBackwardHelper;
currentHeightOffset += Get_inspectorVertSpace_betweenSubPoints();
float x_ofAnchorPointsSubProperty = inspectorRect_reservedForThisTriplet.x + Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox() + Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge() + InternalDXXL_BezierControlHelperSubPoint.Get_inspectorHorizSpace_between_subPointColorBoxEdge_and_actualContenFields();
float width_ofAnchorPointsSubProperty = inspectorRect_reservedForThisTriplet.width - 2.0f * Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox() - 2.0f * Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge() - 2.0f * InternalDXXL_BezierControlHelperSubPoint.Get_inspectorHorizSpace_between_subPointColorBoxEdge_and_actualContenFields();
Rect rect_of_anchorPoint = new Rect(x_ofAnchorPointsSubProperty, inspectorRect_reservedForThisTriplet.y + currentHeightOffset, width_ofAnchorPointsSubProperty, height_ofAnchor);
currentHeightOffset += height_ofAnchor;
currentHeightOffset += Get_inspectorVertSpace_betweenSubPoints();
Rect rect_of_forwardHelperPoint = new Rect(x_ofHelperPointsColorBox, inspectorRect_reservedForThisTriplet.y + currentHeightOffset, width_ofHelperPointsColorBox, height_ofForwardHelper);
backwardHelperPoint.DrawValuesToInspector(rect_of_backwardHelperPoint);
anchorPoint.DrawValuesToInspector(rect_of_anchorPoint);
forwardHelperPoint.DrawValuesToInspector(rect_of_forwardHelperPoint);
}
public bool TryApplyChangesAfterInspectorInput()
{
bool didChangeSomething;
didChangeSomething = backwardHelperPoint.TryApplyChangesAfterInspectorInput();
if (didChangeSomething) { return true; }
didChangeSomething = anchorPoint.TryApplyChangesAfterInspectorInput();
if (didChangeSomething) { return true; }
didChangeSomething = forwardHelperPoint.TryApplyChangesAfterInspectorInput();
if (didChangeSomething) { return true; }
return false;
}
public float GetPropertyHeightForInspectorList()
{
float height_ofBackwardHelper = backwardHelperPoint.GetPropertyHeightForInspectorList();
float height_ofAnchor = anchorPoint.GetPropertyHeightForInspectorList();
float height_ofForwardHelper = forwardHelperPoint.GetPropertyHeightForInspectorList();
float additionalHeight = Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox() + Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge() + Get_inspectorVertSpace_betweenSubPoints() + Get_inspectorVertSpace_betweenSubPoints() + Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge() + Get_inspectorVertSpace_ofMinusButtonOnEachControlPoint() + Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox();
return (height_ofBackwardHelper + height_ofAnchor + height_ofForwardHelper + additionalHeight);
}
public static void DrawEmptyControlPointHoldingOnlyAPlusButton_forInspector(out bool plusButtonBelowListOfControlPoints_hasBeenClicked, out bool unfoldAllWeightsBelowListOfControlPoints_hasBeenClicked, out bool collapseAllWeightsBelowListOfControlPoints_hasBeenClicked, Rect position, Color color_ofAnchorPoints, GUIContent plusSymbolIcon, bool greyOutUnfoldAllButton, bool greyOutCollapseAllButton)
{
#if UNITY_EDITOR
Color backgroundColor = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(color_ofAnchorPoints, InternalDXXL_BezierControlPointTriplet.alpha_ofInspectorBackgroundColor_nonHighlighted);
Rect rect_ofEmptyLine = new Rect(Get_xPos_ofBackgroundRect(position), Get_yPos_ofBackgroundRect(position), Get_width_ofBackgroundRect(position), Get_inspectorVertSpace_ofEmptyLineOfEmptyControlPointHoldingOnlyAPlusButton());
UnityEditor.EditorGUI.DrawRect(rect_ofEmptyLine, backgroundColor);
Rect rect_ofPlusButtonBelowEmptyLine = new Rect(Get_xPos_ofPlusAndMinusButtonRect(position), position.y + Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox() + Get_inspectorVertSpace_ofEmptyLineOfEmptyControlPointHoldingOnlyAPlusButton(), Get_width_ofPlusAndMinusButtons(), Get_inspectorVertSpace_ofMinusButtonOnEachControlPoint());
UnityEditor.EditorGUI.DrawRect(rect_ofPlusButtonBelowEmptyLine, backgroundColor);
GUIStyle style_ofMinusButton = "RL FooterButton";
plusButtonBelowListOfControlPoints_hasBeenClicked = GUI.Button(rect_ofPlusButtonBelowEmptyLine, plusSymbolIcon, style_ofMinusButton);
Rect rect_ofBothFoldAllButtons = new Rect(Get_xPos_ofBackgroundRect(position), position.y + Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox() + Get_inspectorVertSpace_ofEmptyLineOfEmptyControlPointHoldingOnlyAPlusButton() + Get_inspectorVertSpace_ofMinusButtonOnEachControlPoint() + Get_additionalInspectorVertSpace_belowEmptyPlusLine_tillFoldAllButtons(), Get_width_ofBackgroundRect(position), Get_inspectorVertSpace_forFoldAllButtons());
float halfHorizSpaceBetweenButtons = 0.5f * Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox();
Rect rect_ofUnfoldAllButton = new Rect(rect_ofBothFoldAllButtons.x, rect_ofBothFoldAllButtons.y, rect_ofBothFoldAllButtons.width * 0.5f - halfHorizSpaceBetweenButtons, rect_ofBothFoldAllButtons.height);
Rect rect_ofCollapseAllButton = new Rect(rect_ofBothFoldAllButtons.x + rect_ofBothFoldAllButtons.width * 0.5f + halfHorizSpaceBetweenButtons, rect_ofBothFoldAllButtons.y, rect_ofBothFoldAllButtons.width * 0.5f - halfHorizSpaceBetweenButtons, rect_ofBothFoldAllButtons.height);
GUIStyle style_ofUnfoldAllButtons = new GUIStyle(style_ofMinusButton);
style_ofUnfoldAllButtons.fontStyle = FontStyle.Normal;
Color color_ofAGreyedOut_foldAllButton = UtilitiesDXXL_Colors.Get_color_butWithAdjustedAlpha(backgroundColor, 0.5f);
Color color_ofUnfoldAllButton = greyOutUnfoldAllButton ? color_ofAGreyedOut_foldAllButton : backgroundColor;
UnityEditor.EditorGUI.DrawRect(rect_ofUnfoldAllButton, color_ofUnfoldAllButton);
UnityEditor.EditorGUI.BeginDisabledGroup(greyOutUnfoldAllButton);
unfoldAllWeightsBelowListOfControlPoints_hasBeenClicked = GUI.Button(rect_ofUnfoldAllButton, "Unfold all weights", style_ofUnfoldAllButtons);
UnityEditor.EditorGUI.EndDisabledGroup();
Color color_ofCollapseAllButton = greyOutCollapseAllButton ? color_ofAGreyedOut_foldAllButton : backgroundColor;
UnityEditor.EditorGUI.DrawRect(rect_ofCollapseAllButton, color_ofCollapseAllButton);
UnityEditor.EditorGUI.BeginDisabledGroup(greyOutCollapseAllButton);
collapseAllWeightsBelowListOfControlPoints_hasBeenClicked = GUI.Button(rect_ofCollapseAllButton, "Collapse all weights", style_ofUnfoldAllButtons);
UnityEditor.EditorGUI.EndDisabledGroup();
#else
plusButtonBelowListOfControlPoints_hasBeenClicked = false;
unfoldAllWeightsBelowListOfControlPoints_hasBeenClicked = false;
collapseAllWeightsBelowListOfControlPoints_hasBeenClicked = false;
#endif
}
public static float GetPropertyHeightForEmptyControlPointHoldingOnlyAPlusButtonAndFoldAllButtons()
{
return (Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox() + Get_inspectorVertSpace_ofEmptyLineOfEmptyControlPointHoldingOnlyAPlusButton() + Get_inspectorVertSpace_ofMinusButtonOnEachControlPoint() + Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox() + Get_additionalInspectorVertSpace_belowEmptyPlusLine_tillFoldAllButtons() + Get_inspectorVertSpace_forFoldAllButtons() + Get_emptyInspectorVertSpace_belowFoldAllButtons());
}
static float Get_xPos_ofBackgroundRect(Rect inspectorRect_reservedForThisTriplet)
{
return (inspectorRect_reservedForThisTriplet.x + Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox());
}
static float Get_yPos_ofBackgroundRect(Rect inspectorRect_reservedForThisTriplet)
{
return (inspectorRect_reservedForThisTriplet.y + Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox());
}
static float Get_width_ofBackgroundRect(Rect inspectorRect_reservedForThisTriplet)
{
return (inspectorRect_reservedForThisTriplet.width - 2.0f * Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox());
}
static float Get_xPos_ofPlusAndMinusButtonRect(Rect inspectorRect_reservedForThisTriplet)
{
//-> similar problem as described in "DrawBackgroundArea()", where the yPos is shifted by 1 pixel.
//-> in this case the x-position is shifted by 1 pixel to the left.
float offsetForFixingTheOnePixelOffset = 1.0f; //-> fixing it manually (with the risk of introducing a horizontal one pixel offset if there are situations where the problem doesn't occur)
return (inspectorRect_reservedForThisTriplet.x + inspectorRect_reservedForThisTriplet.width - Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox() - Get_width_ofPlusAndMinusButtons() + offsetForFixingTheOnePixelOffset);
}
static float Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge()
{
#if UNITY_EDITOR
return (0.2f * UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
static float Get_inspectorVertSpace_from_mainRect_to_backgroundColorBox()
{
#if UNITY_EDITOR
return (0.2f * UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
static float Get_inspectorVertSpace_betweenSubPoints()
{
#if UNITY_EDITOR
return (2.0f * Get_inspectorSpace_fromOutsideColorBoxEdge_toInsideColorBoxEdge());
#else
return 16.0f; //-> not used
#endif
}
static float Get_inspectorVertSpace_ofMinusButtonOnEachControlPoint()
{
#if UNITY_EDITOR
return (UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
static float Get_inspectorVertSpace_ofEmptyLineOfEmptyControlPointHoldingOnlyAPlusButton()
{
#if UNITY_EDITOR
return (UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
static float Get_additionalInspectorVertSpace_belowEmptyPlusLine_tillFoldAllButtons()
{
#if UNITY_EDITOR
return (0.5f * UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
static float Get_inspectorVertSpace_forFoldAllButtons()
{
#if UNITY_EDITOR
return (UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
static float Get_emptyInspectorVertSpace_belowFoldAllButtons()
{
#if UNITY_EDITOR
return (0.0f * UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
static float Get_width_ofPlusAndMinusButtons()
{
#if UNITY_EDITOR
return (1.5f * UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
static float Get_inspectorHorizSpace_from_mainRect_to_backgroundColorBox()
{
#if UNITY_EDITOR
return (0.2f * UnityEditor.EditorGUIUtility.singleLineHeight);
#else
return 16.0f; //-> not used
#endif
}
}
}