/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// AddNewWayPoint /// # Add a new part to car /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// void AddNewWayPoint(bool useHit, RaycastHit hit) { //Debug.Log ("Add new wayPoint"); GameObject wayPointsContainer = BasicFunctions.CreateContainerIfNotExists("_DECAL_WAYPOINTS"); GameObject newWayPoint = GameObject.CreatePrimitive(PrimitiveType.Capsule); newWayPoint.transform.parent = wayPointsContainer.transform; newWayPoint.transform.localScale = 0.2f * Vector3.one; newWayPoint.GetComponent <Renderer> ().sharedMaterial = new Material(newWayPoint.GetComponent <Renderer> ().sharedMaterial); newWayPoint.GetComponent <Renderer> ().sharedMaterial.color = Color.yellow; newWayPoint.AddComponent <WayPoint> (); newWayPoint.GetComponent <WayPoint> ().index = GetWayPointLogicalIndex(); newWayPoint.name = "Waypoint_" + newWayPoint.GetComponent <WayPoint> ().index; if (useHit) { newWayPoint.transform.position = hit.point; newWayPoint.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.normal); newWayPoint.GetComponent <WayPoint> ().hitNormal = hit.normal; } Selection.activeObject = newWayPoint; }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// CreateNewDecal /// # Create a new mesh decal in the scene /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// public GenericMeshDecal CreateNewMeshDecal(Material decalMaterial, Transform parent, Vector3 point, Vector3 normal, float scaleMultiplier, Vector2 rotationRange, bool attachDecalToCollisionObject) { //print ("CreateNewDecal"); GenericMeshDecal actualDecal = Instantiate(decalPrefab.gameObject).GetComponent <GenericMeshDecal> (); actualDecal.material = decalMaterial; actualDecal.transform.position = point + 0.001f * normal; actualDecal.transform.localScale = scaleMultiplier * actualDecal.transform.localScale; actualDecal.transform.rotation = Quaternion.FromToRotation(Vector3.up, normal); if (attachDecalToCollisionObject) { actualDecal.transform.parent = parent; } else { GameObject decalsContainer = BasicFunctions.CreateContainerIfNotExists(BasicDefines.MESH_DECAL_CONTAINER_NAME); actualDecal.transform.parent = decalsContainer.transform; } actualDecal.rotationRange = rotationRange; actualDecal.name = "RunTimeDecal"; actualDecal.UpdateDecallShape(true, false); return(actualDecal.GetComponent <GenericMeshDecal> ()); }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Merge /// # Merge mesh /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// public static void Merge(List <GameObject> gameObjectListOriginal, string mergedObjectName, bool deleteOldObjects) { List <Material> distinctMaterialList = GetMaterialListFromAGameObjectList(gameObjectListOriginal).Distinct().ToList(); List <GameObject> finalGameObjectList = new List <GameObject> (); //Debug.Log ("----------------------------------------------------"); for (int i = 0; i < distinctMaterialList.Count; i++) { //Debug.Log (i + " -> distinctMaterialList -> " + distinctMaterialList [i].name); List <GameObject> subGameObjectList = new List <GameObject> (); for (int j = 0; j < gameObjectListOriginal.Count; j++) { Material actualGameObjectMainMaterial = BasicFunctions.GetMainMaterial(gameObjectListOriginal [j].transform); if (!actualGameObjectMainMaterial) { //Debug.Log ("Null material: " + gameObjectListOriginal [j].name); } else { if (distinctMaterialList [i] == actualGameObjectMainMaterial) { //Debug.Log (j + " -> merge: " + gameObjectListOriginal [j].name); subGameObjectList.Add(gameObjectListOriginal [j]); } else { //Debug.Log (j + " -> not same material: " + actualGameObjectMainMaterial.name + " and distinct: " + distinctMaterialList [i]); } } } finalGameObjectList.Add(SubMerge(subGameObjectList, "sub_" + mergedObjectName, deleteOldObjects, true)); } SubMerge(finalGameObjectList, mergedObjectName, deleteOldObjects, false); // delete olds foreach (GameObject go in finalGameObjectList) { GameObject.DestroyImmediate(go); } if (deleteOldObjects) { foreach (GameObject go in gameObjectListOriginal) { GameObject.DestroyImmediate(go); } } }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Update /// # Update the class /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// void Update() { if (timerBetweenDistributions <= 0) { GameObject baseContainer = BasicFunctions.CreateContainerIfNotExists("_MEAT_PARTS"); timerBetweenDistributions = Random.Range(1, 2); int index = Random.Range(0, meatPrefabs.Count); GameObject clone = Instantiate(meatPrefabs [index]); clone.transform.position = this.transform.position; //clone.GetComponent<Rigidbody> ().velocity = (-4 + 4 * Random.Range (0, 1)) * Vector3.one; Vector3 objectScale = clone.transform.localScale; objectScale.x *= Random.Range(0.5f, 2); if (index == 0) { objectScale.y *= Random.Range(0.5f, 2); objectScale.z *= Random.Range(0.5f, 2); } else { objectScale.y = objectScale.x; objectScale.z = objectScale.x; } clone.transform.localScale = objectScale; clone.transform.Rotate(Random.Range(0, 360) * Vector3.one); clone.transform.parent = baseContainer.transform; if (!clone.GetComponent <NotStainableObject> ()) { clone.AddComponent <NotStainableObject> (); } actualCloneList.Add(clone); if (actualCloneList.Count > 24) { GameObject removable = actualCloneList [0]; actualCloneList.Remove(removable); Destroy(removable); } } timerBetweenDistributions -= Time.deltaTime; }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// BuildMesh /// # Creates decal's mesh and applys new texture coords /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// public void BuildMesh(GenericMeshDecal decal) { MeshFilter filter = decal.GetComponent <MeshFilter> (); if (filter == null) { filter = decal.gameObject.AddComponent <MeshFilter> (); } if (decal.GetComponent <Renderer> () == null) { decal.gameObject.AddComponent <MeshRenderer> (); } decal.GetComponent <Renderer> ().material = decal.material; if (decal.material == null || decal.sprite == null) { filter.mesh = null; return; } affectedObjects = BasicFunctions.GetAllAffectedObjects(BasicFunctions.GetTransformBounds(decal.transform), decal.affectedLayers); foreach (GameObject go in affectedObjects) { if (!go.GetComponent <WayPoint> () && !go.GetComponent <GenericMeshDecal> ()) { BasicFunctions.BuildDecalForObject(decal, go); } } BasicFunctions.Push(decal.distanceFromHit); Mesh mesh = null; if (planarDecal) { mesh = CreatePlanarMesh(1, 1); } else { mesh = BasicFunctions.CreateMesh(); //// ModifyPlanarMesh (ref mesh, 1, 1); } if (mesh != null) { mesh.name = "GenericPoly"; filter.mesh = mesh; } }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// ClipPoly /// # Return clip poly for actual poly /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// public static GenericPoly ClipPoly(GenericPoly actualPoly, Plane plane) { //Debug.Log ("ClipPoly"); bool[] positive = new bool[vertexNumber]; int positiveCount = 0; for (int i = 0; i < actualPoly.vertexList.Count; i++) { positive [i] = !plane.GetSide(actualPoly.vertexList [i]); if (positive [i]) { positiveCount++; } } if (positiveCount == 0) { return(null); } if (positiveCount == actualPoly.vertexList.Count) { return(actualPoly); } GenericPoly temporalPoly = new GenericPoly(); for (int i = 0; i < actualPoly.vertexList.Count; i++) { int next = i + 1; next %= actualPoly.vertexList.Count; if (positive [i]) { temporalPoly.vertexList.Add(actualPoly.vertexList [i]); } if (positive [i] != positive [next]) { Vector3 v1 = actualPoly.vertexList [next]; Vector3 v2 = actualPoly.vertexList [i]; Vector3 v = BasicFunctions.LineCast(plane, v1, v2); temporalPoly.vertexList.Add(v); } } return(temporalPoly); }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// LateUpdate /// # Update the rain /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// void LateUpdate() { List <Particle> particleList = GetComponent <ParticleEmitter> ().particles.ToList(); int[] livingParticleList = new int[particleList.Count]; int particlesToKeep = 0; for (var i = 0; i < GetComponent <ParticleEmitter>().particleCount; i++) { Particle actualParticle = particleList [i]; if (actualParticle.energy > energyLimit) { actualParticle.color = Color.yellow; particleList [i] = actualParticle; if (splashPrefab) { GameObject rainContainer = BasicFunctions.CreateContainerIfNotExists("_RAIN"); Transform actualSplash = Instantiate(splashPrefab, particleList [i].position, Quaternion.identity) as Transform; if (actualSplash) { actualSplash.parent = rainContainer.transform; } } } else { livingParticleList [particlesToKeep++] = i; } } Particle[] keepParticles = new Particle[particlesToKeep]; for (var j = 0; j < particlesToKeep; j++) { keepParticles [j] = particleList [livingParticleList [j]]; } GetComponent <ParticleEmitter> ().particles = keepParticles; }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// GetMaterialListFromAGameObjectList /// # Merge mesh /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// static List <Material> GetMaterialListFromAGameObjectList(List <GameObject> gameObjectList) { // get mesh fiters List <MeshFilter> meshFilters = new List <MeshFilter> (); for (int i = 0; i < gameObjectList.Count; i++) { meshFilters.Add(BasicFunctions.GetMeshFilterInChilds(gameObjectList [i].transform)); } // get material list List <Material> materials = new List <Material> (); foreach (MeshFilter mf in meshFilters) { MeshRenderer mr = mf.gameObject.GetComponent <MeshRenderer> (); materials.Add(mr.gameObject.GetComponent <Renderer> ().sharedMaterial); } return(materials); }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// HandleObjectsMode /// # To insert objects in scene using mouse /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// void HandleObjectsMode() { if ((GetEditorTimeDiff() > 0.1f) && EditorBasicFunctions.GetMouseButtonDown(0) && EditorBasicFunctions.GetInsertModeKeyPressed() && !GetDoingSomethingSpecial()) { previousEditorTime = EditorApplication.timeSinceStartup; Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition); RaycastHit hit; if (Physics.Raycast(ray, out hit)) { if (lastPrefabHitPoint.ToString() == hit.point.ToString()) { //Debug.Log ("NOTE: same point duplicate -> lastPrefabHitPoint: " + lastPrefabHitPoint); } else { //Debug.Log ("lastPrefabHitPoint A: " + lastPrefabHitPoint); lastPrefabHitPoint = hit.point; //Debug.Log ("New Object"); //Debug.Log ("Hit position: " + hit.point); //Debug.Log ("Collider Name: " + hit.collider.name); GameObject actualObject = Instantiate(genericObject); switch (pivotMode) { case cPivotMode.useOriginalPivot: { actualObject.transform.position = hit.point + extraNormalOffset * hit.normal; } break; case cPivotMode.autoCalculate: { MeshFilter actualMeshFilter = BasicFunctions.GetMeshFilterInChilds(actualObject.transform); if (actualMeshFilter == null) { actualObject.transform.position = hit.point + extraNormalOffset * hit.normal; } else { float pivotOffset = extraNormalOffset + 0.5f * (Mathf.Abs(actualMeshFilter.sharedMesh.bounds.max.y) + Mathf.Abs(actualMeshFilter.sharedMesh.bounds.min.y)); //Debug.Log ("pivotOffset: " + pivotOffset); //Debug.Log ("max: " + actualMeshFilter.sharedMesh.bounds.max); //Debug.Log ("min: " + actualMeshFilter.sharedMesh.bounds.min); //Debug.Log ("Center: " + actualMeshFilter.sharedMesh.bounds.center); actualObject.transform.position = hit.point + pivotOffset * hit.normal; } } break; } actualObject.transform.localScale = Random.Range(objectScaleRange.x, objectScaleRange.y) * actualObject.transform.localScale; actualObject.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.normal); actualObject.transform.Rotate(genericObject.transform.rotation.eulerAngles); actualObject.transform.Rotate(Random.Range(objectRotationRangeX.x, objectRotationRangeX.y), Random.Range(objectRotationRangeY.x, objectRotationRangeY.y), Random.Range(objectRotationRangeZ.x, objectRotationRangeZ.y)); if (attachObjectToCollisionObject) { actualObject.transform.parent = hit.collider.transform; } else { GameObject objectsContainer = BasicFunctions.CreateContainerIfNotExists(BasicDefines.OBJECT_CONTAINER_NAME); actualObject.transform.parent = objectsContainer.transform; } actualObject.AddComponent <GenericObject> (); actualObject.name = actualObject.GetComponent <GenericObject> ().Generate(BasicDefines.OBJECT_BASE_NAME, GetSeedForInstancies(), true, genericObject.name); actualObjectToForceSelect = actualObject.gameObject; } } } }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// GetThumbnail /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// public static Texture GetThumbnail(GameObject obj) { string actualTextureName = obj.name + "_" + "thumbnailforeditorwindow"; // fist, look in the list for (int i = 0; i < thumbTextureList.Count; i++) { if (thumbTextureList[i] && (thumbTextureList[i].name == actualTextureName)) { //Debug.Log ("Is in the list, actualTextureName: " + actualTextureName); return(thumbTextureList[i]); } } // if it is not in the list GameObject container = new GameObject(); GameObject clone = GameObject.Instantiate(obj); clone.transform.position = 99999 * Vector3.one; Vector3 lookAtTarget = clone.transform.position; float offset = 0.3f * obj.transform.localScale.magnitude; MeshFilter actualMeshFilter = BasicFunctions.GetMeshFilterInChilds(clone.transform); if ((actualMeshFilter != null) && (actualMeshFilter.sharedMesh != null)) { lookAtTarget = clone.transform.position + actualMeshFilter.sharedMesh.bounds.center; offset = 0.75f * Vector3.Distance(actualMeshFilter.sharedMesh.bounds.max, actualMeshFilter.sharedMesh.bounds.min); } Camera actualCamera = container.gameObject.AddComponent <Camera>(); actualCamera.farClipPlane = offset + 10; actualCamera.nearClipPlane = 0.1f; actualCamera.transform.position = 99999 * Vector3.one + (new Vector3(0, 0, offset)); actualCamera.transform.LookAt(lookAtTarget); actualCamera.clearFlags = CameraClearFlags.SolidColor; actualCamera.backgroundColor = Color.clear; Light actualLight = container.gameObject.AddComponent <Light>(); actualLight.type = LightType.Directional; actualLight.transform.position = 99999 * Vector3.one + (new Vector3(0, 0, offset)); actualLight.transform.LookAt(lookAtTarget); clone.transform.LookAt(actualCamera.transform); Texture actualThumb = RTImage(actualCamera); GameObject.DestroyImmediate(container, true); GameObject.DestroyImmediate(clone, true); if (actualThumb != null) { // put in the list actualThumb.name = actualTextureName; //Debug.Log ("Add new thumb to the list: " + actualThumb.name); thumbTextureList.Add(actualThumb); } return(actualThumb); }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Start /// # Initialise all /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// void Start() { objectsContainer = BasicFunctions.CreateContainerIfNotExists("_OBJECTS"); }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Merge /// # Merge mesh /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// static GameObject SubMerge(List <GameObject> gameObjectList, string mergedObjectName, bool deleteOldObjects, bool colapse) { // create merged game object GameObject newGo = new GameObject(mergedObjectName); // get mesh fiters List <MeshFilter> meshFilters = new List <MeshFilter> (); for (int i = 0; i < gameObjectList.Count; i++) { meshFilters.Add(BasicFunctions.GetMeshFilterInChilds(gameObjectList [i].transform)); } // get material list List <Material> materials = new List <Material> (); foreach (MeshFilter mf in meshFilters) { MeshRenderer mr = mf.gameObject.GetComponent <MeshRenderer> (); materials.Add(mr.gameObject.GetComponent <Renderer> ().sharedMaterial); } CombineInstance[] combine = new CombineInstance[meshFilters.Count]; int x = 0; while (x < meshFilters.Count) { combine [x].mesh = meshFilters [x].sharedMesh; combine [x].transform = meshFilters [x].transform.localToWorldMatrix; x++; } newGo.AddComponent <MeshFilter> (); newGo.GetComponent <MeshFilter> ().mesh = new Mesh(); newGo.GetComponent <MeshFilter> ().sharedMesh.name = "NewMesh"; newGo.GetComponent <MeshFilter> ().sharedMesh.CombineMeshes(combine, colapse); // For MeshRenderer // Get / Create mesh renderer MeshRenderer meshRendererCombine = newGo.GetComponent <MeshRenderer> (); if (!meshRendererCombine) { meshRendererCombine = newGo.AddComponent <MeshRenderer> (); } // Assign materials meshRendererCombine.materials = materials.ToArray(); // delete olds /*if (deleteOldObjects) * { * foreach (GameObject go in gameObjectList) * { * GameObject.DestroyImmediate (go); * } * }*/ return(newGo); }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// DeleteAllAction /// # Handle "delete all" action /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// void DeleteAllAction() { //Debug.Log("Delete All"); bool deleteMeshDecals = false; bool deleteProjectedDecals = false; bool deleteObjects = false; bool doItByBaseName = false; string baseName = ""; switch (systemMode) { case cSystemMode.edition: { deleteMeshDecals = true; deleteProjectedDecals = true; deleteObjects = true; } break; case cSystemMode.meshDecals: { deleteMeshDecals = true; doItByBaseName = true; baseName = BasicDefines.MESH_DECAL_BASE_NAME; } break; case cSystemMode.projectedDecals: { deleteProjectedDecals = true; doItByBaseName = true; baseName = BasicDefines.PROJECTED_DECAL_BASE_NAME; } break; case cSystemMode.objects: { deleteObjects = true; doItByBaseName = true; baseName = BasicDefines.OBJECT_BASE_NAME; } break; } if (deleteMeshDecals) { GenericDestroyable.DestroyAll(doItByBaseName, baseName); BasicFunctions.DestroyGameObjectByName(baseName); } if (deleteProjectedDecals) { GenericDestroyable.DestroyAll(doItByBaseName, baseName); BasicFunctions.DestroyGameObjectByName(baseName); } if (deleteObjects) { GenericDestroyable.DestroyAll(doItByBaseName, baseName); BasicFunctions.DestroyGameObjectByName(baseName); } }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// HandleProjectedDecalsMode /// # To insert projected decals in scene using mouse /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// void HandleProjectedDecalsMode() { if ((GetEditorTimeDiff() > 0.1f) && EditorBasicFunctions.GetMouseButtonDown(0) && EditorBasicFunctions.GetInsertModeKeyPressed() && !GetDoingSomethingSpecial()) { previousEditorTime = EditorApplication.timeSinceStartup; //Debug.Log ("Event.current.mousePosition: " + Event.current.mousePosition); Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition); RaycastHit hit; if (Physics.Raycast(ray, out hit)) { if (lastProjectedDecalsHitPoint.ToString() == hit.point.ToString()) { //Debug.Log ("NOTE: same point duplicate -> lastProjectedDecalsHitPoint: " + lastProjectedDecalsHitPoint); } else { //Debug.Log ("lastProjectedDecalsHitPoint A: " + lastProjectedDecalsHitPoint); lastProjectedDecalsHitPoint = hit.point; //Debug.Log ("New Decal"); //Debug.Log ("Hit position: " + hit.point); //Debug.Log ("Collider Name: " + hit.collider.name); GenericProjectorDecal actualProjectedDecal = Instantiate(projectedDecalPrefab.gameObject).GetComponent <GenericProjectorDecal> () as GenericProjectorDecal; actualProjectedDecal.SetOldParameters(projectedDecalPrefab.transform.localScale, projectedDecalPrefab.GetComponent <Projector> ().orthographicSize, projectedDecalPrefab.GetComponent <Projector> ().aspectRatio); //Debug.Log (actualProjectedDecal.material.mainTexture.name); actualProjectedDecal.transform.position = hit.point + 0.3f * hit.normal; Vector3 finalScale = Random.Range(actualProjectedDecal.scaleRange.x, actualProjectedDecal.scaleRange.y) * actualProjectedDecal.transform.localScale; float textureAspectRatio = (float)actualProjectedDecal.material.mainTexture.width / (float)actualProjectedDecal.material.mainTexture.height; finalScale.x = textureAspectRatio * finalScale.x; actualProjectedDecal.transform.localScale = finalScale; actualProjectedDecal.transform.LookAt(hit.point); actualProjectedDecal.transform.Rotate(new Vector3(0, 0, Random.Range(actualProjectedDecal.rotationRange.x, actualProjectedDecal.rotationRange.y))); actualProjectedDecal.name = actualProjectedDecal.Generate(BasicDefines.PROJECTED_DECAL_BASE_NAME, GetSeedForInstancies(), true, actualProjectedDecal.material.name); //Debug.Log ("actualProjectedDecal.attachToCollisionObject: " + actualProjectedDecal.attachToCollisionObject); if (actualProjectedDecal.attachToCollisionObject) { //Debug.Log ("Parent name: " + hit.collider.name); actualProjectedDecal.transform.parent = hit.collider.transform; } else { GameObject decalsContainer = BasicFunctions.CreateContainerIfNotExists(BasicDefines.PROJECTED_DECAL_CONTAINER_NAME); actualProjectedDecal.transform.parent = decalsContainer.transform; } actualProjectedDecal.UpdateShape(); actualObjectToForceSelect = actualProjectedDecal.gameObject; } } } }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// DrawObjectlList /// # Draw actual selectable prefab list (looking inside it's folder) and handle dev's selections /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// public static GameObject DrawPrefabList(GameObject actualGameObject, Rect position) { // save actual gui color Color actualGuiColor = GUI.color; Color bgColor = GUI.backgroundColor; GameObject selectedGameObject = actualGameObject; EditorGUILayout.Separator(); // get actual prefab list bool redoTheList = false; for (int i = 0; i < prefabList.Count; i++) { if (AssetDatabase.GetAssetPath(prefabList [i]).Length < 2) { redoTheList = true; } } if (redoTheList) { Debug.Log("Prefab deleted, redo prefab decal list"); } if ((prefabList.Count <= 0) || redoTheList) { prefabList = EditorBasicFunctions.GetPrefabList(); } // calculate paths List <string> localTotalGameObjectPathList = new List <string> (); for (int i = 0; i < prefabList.Count; i++) { string totalPath = AssetDatabase.GetAssetPath(prefabList [i]); string actualPath = Path.GetDirectoryName(totalPath); int index = 0; for (int j = 0; j < actualPath.Length; j++) { if (actualPath [j] == '/') { index = j; } } string finalPath = actualPath.Substring(index + 1, actualPath.Length - index - 1); localTotalGameObjectPathList.Add(finalPath); } List <string> localGameObjectPathList = localTotalGameObjectPathList.Distinct().ToList(); if (!showSystemFolders) { localGameObjectPathList.Remove("System"); } //print ("------------------------------------------"); //for (int i = 0; i < localGameObjectPathList.Count; i++) //{ //print (localGameObjectPathList [i]); //} EditorGUILayout.Separator(); GenericObject.actualFolderIndex = EditorGUILayout.Popup(GenericObject.actualFolderIndex, localGameObjectPathList.ToArray(), new GUILayoutOption[] { GUILayout.Width(0.81f * position.width) }); EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); if (EditorBasicFunctions.GetEditorTextButton("Refresh", "Refresh the list, just in case", position)) { RefreshLists(); } GUILayout.FlexibleSpace(); EditorGUILayout.EndHorizontal(); EditorGUILayout.Separator(); string selectedGameObjectPath = BasicDefines.NOT_DEFINED; if (localGameObjectPathList.Count > 0) { selectedGameObjectPath = localGameObjectPathList [GenericObject.actualFolderIndex]; } // test some things int numberOfObjectsPerLine = 4; int cont = 0; bool begin = false; bool actualSelectedElementIsInSelectedPathList = false; GameObject firstElementInActualPath = null; // draw objects in editor window for (int i = 0; i < Mathf.Ceil((float)prefabList.Count); i++) { if (localTotalGameObjectPathList [i] == selectedGameObjectPath) { if (firstElementInActualPath == null) { firstElementInActualPath = prefabList [i]; } if ((selectedGameObject == prefabList [i])) { actualSelectedElementIsInSelectedPathList = true; } if (cont % numberOfObjectsPerLine == 0) { GUILayout.BeginHorizontal(); begin = true; } Texture previsualization = BasicFunctions.GetThumbnail(prefabList [i]); Texture unityPreview = AssetPreview.GetAssetPreview(actualGameObject); if (unityPreview) { //previsualization = unityPreview; } if (actualGameObject == prefabList [i]) { GUI.color = new Color(1, 1, 1, 1); GUI.backgroundColor = new Color(0.6f, 0.0f, 0.6f, 1f); } else { GUI.color = new Color(1, 1, 1, 1f); GUI.backgroundColor = new Color(1, 1, 1, 0.3f); } float buttonsScale = 0.94f * position.width / (numberOfObjectsPerLine + 0.3f); bool selected = GUILayout.Button(new GUIContent(previsualization, prefabList [i].name), new GUILayoutOption[] { GUILayout.Width(buttonsScale), GUILayout.Height(buttonsScale) }); if (selected) { selectedGameObject = prefabList [i]; } if (cont % numberOfObjectsPerLine == numberOfObjectsPerLine - 1) { GUILayout.EndHorizontal(); begin = false; } cont++; } } if (!actualSelectedElementIsInSelectedPathList) { //print ("Change to firstElementInActualPath: " + firstElementInActualPath.name); selectedGameObject = firstElementInActualPath; } if (begin) { EditorGUILayout.EndHorizontal(); } // restore Gui Color GUI.color = actualGuiColor; GUI.backgroundColor = bgColor; //return selected game object return(selectedGameObject); }
/////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// HandleMeshDecalsMode /// # To insert mesh decals in scene using mouse /// </summary> /////////////////////////////////////////////////////////////////////////////////////////////////////// void HandleMeshDecalsMode() { if ((GetEditorTimeDiff() > 0.1f) && EditorBasicFunctions.GetMouseButtonDown(0) && EditorBasicFunctions.GetInsertModeKeyPressed() && !GetDoingSomethingSpecial()) { previousEditorTime = EditorApplication.timeSinceStartup; //Debug.Log ("Event.current.mousePosition: " + Event.current.mousePosition); Ray ray = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition); RaycastHit hit; //Debug.Log ("-----------------------------------------------------------"); if (Physics.Raycast(ray, out hit)) { if (lastMeshDecalsHitPoint.ToString() == hit.point.ToString()) { //Debug.Log ("NOTE: same point duplicate -> lastMeshDecalsHitPoint: " + lastMeshDecalsHitPoint); } else { //Debug.Log ("lastMeshDecalsHitPoint A: " + lastMeshDecalsHitPoint); lastMeshDecalsHitPoint = hit.point; //Debug.Log ("hit.point: " + hit.point); //Debug.Log ("lastMeshDecalsHitPoint B: " + lastMeshDecalsHitPoint); //Debug.Log ("New Decal"); //Debug.Log ("Hit position: " + hit.point); //Debug.Log ("Collider Name: " + hit.collider.name); bool setPlanarDecal = EditorBasicFunctions.planarMeshDecals; if (hit.collider.GetComponent <Terrain> ()) { //Debug.Log ("It's a terrain, set the decal as planar"); setPlanarDecal = true; } meshDecalPrefab.planarDecal = setPlanarDecal; meshDecalPrefab.comeFromEditor = setPlanarDecal; GenericMeshDecal actualDecal = Instantiate(meshDecalPrefab.gameObject).GetComponent <GenericMeshDecal> (); actualDecal.transform.position = hit.point; meshDecalPrefab.comeFromEditor = false; Vector3 finalScale = Random.Range(actualDecal.scaleRange.x, actualDecal.scaleRange.y) * actualDecal.transform.localScale; float textureAspectRatio = (float)actualDecal.material.mainTexture.width / (float)actualDecal.material.mainTexture.height; if (actualDecal.GetPlanar()) { finalScale.x = 0.5f * finalScale.x; finalScale.y = textureAspectRatio * finalScale.x; } else { finalScale.x = textureAspectRatio * finalScale.x; } //finalScale.y = finalScale.x; //finalScale.z = finalScale.x; actualDecal.transform.localScale = finalScale; actualDecal.transform.rotation = Quaternion.FromToRotation(Vector3.up, hit.normal); actualDecal.name = actualDecal.Generate(BasicDefines.MESH_DECAL_BASE_NAME, GetSeedForInstancies(), true, actualDecal.material.name); actualDecal.UpdateDecallShape(true, false); //Debug.Log ("actualDecal.attachToCollisionObject: " + actualDecal.attachToCollisionObject); if (actualDecal.attachToCollisionObject) { //Debug.Log ("Parent name: " + hit.collider.name); actualDecal.transform.parent = hit.collider.transform; } else { GameObject decalsContainer = BasicFunctions.CreateContainerIfNotExists(BasicDefines.MESH_DECAL_CONTAINER_NAME); actualDecal.transform.parent = decalsContainer.transform; } if (actualDecal.addCollider) { actualDecal.gameObject.AddComponent <MeshCollider> (); //actualDecal.gameObject.GetComponent<MeshCollider> ().convex = true; } actualObjectToForceSelect = actualDecal.gameObject; } } } }