//------------------------------------------------------------------------- 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 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); } }
//------------------------------------------------------------------------- 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 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 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 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 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); } }