//-------------------------------------------------------------------------
public void ReloadOrRecalculateSingleCollider(AlphaMeshCollider target)
{
if (!target.CanReloadCollider)
{
return;
}
string colliderMeshPath = target.FullColliderMeshPath();
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null || !IsColliderGroupValid(colliderGroup))
{
if (!target.CanRecalculateCollider)
{
return;
}
target.RecalculateCollider();
UpdateSimilarCollidersAndGroupToTarget(target);
}
else
{
AssignValuesFromColliderGroup(target, colliderGroup);
}
}
//-------------------------------------------------------------------------
protected void EnsureColliderGroupIsValid(ColliderGroup colliderGroup)
{
if (IsColliderGroupValid(colliderGroup))
{
return;
}
string colliderMeshPath = colliderGroup.mFullColliderMeshPath;
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
colliderGroup.mAlphaMeshColliderObjects = new List <WeakReference>();
AlphaMeshCollider target = null;
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FullColliderMeshPath().Equals(colliderMeshPath))
{
target = collider;
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
}
}
if (target != null)
{
AssignValuesFromInstanceToGroup(target, colliderGroup);
}
}
//-------------------------------------------------------------------------
protected void SelectAllInstances(AlphaMeshColliderRegistry registry)
{
int numInstances = 0;
foreach (AlphaMeshColliderRegistry.ColliderGroup colliderGroup in registry.mColliderGroups)
{
if (colliderGroup.mAlphaMeshColliderObjects != null)
{
numInstances += colliderGroup.mAlphaMeshColliderObjects.Count;
}
}
GameObject[] newSelection = new GameObject[numInstances];
int selectionIndex = 0;
foreach (AlphaMeshColliderRegistry.ColliderGroup colliderGroup in registry.mColliderGroups)
{
if (colliderGroup.mAlphaMeshColliderObjects != null)
{
foreach (System.WeakReference colliderInstanceRef in colliderGroup.mAlphaMeshColliderObjects)
{
AlphaMeshCollider instance = (AlphaMeshCollider)colliderInstanceRef.Target;
newSelection[selectionIndex++] = instance.gameObject;
}
}
}
Selection.objects = newSelection;
}
//-------------------------------------------------------------------------
protected void UpdateSimilarCollidersAndGroupToTarget(AlphaMeshCollider target)
{
string colliderMeshPath = target.FullColliderMeshPath();
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null)
{
// add new group.
colliderGroup = new ColliderGroup();
colliderGroup.mFullColliderMeshPath = colliderMeshPath;
mColliderGroups.Add(colliderGroup);
}
AssignValuesFromInstanceToGroup(target, colliderGroup);
colliderGroup.mAlphaMeshColliderObjects = new List <WeakReference>();
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FullColliderMeshPath().Equals(colliderMeshPath))
{
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
// reassign previously calculated values.
AssignValuesFromColliderGroup(collider, colliderGroup);
}
}
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
target.ColliderMesh = colliderGroup.mColliderMesh; // sets the sharedMesh to null first, so no need to set it here.
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.ColliderRegionParams = colliderGroup.mColliderRegionParameters;
target.ColliderRegions = colliderGroup.mColliderRegions;
target.OutlineAlgorithm = colliderGroup.mOutlineAlgorithm;
}
//-------------------------------------------------------------------------
protected void AssignValuesFromInstanceToGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
colliderGroup.mColliderMesh = target.ColliderMesh;
colliderGroup.mRegionIndependentParameters = target.RegionIndependentParams;
colliderGroup.mColliderRegionParameters = target.ColliderRegionParams;
colliderGroup.mColliderRegions = target.ColliderRegions;
colliderGroup.mOutlineAlgorithm = target.OutlineAlgorithm;
}
//-------------------------------------------------------------------------
protected void AssignValuesFromInstanceToGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
colliderGroup.mRegionIndependentParameters = target.RegionIndependentParams;
colliderGroup.mIslandRegionParameters = target.IslandRegionParams;
colliderGroup.mSeaRegionParameters = target.SeaRegionParams;
colliderGroup.mGeneratedColliderData = target.GeneratedColliderData;
colliderGroup.mColliderMeshes = target.ColliderMeshes;
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
target.ColliderMesh = colliderGroup.mColliderMesh; // sets the sharedMesh to null first, so no need to set it here.
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.ColliderRegionParams = colliderGroup.mColliderRegionParameters;
target.ColliderRegions = colliderGroup.mColliderRegions;
target.OutlineAlgorithm = colliderGroup.mOutlineAlgorithm;
}
//-------------------------------------------------------------------------
public bool SetupBinaryImageAndIslands(out int numColliderRegions, out object spriteCollectionDefinition, object spriteCollection, int spriteID)
{
numColliderRegions = 0;
spriteCollectionDefinition = null;
mMainTex = GetTextureRef(spriteCollection, spriteID);
if (mMainTex == null)
{
//Debug.LogError("No sprite texture found at sprite '" + tk2dSpriteComponent.name + "' with spriteID " + spriteID + ".");
Debug.LogError("No sprite texture found at sprite with spriteID " + spriteID + ".");
return(false);
}
spriteCollectionDefinition = GetTK2DSpriteCollectionDefinition(spriteCollection, spriteID);
if (spriteCollectionDefinition == null)
{
// last error is already set in GetTK2DSpriteCollectionDefinition() above.
return(false);
}
if (mOutlineAlgorithm == null)
{
mOutlineAlgorithm = new PolygonOutlineFromImageFrontend();
}
int regionXOffset = 0;
int regionYOffset = 0;
int regionWidth = UsedTexture.width;
int regionHeight = UsedTexture.height;
bool isRegionUsed = false;
if (mRegionIndependentParameters.CustomTex == null)
{
isRegionUsed = ReadRegionParameters(out regionXOffset, out regionYOffset, out regionWidth, out regionHeight, spriteCollectionDefinition);
regionYOffset = mMainTex.height - regionYOffset - regionHeight;
}
mOutlineAlgorithm.BinaryAlphaThresholdImageFromTexture(ref mBinaryImage, out mBinaryImageWidth, out mBinaryImageHeight, UsedTexture, mRegionIndependentParameters.AlphaOpaqueThreshold,
isRegionUsed, regionXOffset, regionYOffset, regionWidth, regionHeight);
int imageSize = mBinaryImageWidth * mBinaryImageHeight;
if (mClassificationImage == null || mClassificationImage.Length < imageSize)
{
mClassificationImage = new int[imageSize];
}
bool anyIslandsFound = CalculateIslandStartingPoints(mBinaryImage, mBinaryImageWidth, mBinaryImageHeight, ref mClassificationImage, ref mIslands, ref mSeaRegions);
if (!anyIslandsFound)
{
return(false);
}
AlphaMeshCollider.SetupColliderRegions(out mColliderRegions, mIslands, mSeaRegions);
numColliderRegions = mColliderRegions.Length;
SetupColliderRegionParameters(ref mColliderRegionParameters, mRegionIndependentParameters.DefaultMaxPointCount, mIslands, mSeaRegions);
return(true);
}
//-------------------------------------------------------------------------
public void RecalculateColliderAndUpdateSimilar(AlphaMeshCollider target)
{
if (!target.CanRecalculateCollider)
return;
target.RecalculateCollider();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
public void RewriteColliderToFileAndUpdateSimilar(AlphaMeshCollider target)
{
if (target.CanRewriteCollider)
{
target.RewriteColliderToFile();
}
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
static void AddAlphaMeshColliderToOTTilesSprite(Transform tilesSpriteNode, Component otTilesSprite)
{
AlphaMeshCollider alphaMeshColliderComponent = tilesSpriteNode.GetComponent <AlphaMeshCollider>();
if (alphaMeshColliderComponent == null)
{
alphaMeshColliderComponent = UndoAware.AddComponent <AlphaMeshCollider>(tilesSpriteNode.gameObject);
alphaMeshColliderComponent.SetOTTilesSprite(otTilesSprite);
}
}
//-------------------------------------------------------------------------
public void RecalculateColliderFromPreviousResultAndUpdateSimilar(AlphaMeshCollider target)
{
if (!target.CanRecalculateCollider)
{
return;
}
target.RecalculateColliderFromPreviousResult();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
public bool AssignValuesFromColliderGroup(AlphaMeshCollider target, string fullMeshPath)
{
ColliderGroup colliderGroup = this.FindColliderGroup(fullMeshPath);
if (colliderGroup == null) {
return false;
}
else {
AssignValuesFromColliderGroup(target, colliderGroup);
return true;
}
}
//-------------------------------------------------------------------------
public void RecalculateAllFramesAtColliderAndUpdateSimilar(AlphaMeshCollider target)
{
if (!target.CanRecalculateCollider)
{
return;
}
target.RecalculateAllColliderFrames();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.IslandRegionParams = colliderGroup.mIslandRegionParameters;
target.SeaRegionParams = colliderGroup.mSeaRegionParameters;
target.GeneratedColliderData = colliderGroup.mGeneratedColliderData;
target.CorrectColliderTypeToParameters();
target.ColliderMeshes = colliderGroup.mColliderMeshes; // sets the sharedMesh to null first, so no need to set it here.
#if UNITY_4_3_AND_LATER
target.ReassignCollidersIfNeeded();
#endif
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup)
{
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.ColliderRegionParams = colliderGroup.mColliderRegionParameters;
target.ColliderRegions = colliderGroup.mColliderRegions;
target.OutlineAlgorithm = colliderGroup.mOutlineAlgorithm;
target.CorrectColliderTypeToParameters();
target.ColliderMesh = colliderGroup.mColliderMesh; // sets the sharedMesh to null first, so no need to set it here.
#if UNITY_4_3_AND_LATER
target.ReassignPolygonCollider2DDataIfNeeded();
#endif
}
//-------------------------------------------------------------------------
static void AddAlphaMeshCollidersOfTreeToList(Transform node, ref List <GameObject> resultList)
{
AlphaMeshCollider alphaCollider = node.GetComponent <AlphaMeshCollider>();
if (alphaCollider != null)
{
resultList.Add(node.gameObject);
}
foreach (Transform child in node)
{
AddAlphaMeshCollidersOfTreeToList(child, ref resultList);
}
}
//-------------------------------------------------------------------------
public bool AssignValuesFromColliderGroup(AlphaMeshCollider target, string fullMeshPath)
{
ColliderGroup colliderGroup = this.FindColliderGroup(fullMeshPath);
if (colliderGroup == null)
{
return(false);
}
else
{
AssignValuesFromColliderGroup(target, colliderGroup);
return(true);
}
}
static void AddCollidersToBoneAnimationTree(Transform node)
{
foreach (Transform child in node)
{
if (!child.name.EndsWith("_Sprite"))
{
AlphaMeshCollider collider = child.GetComponent <AlphaMeshCollider>();
if (collider == null)
{
collider = UndoAware.AddComponent <AlphaMeshCollider>(child.gameObject);
}
}
AddCollidersToBoneAnimationTree(child);
}
}
//-------------------------------------------------------------------------
public void ReloadOrRecalculateColliderAndUpdateSimilar(AlphaMeshCollider target)
{
if (!target.CanRecalculateCollider)
{
return;
}
string colliderMeshPath = target.FirstFrameFullColliderMeshPath();
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null || !IsColliderGroupValid(colliderGroup))
{
target.RecalculateCollider();
UpdateSimilarCollidersAndGroupToTarget(target);
}
else
{
UpdateSimilarCollidersToGroup(colliderGroup);
}
}
//-------------------------------------------------------------------------
protected void AddChildColliderDataRecursively(Transform node, string nodePath, ref List <AlphaMeshCollider> collidersList, ref List <RestoreData> dataList, ref List <string> pathsList, ref List <bool> isScaleAnimNodeList)
{
foreach (Transform child in node)
{
string childNodePath = (nodePath.Length == 0) ? child.name : nodePath + "/" + child.name;
AlphaMeshCollider alphaMeshColliderComponent = child.GetComponent <AlphaMeshCollider>();
if (alphaMeshColliderComponent != null)
{
MeshCollider meshCollider = alphaMeshColliderComponent.TargetNodeToAttachMeshCollider.gameObject.GetComponent <MeshCollider>();
if (meshCollider != null)
{
string meshNodePath = childNodePath;
bool isScaleAnimNode = alphaMeshColliderComponent.ApplySmoothMovesScaleAnim;
if (isScaleAnimNode)
{
meshNodePath += "/" + alphaMeshColliderComponent.TargetNodeNameToAttachMeshCollider;
}
collidersList.Add(alphaMeshColliderComponent);
RestoreData data = new RestoreData();
data.mColliderMesh = meshCollider.sharedMesh;
data.mIsTrigger = meshCollider.isTrigger;
data.mConvex = meshCollider.convex;
data.mSharedMaterial = meshCollider.sharedMaterial;
data.mSmoothSphereCollisions = meshCollider.smoothSphereCollisions;
dataList.Add(data);
pathsList.Add(meshNodePath);
isScaleAnimNodeList.Add(isScaleAnimNode);
}
}
AddChildColliderDataRecursively(child, childNodePath, ref collidersList, ref dataList, ref pathsList, ref isScaleAnimNodeList);
}
}
//-------------------------------------------------------------------------
protected void AssignValuesFromInstanceToGroup(AlphaMeshCollider target, ColliderGroup colliderGroup) {
colliderGroup.mRegionIndependentParameters = target.RegionIndependentParams;
colliderGroup.mIslandRegionParameters = target.IslandRegionParams;
colliderGroup.mSeaRegionParameters = target.SeaRegionParams;
colliderGroup.mGeneratedColliderData = target.GeneratedColliderData;
colliderGroup.mColliderMeshes = target.ColliderMeshes;
}
//-------------------------------------------------------------------------
public void ReloadOrRecalculateSingleCollider(AlphaMeshCollider target) {
if (!target.CanReloadCollider)
return;
string colliderMeshPath = target.FirstFrameFullColliderMeshPath();
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null || !IsColliderGroupValid(colliderGroup)) {
if (!target.CanRecalculateCollider)
return;
target.RecalculateCollider();
UpdateSimilarCollidersAndGroupToTarget(target);
}
else {
AssignValuesFromColliderGroup(target, colliderGroup);
}
}
//-------------------------------------------------------------------------
protected void UpdateSimilarCollidersAndGroupToTarget(AlphaMeshCollider target) {
string colliderMeshPath = target.FirstFrameFullColliderMeshPath();
#if UNITY_4_AND_LATER
object[] alphaMeshColliders = GameObject.FindObjectsOfType(typeof(AlphaMeshCollider));
#else
object[] alphaMeshColliders = GameObject.FindSceneObjectsOfType(typeof(AlphaMeshCollider));
#endif
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null) {
// add new group.
colliderGroup = new ColliderGroup();
colliderGroup.mFullColliderMeshPath = colliderMeshPath;
mColliderGroups.Add(colliderGroup);
}
AssignValuesFromInstanceToGroup(target, colliderGroup);
colliderGroup.mAlphaMeshColliderObjects = new List<WeakReference>();
foreach (AlphaMeshCollider collider in alphaMeshColliders)
{
if (collider.FirstFrameFullColliderMeshPath().Equals(colliderMeshPath)) {
colliderGroup.mAlphaMeshColliderObjects.Add(new WeakReference(collider));
if (collider == target) {
continue;
}
else {
// reassign previously calculated values.
AssignValuesFromColliderGroup(collider, colliderGroup);
}
}
}
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup) {
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.ColliderRegionParams = colliderGroup.mColliderRegionParameters;
target.ColliderRegions = colliderGroup.mColliderRegions;
target.OutlineAlgorithm = colliderGroup.mOutlineAlgorithm;
target.CorrectColliderTypeToParameters();
target.ColliderMesh = colliderGroup.mColliderMesh; // sets the sharedMesh to null first, so no need to set it here.
#if UNITY_4_3_AND_LATER
target.ReassignPolygonCollider2DDataIfNeeded();
#endif
}
//-------------------------------------------------------------------------
public void RewriteAndReloadAllFramesAndUpdateSimilar(AlphaMeshCollider target) {
target.RewriteAndReloadAllColliderFrames();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
static public GameObject CreateColliderPrefabForOTContainerFrame(AlphaMeshCollider referenceParameters, out int tileIndex, out Vector2 resultFrameSize, Transform parentNode, object otContainerFrame, Texture2D texture) {
tileIndex = 0;
resultFrameSize = Vector2.one;
Type containerFrameType = otContainerFrame.GetType();
// tileIndex = frame.index
FieldInfo fieldIndex = containerFrameType.GetField("index");
if (fieldIndex == null) {
Debug.LogError("Detected a missing 'index' member variable at an OTContainer.Frame object - Is your Orthello package up to date? 2D ColliderGen might probably not work correctly with this version.");
return null;
}
tileIndex = (int) fieldIndex.GetValue(otContainerFrame);
// string nameString = frame.name
FieldInfo fieldName = containerFrameType.GetField("name");
if (fieldName == null) {
Debug.LogError("Detected a missing 'name' member variable at an OTContainer.Frame object - Is your Orthello package up to date? 2D ColliderGen might probably not work correctly with this version.");
return null;
}
string name = (string) fieldName.GetValue(otContainerFrame);
// float rotation = frame.rotation
FieldInfo fieldRotation = containerFrameType.GetField("rotation");
float rotation = 0;
if (fieldRotation == null) {
Debug.LogWarning("Detected a missing 'rotation' member variable at an OTContainer.Frame object - Is your Orthello package up to date? 2D ColliderGen might probably not work correctly with this version.");
}
else {
rotation = (float) fieldRotation.GetValue(otContainerFrame);
}
// Vector2[] uvCoords = frame.uv
FieldInfo fieldUV = containerFrameType.GetField("uv");
if (fieldUV == null) {
Debug.LogError("Detected a missing 'uv' member variable at an OTContainer.Frame object - Is your Orthello package up to date? 2D ColliderGen might probably not work correctly with this version.");
return null;
}
Vector2[] uvCoords = (Vector2[]) fieldUV.GetValue(otContainerFrame);
Vector2 framePosition;
GetSizeAndPositionFromOrthelloUVCoords(out framePosition, out resultFrameSize, uvCoords, texture.width, texture.height);
GameObject colliderObject = CreateAlphaMeshColliderGameObject(parentNode, PREFAB_GAMEOBJECT_NAME_PREFIX + name, name, texture, framePosition, resultFrameSize, rotation);
AlphaMeshCollider alphaMeshColliderComponent = colliderObject.GetComponent<AlphaMeshCollider>();
if (referenceParameters) {
alphaMeshColliderComponent.mRegionIndependentParameters.AlphaOpaqueThreshold = referenceParameters.mRegionIndependentParameters.AlphaOpaqueThreshold;
alphaMeshColliderComponent.mRegionIndependentParameters.DefaultMaxPointCount = referenceParameters.mRegionIndependentParameters.DefaultMaxPointCount;
alphaMeshColliderComponent.mRegionIndependentParameters.Thickness = referenceParameters.mRegionIndependentParameters.Thickness;
alphaMeshColliderComponent.mRegionIndependentParameters.FlipHorizontal = referenceParameters.mRegionIndependentParameters.FlipHorizontal;
alphaMeshColliderComponent.mRegionIndependentParameters.FlipVertical = referenceParameters.mRegionIndependentParameters.FlipVertical;
alphaMeshColliderComponent.mRegionIndependentParameters.Convex = referenceParameters.mRegionIndependentParameters.Convex;
alphaMeshColliderComponent.mRegionIndependentParameters.FlipInsideOutside = referenceParameters.mRegionIndependentParameters.FlipInsideOutside;
alphaMeshColliderComponent.mColliderMeshDirectory = referenceParameters.mColliderMeshDirectory;
alphaMeshColliderComponent.mGroupSuffix = referenceParameters.mGroupSuffix;
alphaMeshColliderComponent.mRegionIndependentParameters.CustomRotation = referenceParameters.mRegionIndependentParameters.CustomRotation;
alphaMeshColliderComponent.mRegionIndependentParameters.CustomScale = referenceParameters.mRegionIndependentParameters.CustomScale;
alphaMeshColliderComponent.mRegionIndependentParameters.CustomOffset = referenceParameters.mRegionIndependentParameters.CustomOffset;
alphaMeshColliderComponent.mWasInitialized = true;
}
else {
Debug.Log("NULL reference params??"); // debug, remove!
}
alphaMeshColliderComponent.UpdateAlphaMeshCollider();
#if UNITY_4_AND_LATER
colliderObject.SetActive(true);
#else
colliderObject.active = false;
#endif
return colliderObject;
}
//-------------------------------------------------------------------------
static void addColliderGameObjectsForOTTileMapLayer(Transform layerNode, Component otTileMap, object otTileMapLayer, int layerIndex)
{
// read tileMapSize = OTTileMap.mapSize (UnityEngine.Vector2)
System.Type otTileMapType = otTileMap.GetType();
FieldInfo fieldMapSize = otTileMapType.GetField("mapSize");
if (fieldMapSize == null)
{
Debug.LogError("Detected a missing 'mapSize' member variable at OTTileMap component - Is your Orthello package up to date? 2D ColliderGen might probably not work correctly with this version.");
return;
}
Vector2 tileMapSize = (UnityEngine.Vector2)fieldMapSize.GetValue(otTileMap);
int tileMapWidth = (int)tileMapSize.x;
int tileMapHeight = (int)tileMapSize.y;
// read mapTileSize = OTTileMap.mapTileSize (UnityEngine.Vector2)
FieldInfo fieldMapTileSize = otTileMapType.GetField("mapTileSize");
if (fieldMapTileSize == null)
{
Debug.LogError("Detected a missing 'mapTileSize' member variable at OTTileMap component - Is your Orthello package up to date? 2D ColliderGen might probably not work correctly with this version.");
return;
}
Vector2 mapTileSize = (UnityEngine.Vector2)fieldMapTileSize.GetValue(otTileMap);
Vector3 mapTileScale = new Vector3(1.0f / tileMapSize.x, 1.0f / tileMapSize.y, 1.0f / tileMapSize.x);
System.Collections.Generic.Dictionary <int, object> tileSetAtTileIndex = new System.Collections.Generic.Dictionary <int, object>();
Vector2 bottomLeftTileOffset = new Vector2(-0.5f, -0.5f);
// read tileIndices = otTileMapLayer.tiles (int[])
System.Type otTileMapLayerType = otTileMapLayer.GetType();
FieldInfo fieldTiles = otTileMapLayerType.GetField("tiles");
if (fieldTiles == null)
{
Debug.LogError("Detected a missing 'tiles' member variable at OTTileMapLayer component - Is your Orthello package up to date? 2D ColliderGen might probably not work correctly with this version.");
return;
}
int[] tileIndices = (int[])fieldTiles.GetValue(otTileMapLayer);
System.Collections.Generic.Dictionary <int, Transform> groupNodeForTileIndex = new System.Collections.Generic.Dictionary <int, Transform>();
Transform tileGroupNode = null;
object tileSet = null;
for (int y = 0; y < tileMapHeight; ++y)
{
for (int x = 0; x < tileMapWidth; ++x)
{
int tileIndex = tileIndices[y * tileMapWidth + x];
if (tileIndex != 0)
{
if (groupNodeForTileIndex.ContainsKey(tileIndex))
{
tileGroupNode = groupNodeForTileIndex[tileIndex];
tileSet = tileSetAtTileIndex[tileIndex];
}
else
{
// create a group node
GameObject newTileGroup = UndoAware.CreateGameObject("Tile Type " + tileIndex);
newTileGroup.transform.parent = layerNode;
newTileGroup.transform.localPosition = Vector3.zero;
newTileGroup.transform.localScale = Vector3.one;
tileGroupNode = newTileGroup.transform;
groupNodeForTileIndex[tileIndex] = tileGroupNode;
// get tileset for tile index
tileSet = AlphaMeshCollider.GetOTTileSetForTileIndex(otTileMap, tileIndex);
tileSetAtTileIndex[tileIndex] = tileSet;
}
// read tileSet.tileSize (Vector2)
System.Type otTileSetType = tileSet.GetType();
FieldInfo fieldTileSize = otTileSetType.GetField("tileSize");
if (fieldTileSize == null)
{
Debug.LogError("Detected a missing 'tileSize' member variable at OTTileSet class - Is your Orthello package up to date? 2D ColliderGen might probably not work correctly with this version.");
return;
}
Vector2 tileSize = (UnityEngine.Vector2)fieldTileSize.GetValue(tileSet);
Vector3 tileScale = new Vector3(mapTileScale.x / mapTileSize.x * tileSize.x, mapTileScale.y / mapTileSize.y * tileSize.y, mapTileScale.z);
Vector2 tileCenterOffset = new Vector3(tileScale.x * 0.5f, tileScale.x * 0.5f);
// add a GameObject for each enabled tile with name "tile y x"
GameObject alphaMeshColliderNode = UndoAware.CreateGameObject("tile " + y + " " + x);
alphaMeshColliderNode.transform.parent = tileGroupNode;
AlphaMeshCollider alphaMeshColliderComponent = UndoAware.AddComponent <AlphaMeshCollider>(alphaMeshColliderNode);
alphaMeshColliderComponent.SetOTTileMap(otTileMap, layerIndex, x, y, tileMapWidth);
// set the position of the tile collider according to its (x,y) pos in the map.
alphaMeshColliderNode.transform.localPosition = new Vector3(x * mapTileScale.x + bottomLeftTileOffset.x + tileCenterOffset.x, (tileMapSize.y - 1 - y) * mapTileScale.y + bottomLeftTileOffset.y + tileCenterOffset.y, 0.0f);
alphaMeshColliderNode.transform.localScale = tileScale;
}
}
}
}
//-------------------------------------------------------------------------
public void AssignValuesFromColliderGroup(AlphaMeshCollider target, ColliderGroup colliderGroup) {
target.RegionIndependentParams = colliderGroup.mRegionIndependentParameters;
target.IslandRegionParams = colliderGroup.mIslandRegionParameters;
target.SeaRegionParams = colliderGroup.mSeaRegionParameters;
target.GeneratedColliderData = colliderGroup.mGeneratedColliderData;
target.CorrectColliderTypeToParameters();
target.ColliderMeshes = colliderGroup.mColliderMeshes; // sets the sharedMesh to null first, so no need to set it here.
#if UNITY_4_3_AND_LATER
target.ReassignCollidersIfNeeded();
#endif
}
//-------------------------------------------------------------------------
public override void OnInspectorGUI()
{
AlphaMeshColliderRegistry registry = (AlphaMeshColliderRegistry)target;
//EditorGUIUtility.LookLikeInspector();
EditorGUILayout.TextField("Collider Groups", registry.mColliderGroups.Count.ToString());
foreach (AlphaMeshColliderRegistry.ColliderGroup colliderGroup in registry.mColliderGroups)
{
EditorGUI.indentLevel = 0; // Indent 0
string path = colliderGroup.mFullColliderMeshPath;
int pointCount = 0;
if ((colliderGroup.FirstColliderMesh) &&
(colliderGroup.FirstColliderMesh.triangles != null) &&
(colliderGroup.FirstColliderMesh.triangles.Length > 0))
{
pointCount = colliderGroup.FirstColliderMesh.triangles.Length / 6;
}
else if (colliderGroup.mAlphaMeshColliderObjects != null && colliderGroup.mAlphaMeshColliderObjects.Count != 0)
{
AlphaMeshCollider firstInstance = (AlphaMeshCollider)colliderGroup.mAlphaMeshColliderObjects[0].Target;
pointCount = firstInstance.ColliderRegionsTotalMaxPointCount;
}
else if (colliderGroup.mGeneratedColliderData != null &&
colliderGroup.mGeneratedColliderData.Length > 0 &&
colliderGroup.mGeneratedColliderData[0].mOutlineAlgorithm != null)
{
pointCount = colliderGroup.mGeneratedColliderData[0].mOutlineAlgorithm.MaxPointCount;
}
bool showGroup = mShowGroupAtPath.ContainsKey(path) && mShowGroupAtPath[path];
string foldoutString = System.IO.Path.GetFileName(path);
if (pointCount != 0)
{
foldoutString += "\t [" + pointCount + " vertices]";
}
if (colliderGroup.mAlphaMeshColliderObjects != null)
{
foldoutString += "\t " + colliderGroup.mAlphaMeshColliderObjects.Count + "x";
}
mShowGroupAtPath[path] = EditorGUILayout.Foldout(showGroup, foldoutString);
if (mShowGroupAtPath[path])
{
EditorGUI.indentLevel = 1; // Indent 1
EditorGUILayout.TextField("Collider Mesh Path", path);
if (pointCount != 0)
{
EditorGUILayout.IntField("Outline Vertex Count", pointCount);
}
else
{
EditorGUILayout.TextField("Outline Vertex Count", "<not yet calculated>");
}
EditorGUILayout.ObjectField("Mesh", colliderGroup.FirstColliderMesh, typeof(Mesh), true);
if (colliderGroup.mAlphaMeshColliderObjects == null)
{
EditorGUILayout.LabelField("No Instances");
}
else
{
int index = 1;
foreach (System.WeakReference colliderInstanceRef in colliderGroup.mAlphaMeshColliderObjects)
{
AlphaMeshCollider instance = (AlphaMeshCollider)colliderInstanceRef.Target;
EditorGUILayout.ObjectField("Instance " + index++, instance, typeof(AlphaMeshCollider), true);
}
if (GUILayout.Button("Select Instances"))
{
GameObject[] newSelection = new GameObject[colliderGroup.mAlphaMeshColliderObjects.Count];
int selectionIndex = 0;
foreach (System.WeakReference colliderInstanceRef in colliderGroup.mAlphaMeshColliderObjects)
{
AlphaMeshCollider instance = (AlphaMeshCollider)colliderInstanceRef.Target;
newSelection[selectionIndex++] = instance.gameObject;
}
Selection.objects = newSelection;
}
}
}
}
if (GUILayout.Button("Select All Instances"))
{
SelectAllInstances(registry);
}
EditorGUI.indentLevel = 0;
//EditorGUIUtility.LookLikeControls();
}
//-------------------------------------------------------------------------
static GameObject GetTileColliderPrefabGroupNode(Component otTilesSprite)
{
string prefabGroupNodeName = AlphaMeshCollider.GetTileColliderPrefabGroupNodeName(otTilesSprite);
return(GameObject.Find(prefabGroupNodeName));
}
//-------------------------------------------------------------------------
static bool CreateAllTileColliderPrefabs(Component otTilesSprite, out List <GameObject> colliderPrefabAtTileIndex, out Vector2 atlasFrameSizeInPixels)
{
AlphaMeshCollider referenceParameterObject = otTilesSprite.GetComponent <AlphaMeshCollider>();
return(AlphaMeshCollider.CreateColliderPrefabsForAllOTContainerFrames(otTilesSprite, referenceParameterObject, out colliderPrefabAtTileIndex, out atlasFrameSizeInPixels));
}
//-------------------------------------------------------------------------
public void RewriteColliderToFileAndUpdateSimilar(AlphaMeshCollider target) {
if (target.CanRewriteCollider) {
target.RewriteColliderToFile();
}
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
public void ReloadOrRecalculateColliderAndUpdateSimilar(AlphaMeshCollider target) {
if (!target.CanRecalculateCollider)
return;
string colliderMeshPath = target.FullColliderMeshPath();
ColliderGroup colliderGroup = FindColliderGroup(colliderMeshPath);
if (colliderGroup == null || !IsColliderGroupValid(colliderGroup)) {
target.RecalculateCollider();
UpdateSimilarCollidersAndGroupToTarget(target);
}
else {
UpdateSimilarCollidersToGroup(colliderGroup);
}
}
//-------------------------------------------------------------------------
protected void AssignValuesFromInstanceToGroup(AlphaMeshCollider target, ColliderGroup colliderGroup) {
colliderGroup.mRegionIndependentParameters = target.RegionIndependentParams;
colliderGroup.mColliderRegionParameters = target.ColliderRegionParams;
colliderGroup.mColliderRegions = target.ColliderRegions;
colliderGroup.mOutlineAlgorithm = target.OutlineAlgorithm;
colliderGroup.mColliderMesh = target.ColliderMesh;
}
//-------------------------------------------------------------------------
public void ChangeSyncToParentSpriteRenderer(AlphaMeshCollider target, bool doSyncToParent)
{
target.ChangeSyncToParentSpriteRenderer(doSyncToParent);
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
public void RewriteAndReloadAllFramesAndUpdateSimilar(AlphaMeshCollider target)
{
target.RewriteAndReloadAllColliderFrames();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
public void RemoveActiveColliderFrame(AlphaMeshCollider target)
{
target.RemoveActiveColliderFrame();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
public void SetActiveFrameReferenceFrameIndex(AlphaMeshCollider target, int referenceFrameIndex)
{
target.SetActiveFrameReferenceFrameIndex(referenceFrameIndex);
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
static public bool CreateColliderPrefabsForAllOTContainerFrames(Component otSprite, AlphaMeshCollider referenceParameters, out List<GameObject> colliderPrefabAtTileIndex, out Vector2 atlasFrameSizeInPixels) {
colliderPrefabAtTileIndex = new List<GameObject>();
atlasFrameSizeInPixels = Vector2.one;
object otSpriteContainer;
Texture2D texture;
GetSpriteContainerAndTextureOfOTSprite(otSprite, out otSpriteContainer, out texture);
string groupNodeName = GetTileColliderPrefabGroupNodeName(texture.name);
// add a GameObject node to group the collider prefabs
GameObject collidersNode = new GameObject(groupNodeName);
collidersNode.transform.parent = null;
collidersNode.transform.localPosition = Vector3.zero;
collidersNode.transform.localScale = Vector3.one;
#if UNITY_4_AND_LATER
collidersNode.SetActive(true);
#else
collidersNode.active = true; // we need to keep this root-node active in order to find it via GameObject.Find().
#endif
// framesArray = otSpriteContainer.frames
Type containerType = otSpriteContainer.GetType();
FieldInfo fieldFrames = containerType.BaseType.GetField("frames", BindingFlags.NonPublic | BindingFlags.Instance);
if (fieldFrames == null) {
Debug.LogWarning("Failed to read frames field of the OTContainer component. Seems as if a different version of Orthello is used. If you need texture- or sprite-atlas support, please consider updating your Orthello framework.");
return false;
}
IEnumerable framesArray = (IEnumerable) fieldFrames.GetValue(otSpriteContainer);
bool areAllSuccessful = true;
Vector2 frameSize;
foreach (object frame in framesArray) {
int tileIndex;
GameObject colliderForFrame = CreateColliderPrefabForOTContainerFrame(referenceParameters, out tileIndex, out frameSize, collidersNode.transform, frame, texture);
if (colliderForFrame == null) {
areAllSuccessful = false;
}
else {
while (colliderPrefabAtTileIndex.Count < tileIndex + 1) {
colliderPrefabAtTileIndex.Add(null);
}
colliderPrefabAtTileIndex[tileIndex] = colliderForFrame;
atlasFrameSizeInPixels = frameSize;
}
}
return areAllSuccessful;
}
//-------------------------------------------------------------------------
public void IncreaseActiveFrameReferenceFrameIndex(AlphaMeshCollider target)
{
target.IncreaseActiveFrameReferenceFrameIndex();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
// Compatibility glue-code: read all old parameters and set the new RegionIndependentParameters pendants accordingly.
public static void CopyParametersToRegionIndependentParametersForBackwardsCompatibility(ref RegionIndependentParameters colliderParameters,
AlphaMeshCollider oldReference) {
colliderParameters.LiveUpdate = oldReference.mLiveUpdate;
colliderParameters.AlphaOpaqueThreshold = oldReference.mAlphaOpaqueThreshold;
colliderParameters.VertexReductionDistanceTolerance = oldReference.mVertexReductionDistanceTolerance;
colliderParameters.DefaultMaxPointCount = oldReference.mDefaultMaxPointCount;
colliderParameters.Thickness = oldReference.mThickness;
colliderParameters.FlipHorizontal = oldReference.mFlipHorizontal;
colliderParameters.FlipVertical = oldReference.mFlipVertical;
colliderParameters.Convex = oldReference.mConvex;
colliderParameters.FlipInsideOutside = oldReference.mFlipInsideOutside;
colliderParameters.CustomRotation = oldReference.mCustomRotation;
colliderParameters.CustomScale = oldReference.mCustomScale;
colliderParameters.CustomOffset = oldReference.mCustomOffset;
colliderParameters.CopyOTSpriteFlipping = oldReference.mCopyOTSpriteFlipping;
colliderParameters.CopySmoothMovesSpriteDimensions = oldReference.mCopySmoothMovesSpriteDimensions;
colliderParameters.CustomTex = oldReference.mCustomTex;
colliderParameters.IsCustomAtlasRegionUsed = oldReference.mIsCustomAtlasRegionUsed;
colliderParameters.CustomAtlasFrameTitle = oldReference.mCustomAtlasFrameTitle;
colliderParameters.CustomAtlasFramePositionInPixels = oldReference.mCustomAtlasFramePositionInPixels;
colliderParameters.CustomAtlasFrameSizeInPixels = oldReference.mCustomAtlasFrameSizeInPixels;
colliderParameters.CustomAtlasFrameRotation = oldReference.mCustomAtlasFrameRotation;
colliderParameters.ApplySmoothMovesScaleAnim = oldReference.mApplySmoothMovesScaleAnim;
oldReference.mCustomRotation = OLD_PARAMETERS_CONVERTED;
}
//-------------------------------------------------------------------------
public void AddActiveColliderFrameBackIn(AlphaMeshCollider target)
{
target.AddActiveColliderFrameBackIn();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
public void ReloadAllFramesAtColliderAndUpdateSimilar(AlphaMeshCollider target) {
if (!target.CanReloadCollider)
return;
target.ReloadAllColliderFrames();
UpdateSimilarCollidersAndGroupToTarget(target);
}
//-------------------------------------------------------------------------
protected void AddChildColliderDataRecursively(Transform node, string nodePath, ref List <AlphaMeshCollider> collidersList, ref List <RestoreData> dataList, ref List <string> pathsList, ref List <bool> isScaleAnimNodeList)
{
foreach (Transform child in node)
{
string childNodePath = (nodePath.Length == 0) ? child.name : nodePath + "/" + child.name;
AlphaMeshCollider alphaMeshColliderComponent = child.GetComponent <AlphaMeshCollider>();
if (alphaMeshColliderComponent != null)
{
string colliderNodePath = childNodePath;
bool isScaleAnimNode = alphaMeshColliderComponent.ApplySmoothMovesScaleAnim;
if (isScaleAnimNode)
{
colliderNodePath += "/" + alphaMeshColliderComponent.TargetNodeNameToAttachMeshCollider;
}
MeshCollider meshCollider = alphaMeshColliderComponent.TargetNodeToAttachMeshCollider.gameObject.GetComponent <MeshCollider>();
if (meshCollider != null)
{
collidersList.Add(alphaMeshColliderComponent);
RestoreData data = new RestoreData();
data.mColliderMesh = meshCollider.sharedMesh;
data.mIsTrigger = meshCollider.isTrigger;
data.mConvex = meshCollider.convex;
data.mSharedMaterial = meshCollider.sharedMaterial;
data.mSmoothSphereCollisions = meshCollider.smoothSphereCollisions;
dataList.Add(data);
pathsList.Add(colliderNodePath);
isScaleAnimNodeList.Add(isScaleAnimNode);
}
#if UNITY_4_3_AND_LATER
PolygonCollider2D polygonCollider = alphaMeshColliderComponent.TargetNodeToAttachMeshCollider.gameObject.GetComponent <PolygonCollider2D>();
if (polygonCollider != null)
{
collidersList.Add(alphaMeshColliderComponent);
RestoreData data = new RestoreData();
//int numPaths = polygonCollider.pathCount;
//data.mPolygonColliderPaths = new List<Vector2[]>(numPaths);
//for (int pathIndex = 0; pathIndex < numPaths; ++pathIndex) {
// data.mPolygonColliderPaths[pathIndex] = polygonCollider.GetPath(pathIndex);
//}
data.mPolygonColliderPathCount = polygonCollider.pathCount;
data.mPolygonColliderPoints = polygonCollider.points;
data.mIsTrigger = polygonCollider.isTrigger;
// data.mConvex = meshCollider.convex; // Note: polygon colliders have no convex flag.
data.mSharedMaterial2D = polygonCollider.sharedMaterial;
//data.mSmoothSphereCollisions = meshCollider.smoothSphereCollisions; // Note: polygon colliders have no smoothSphereCollisions flag.
dataList.Add(data);
pathsList.Add(colliderNodePath);
isScaleAnimNodeList.Add(isScaleAnimNode);
}
#endif
}
AddChildColliderDataRecursively(child, childNodePath, ref collidersList, ref dataList, ref pathsList, ref isScaleAnimNodeList);
}
}
