//-------------------------------------------------------------------------
public static void CalculateUnreducedOutlineForAllColliderRegions(ref ColliderRegionData[] colliderRegions, ref PolygonOutlineFromImageFrontend outlineAlgorithm,
RegionIndependentParameters regionIndependentParameters,
ColliderRegionParameters[] colliderRegionParameters, bool [,] binaryImage,
bool ccwVertexOrder) {
for (int count = 0; count < colliderRegions.Length; ++count) {
if (colliderRegionParameters[count].EnableRegion) {
// Calculate polygon bounds
outlineAlgorithm.VertexReductionDistanceTolerance = regionIndependentParameters.VertexReductionDistanceTolerance;
outlineAlgorithm.MaxPointCount = colliderRegionParameters[count].MaxPointCount;
bool allRegionsConvex = regionIndependentParameters.Convex;
outlineAlgorithm.Convex = allRegionsConvex ? true : colliderRegionParameters[count].Convex;
//outlineAlgorithm.Convex = colliderRegionParameters[count].Convex;
outlineAlgorithm.XOffsetNormalized = -0.5f;//-this.transform.localScale.x / 2.0f;
outlineAlgorithm.YOffsetNormalized = -0.5f;//-this.transform.localScale.y / 2.0f;
bool outputInNormalizedSpace = true;
bool regionVertexOrder = ccwVertexOrder;
if (!colliderRegions[count].mRegionIsIsland) {
regionVertexOrder = !regionVertexOrder;
}
colliderRegions[count].mOutlineVertexOrderIsCCW = regionVertexOrder;
outlineAlgorithm.UnreducedOutlineFromBinaryImage(out colliderRegions[count].mIntermediateOutlineVertices, binaryImage, colliderRegions[count].mDetectedRegion.mPointAtBorder, colliderRegions[count].mRegionIsIsland, outputInNormalizedSpace, regionVertexOrder);
}
else {
colliderRegions[count].mIntermediateOutlineVertices = null;
colliderRegions[count].mResultVertices = null;
colliderRegions[count].mResultTriangleIndices = null;
}
}
}
//-------------------------------------------------------------------------
public static void SetupColliderRegionParameters(ref ColliderRegionParameters[] colliderRegionParameters, int defaultMaxPointCount,
IslandDetector.Region[] islands, IslandDetector.Region[] seaRegions) {
int numColliderRegions = islands.Length + seaRegions.Length;
bool shallResetRegionParameters = (colliderRegionParameters == null || numColliderRegions != colliderRegionParameters.Length); // TODO!! check when to throw parameters away!
if (shallResetRegionParameters) {
colliderRegionParameters = new ColliderRegionParameters[numColliderRegions];
int colliderRegionIndex = 0;
// Note: We enable the first island region only. All other island- and all sea-regions are initially disabled.
for (int islandIndex = 0; islandIndex < islands.Length; ++islandIndex) {
ColliderRegionParameters newParameters = new ColliderRegionParameters();
if (islandIndex == 0) {
newParameters.EnableRegion = true;
}
else {
newParameters.EnableRegion = false;
}
newParameters.MaxPointCount = defaultMaxPointCount;
colliderRegionParameters[colliderRegionIndex++] = newParameters;
}
for (int seaRegionIndex = 0; seaRegionIndex < seaRegions.Length; ++seaRegionIndex) {
ColliderRegionParameters newParameters = new ColliderRegionParameters();
newParameters.EnableRegion = false;
newParameters.MaxPointCount = defaultMaxPointCount;
colliderRegionParameters[colliderRegionIndex++] = newParameters;
}
}
else {
for (int count = 0; count < colliderRegionParameters.Length; ++count) {
colliderRegionParameters[count].RegionUpdateCalculationNeeded = true;
}
}
}
//-------------------------------------------------------------------------
// Compatibility glue-code: to read the old mMaxPointCount value and sets the first island's newParameters.MaxPointCount value.
public static void CopyOldPointCountParameterToFirstIslandForBackwardsCompatibility(ref ColliderRegionParameters[] colliderRegionParameters,
ref int deprecatedOldPointCountParameter) {
if (deprecatedOldPointCountParameter != PARAMETER_NOT_USED_ANYMORE) {
colliderRegionParameters[0].MaxPointCount = deprecatedOldPointCountParameter;
deprecatedOldPointCountParameter = PARAMETER_NOT_USED_ANYMORE;
}
}
//-------------------------------------------------------------------------
public static void SetupColliderRegionParameters(ref ColliderRegionParameters[] islandRegionParameters, ref ColliderRegionParameters[] seaRegionParameters,
int defaultMaxPointCount,
IslandDetector.Region[] islands, IslandDetector.Region[] seaRegions) {
// Islands
int oldIslandRegionParametersLength = 0;
if (islandRegionParameters == null) {
islandRegionParameters = new ColliderRegionParameters[islands.Length];
}
else {
oldIslandRegionParametersLength = islandRegionParameters.Length;
if (islands.Length > oldIslandRegionParametersLength) {
System.Array.Resize(ref islandRegionParameters, islands.Length);
}
}
// set RegionUpdateCalculationNeeded at old entries
for (int existingIndex = 0; existingIndex < oldIslandRegionParametersLength; ++existingIndex) {
islandRegionParameters[existingIndex].RegionUpdateCalculationNeeded = true;
}
// add new ColliderRegionParameters at new ones
for (int newIndex = oldIslandRegionParametersLength; newIndex < islands.Length; ++newIndex) {
// Note: We enable the first island region only. All other island- and all sea-regions are initially disabled.
ColliderRegionParameters newParameters = new ColliderRegionParameters();
if (newIndex == 0) {
newParameters.EnableRegion = true;
}
else {
newParameters.EnableRegion = false;
}
newParameters.MaxPointCount = defaultMaxPointCount;
islandRegionParameters[newIndex] = newParameters;
}
// Sea regions
int oldSeaRegionParametersLength = 0;
if (seaRegionParameters == null) {
seaRegionParameters = new ColliderRegionParameters[seaRegions.Length];
}
else {
oldSeaRegionParametersLength = seaRegionParameters.Length;
if (seaRegions.Length > oldSeaRegionParametersLength) {
System.Array.Resize(ref seaRegionParameters, seaRegions.Length);
}
}
// set RegionUpdateCalculationNeeded at old entries
for (int existingIndex = 0; existingIndex < oldSeaRegionParametersLength; ++existingIndex) {
seaRegionParameters[existingIndex].RegionUpdateCalculationNeeded = true;
}
// add new ColliderRegionParameters at new ones
for (int seaRegionIndex = oldSeaRegionParametersLength; seaRegionIndex < seaRegions.Length; ++seaRegionIndex) {
ColliderRegionParameters newParameters = new ColliderRegionParameters();
newParameters.EnableRegion = false;
newParameters.MaxPointCount = defaultMaxPointCount;
seaRegionParameters[seaRegionIndex] = newParameters;
}
}
