void PropertiesWindow(int id = 2) { GUILayout.BeginVertical(); if (listTypes != null && !string.IsNullOrEmpty(listTypes.SelectedItem)) { if (selectedType != null) { // Title GUILayout.Space(2); LabelHelper.TitleLabel(selectedType.Name); LineHelper.Draw(Color.gray); // Common GUILayout.Space(2); if (selectedType.BaseType != typeof(ObservableModel)) { GUILayout.BeginHorizontal(); if (ColorButton.Draw("Edit View Logic (Handler)", CommonColor.LightBlue, GUILayout.Height(30))) { string handler = CodeGenerationHelper.GetScriptPathByType(selectedType); handler = handler.Replace(".cs", ".Handler.cs"); UnityEditorInternal.InternalEditorUtility.OpenFileAtLineExternal(handler, 1); } if (ColorButton.Draw("Edit View (UI)", CommonColor.LightBlue, GUILayout.Height(30))) { GameObject prefabInstance; UnityEngine.Object obj = FindObjectOfType(selectedType); if (obj != null) { prefabInstance = ((MonoBehaviour)obj).gameObject; } else { bool isDialog = selectedType.BaseType == typeof(UIManDialog); string prefabFolder = GetUIPrefabPath(selectedType, isDialog); string prefabFile = selectedType.Name + PREFAB_EXT; string prefabPath = Path.Combine(prefabFolder, prefabFile); GameObject prefab = AssetDatabase.LoadAssetAtPath <GameObject> (prefabPath); if (prefab == null) { prefab = FindAssetObject <GameObject> (selectedType.Name, PREFAB_EXT); } prefabInstance = PrefabUtility.InstantiatePrefab(prefab) as GameObject; if (isDialog) { prefabInstance.transform.SetParent(UIMan.Instance.dialogRoot, false); } else { prefabInstance.transform.SetParent(UIMan.Instance.screenRoot, false); } } Selection.activeGameObject = prefabInstance; } if (ColorButton.Draw("Delete", CommonColor.LightRed, GUILayout.Height(30))) { string cs = CodeGenerationHelper.GetScriptPathByType(selectedType); string handler = cs.Replace(".cs", ".Handler.cs"); AssetDatabase.DeleteAsset(cs); AssetDatabase.DeleteAsset(handler); bool isDialog = selectedType.BaseType == typeof(UIManDialog); string prefabFolder = GetUIPrefabPath(selectedType, isDialog); string prefabFile = selectedType.Name + PREFAB_EXT; string prefabPath = UIManDefine.ASSETS_FOLDER + prefabFolder + prefabFile; AssetDatabase.DeleteAsset(prefabPath); AssetDatabase.Refresh(); } GUILayout.EndHorizontal(); LineHelper.Draw(Color.gray); } // Base type GUILayout.Space(10); LabelHelper.HeaderLabel("Type"); LineHelper.Draw(Color.gray); baseTypePopup.Draw(); if (baseTypePopup.SelectedItem != "ObservableModel") { if (!System.IO.File.Exists(handlerScriptPath)) { if (GUILayout.Button("Generate Handler")) { string backupCode = CodeGenerationHelper.DeleteScript(handlerScriptPath); GenerateViewModelHandler(backupCode, selectedType.BaseType.Name); } } } // Properties GUILayout.Space(10); LabelHelper.HeaderLabel("Properties"); LineHelper.Draw(Color.gray); propertiesScrollPos = EditorGUILayout.BeginScrollView(propertiesScrollPos, GUILayout.ExpandWidth(true), GUILayout.ExpandHeight(true)); if (propertiesDrawerCache.ContainsKey(selectedType)) { EditablePropertyDrawer[] props = propertiesDrawerCache [selectedType]; for (int i = 0; i < props.Length; i++) { props [i].Draw(propertiesAreaWidth); } } EditorGUILayout.EndScrollView(); } GUILayout.Space(10); // Add property if (ColorButton.Draw("Add New Property", CommonColor.LightGreen, GUILayout.Height(30))) { int newIndex = 0; string strNewIndex = ""; for (int i = 0; i < selectedProperties.Length; i++) { if (selectedProperties [i].LastName.Contains("NewProperty")) { newIndex++; } } if (newIndex > 0) { strNewIndex = newIndex.ToString(); } CustomPropertyInfo newProperty = new CustomPropertyInfo("", typeof(string)); newProperty.LastName = "NewProperty" + strNewIndex; ArrayUtility.Add <CustomPropertyInfo> (ref selectedProperties, newProperty); CachePropertiesDrawer(); } //Save all change CustomPropertyInfo[] changeList = new CustomPropertyInfo[0]; CustomPropertyInfo[] selectedList = new CustomPropertyInfo[0]; for (int i = 0; i < selectedProperties.Length; i++) { if (selectedProperties [i].HasChange) { ArrayUtility.Add(ref changeList, selectedProperties [i]); } if (selectedProperties [i].IsSelected) { ArrayUtility.Add(ref selectedList, selectedProperties [i]); } } GUILayout.Space(10); LineHelper.Draw(Color.gray); GUILayout.Space(5); if (changeList.Length > 0) { if (ColorButton.Draw("Save All Changes", CommonColor.LightGreen, GUILayout.Height(30))) { for (int i = 0; i < changeList.Length; i++) { changeList [i].CommitChange(); } SaveCurrentType(true, baseTypePopup.SelectedItem); } } if (selectedList.Length > 0) { if (ColorButton.Draw("Delete Selected Properties", CommonColor.LightRed, GUILayout.Height(30))) { for (int i = 0; i < selectedList.Length; i++) { ArrayUtility.Remove(ref selectedProperties, selectedList [i]); } SaveCurrentType(true, baseTypePopup.SelectedItem); CachePropertiesDrawer(true); } } if (selectedProperties.Length > 0) { if (ColorButton.Draw("Delete All Properties", CommonColor.LightRed, GUILayout.Height(30))) { while (selectedProperties.Length > 0) { ArrayUtility.Clear(ref selectedProperties); SaveCurrentType(); CachePropertiesDrawer(true); } } } } else { GUILayout.Label("NO DATA FOR PREVIEW!"); } GUILayout.EndVertical(); }
static public void UpdateCache() { // Deserialize the cache from the unity resources if (eventCache == null) { eventCache = AssetDatabase.LoadAssetAtPath(CacheAssetFullName, typeof(EventCache)) as EventCache; if (eventCache == null || eventCache.cacheVersion != EventCache.CurrentCacheVersion) { UnityEngine.Debug.Log("FMOD Studio: Cannot find serialized event cache or cache in old format, creating new instance"); eventCache = ScriptableObject.CreateInstance <EventCache>(); eventCache.cacheVersion = EventCache.CurrentCacheVersion; AssetDatabase.CreateAsset(eventCache, CacheAssetFullName); } } if (EditorUtils.GetBankDirectory() == null) { ClearCache(); return; } string defaultBankFolder = null; if (!Settings.Instance.HasPlatforms) { defaultBankFolder = EditorUtils.GetBankDirectory(); } else { FMODPlatform platform = RuntimeUtils.GetEditorFMODPlatform(); if (platform == FMODPlatform.None) { platform = FMODPlatform.PlayInEditor; } defaultBankFolder = Path.Combine(EditorUtils.GetBankDirectory(), Settings.Instance.GetBankPlatform(platform)); } string[] bankPlatforms = EditorUtils.GetBankPlatforms(); string[] bankFolders = new string[bankPlatforms.Length]; for (int i = 0; i < bankPlatforms.Length; i++) { bankFolders[i] = Path.Combine(EditorUtils.GetBankDirectory(), bankPlatforms[i]); } List <String> stringBanks = new List <string>(0); try { var files = Directory.GetFiles(defaultBankFolder, "*." + StringBankExtension); stringBanks = new List <string>(files); } catch { } // Strip out OSX resource-fork files that appear on FAT32 stringBanks.RemoveAll((x) => Path.GetFileName(x).StartsWith("._")); if (stringBanks.Count == 0) { bool wasValid = eventCache.StringsBankWriteTime != DateTime.MinValue; ClearCache(); if (wasValid) { UnityEngine.Debug.LogError(String.Format("FMOD Studio: Directory {0} doesn't contain any banks. Build from the tool or check the path in the settings", defaultBankFolder)); } return; } // If we have multiple .strings.bank files find the most recent stringBanks.Sort((a, b) => File.GetLastWriteTime(b).CompareTo(File.GetLastWriteTime(a))); string stringBankPath = stringBanks[0]; // Use the string bank timestamp as a marker for the most recent build of any bank because it gets exported every time if (File.GetLastWriteTime(stringBankPath) == eventCache.StringsBankWriteTime) { countdownTimer = CountdownTimerReset; return; } if (EditorUtils.IsFileOpenByStudio(stringBankPath)) { countdownTimer = CountdownTimerReset; return; } FMOD.Studio.Bank stringBank = null; EditorUtils.CheckResult(EditorUtils.System.loadBankFile(stringBankPath, FMOD.Studio.LOAD_BANK_FLAGS.NORMAL, out stringBank)); if (stringBank == null) { countdownTimer = CountdownTimerReset; return; } // Iterate every string in the strings bank and look for any that identify banks int stringCount; stringBank.getStringCount(out stringCount); List <string> bankFileNames = new List <string>(); for (int stringIndex = 0; stringIndex < stringCount; stringIndex++) { string currentString; Guid currentGuid; stringBank.getStringInfo(stringIndex, out currentGuid, out currentString); const string BankPrefix = "bank:/"; int BankPrefixLength = BankPrefix.Length; if (currentString.StartsWith(BankPrefix)) { string bankFileName = currentString.Substring(BankPrefixLength) + "." + BankExtension; if (!bankFileName.Contains(StringBankExtension)) // filter out the strings bank { bankFileNames.Add(bankFileName); } } } // Unload the strings bank stringBank.unload(); // Check if any of the files are still being written by studio foreach (string bankFileName in bankFileNames) { string bankPath = Path.Combine(defaultBankFolder, bankFileName); if (!File.Exists(bankPath)) { // TODO: this is meant to catch the case where we're in the middle of a build and a bank is being built // for the first time. But it also stops someone trying to import an incomplete set of banks without any error message. countdownTimer = CountdownTimerReset; return; } EditorBankRef bankRef = eventCache.EditorBanks.Find((x) => bankPath == x.Path); if (bankRef == null) { if (EditorUtils.IsFileOpenByStudio(bankPath)) { countdownTimer = CountdownTimerReset; return; } continue; } if (bankRef.LastModified != File.GetLastWriteTime(bankPath)) { if (EditorUtils.IsFileOpenByStudio(bankPath)) { countdownTimer = CountdownTimerReset; return; } } } // Count down the timer in case we catch studio in-between updating two files. if (countdownTimer-- > 0) { return; } // All files are finished being modified by studio so update the cache // Stop editor preview so no stale data being held EditorUtils.PreviewStop(); // Reload the strings bank EditorUtils.CheckResult(EditorUtils.System.loadBankFile(stringBankPath, FMOD.Studio.LOAD_BANK_FLAGS.NORMAL, out stringBank)); if (stringBank == null) { ClearCache(); return; } FileInfo stringBankFileInfo = new FileInfo(stringBankPath); eventCache.StringsBankWriteTime = stringBankFileInfo.LastWriteTime; string masterBankFileName = Path.GetFileName(stringBankPath).Replace(StringBankExtension, BankExtension); AssetDatabase.StartAssetEditing(); if (eventCache.StringsBankRef == null) { eventCache.StringsBankRef = ScriptableObject.CreateInstance <EditorBankRef>(); eventCache.StringsBankRef.FileSizes = new List <EditorBankRef.NameValuePair>(); eventCache.EditorBanks.Add(eventCache.StringsBankRef); AssetDatabase.AddObjectToAsset(eventCache.StringsBankRef, eventCache); AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(eventCache.StringsBankRef)); } eventCache.StringsBankRef.Path = stringBankPath; eventCache.StringsBankRef.LastModified = eventCache.StringsBankWriteTime; eventCache.StringsBankRef.FileSizes.Clear(); if (Settings.Instance.HasPlatforms) { for (int i = 0; i < bankPlatforms.Length; i++) { eventCache.StringsBankRef.FileSizes.Add(new EditorBankRef.NameValuePair(bankPlatforms[i], stringBankFileInfo.Length)); } } else { eventCache.StringsBankRef.FileSizes.Add(new EditorBankRef.NameValuePair("", stringBankFileInfo.Length)); } eventCache.EditorBanks.ForEach((x) => x.Exists = false); eventCache.StringsBankRef.Exists = true; string[] folderContents = Directory.GetFiles(defaultBankFolder); foreach (string bankFileName in bankFileNames) { // Get the true file path, can't trust the character case we got from the string bank string bankPath = ArrayUtility.Find(folderContents, x => (string.Equals(bankFileName, Path.GetFileName(x), StringComparison.CurrentCultureIgnoreCase))); FileInfo bankFileInfo = new FileInfo(bankPath); EditorBankRef bankRef = eventCache.EditorBanks.Find((x) => bankFileInfo.FullName == x.Path); // New bank we've never seen before if (bankRef == null) { bankRef = ScriptableObject.CreateInstance <EditorBankRef>(); AssetDatabase.AddObjectToAsset(bankRef, eventCache); AssetDatabase.ImportAsset(AssetDatabase.GetAssetPath(bankRef)); bankRef.Path = bankFileInfo.FullName; bankRef.LastModified = DateTime.MinValue; bankRef.FileSizes = new List <EditorBankRef.NameValuePair>(); eventCache.EditorBanks.Add(bankRef); } bankRef.Exists = true; // Timestamp check - if it doesn't match update events from that bank if (bankRef.LastModified != bankFileInfo.LastWriteTime) { bankRef.LastModified = bankFileInfo.LastWriteTime; UpdateCacheBank(bankRef); } // Update file sizes bankRef.FileSizes.Clear(); if (Settings.Instance.HasPlatforms) { for (int i = 0; i < bankPlatforms.Length; i++) { string platformBankPath = Path.Combine(bankFolders[i], bankFileName); var fileInfo = new FileInfo(platformBankPath); if (fileInfo.Exists) { bankRef.FileSizes.Add(new EditorBankRef.NameValuePair(bankPlatforms[i], fileInfo.Length)); } } } else { string platformBankPath = Path.Combine(EditorUtils.GetBankDirectory(), bankFileName); var fileInfo = new FileInfo(platformBankPath); if (fileInfo.Exists) { bankRef.FileSizes.Add(new EditorBankRef.NameValuePair("", fileInfo.Length)); } } if (bankFileInfo.Name == masterBankFileName) { eventCache.MasterBankRef = bankRef; } } // Unload the strings bank stringBank.unload(); // Remove any stale entries from bank and event lists eventCache.EditorBanks.FindAll((x) => !x.Exists).ForEach(RemoveCacheBank); eventCache.EditorBanks.RemoveAll((x) => !x.Exists); eventCache.EditorEvents.RemoveAll((x) => x.Banks.Count == 0); OnCacheChange(); AssetDatabase.StopAssetEditing(); }
/// <summary> /// Reads a sequence of bytes from the current stream. /// </summary> /// <param name="buffer">The buffer that contains decrypted data.</param> /// <param name="offset">The offset in buffer at which to begin storing the decrypted data.</param> /// <param name="count">The maximum number of bytes to get.</param> /// <exception cref="ArgumentOutOfRangeException">Raised when buffer or the internal decryptedBuffer doesn't /// contain enough space /// </exception> /// <exception cref="IOException">Raised when attempting to read from/write to a remote connection which /// has been closed</exception> /// <returns>The actual number of bytes read into the buffer. Could be less than count</returns> public override int Read(byte[] buffer, int offset, int count) { if (offset > buffer.Length - 1) { throw new ArgumentOutOfRangeException("offset"); } if (offset + count > buffer.Length) { throw new ArgumentOutOfRangeException("count"); } if (!IsBufferEmpty()) { if (CheckAvailableCount(count)) { Array.Copy(decryptedBuffer, this.startIndex, buffer, offset, count); this.startIndex += count; return(count); } else { int sizeRead = this.endIndex - this.startIndex; Array.Copy(decryptedBuffer, this.startIndex, buffer, offset, sizeRead); // All data is read, reset indices this.startIndex = 0; this.endIndex = 0; return(sizeRead); } } byte[] encryptedMsg = null; int bytesReceived = 0; byte[] decryptedMsg = null; while (decryptedMsg == null) { // decryptedMsg being null indicates incomplete data, so we continue reading and decrypting. bytesReceived = ReceivePacket(); // The connection has been closed by remote server if (bytesReceived == 0) { return(0); } // There's pooled data, concatenate the buffer together for decryption if (this.pooledBuffer != null && this.pooledBuffer.Length > 0) { encryptedMsg = new byte[this.pooledBuffer.Length + bytesReceived]; Array.Copy(this.pooledBuffer, encryptedMsg, this.pooledBuffer.Length); Array.Copy(recvBuffer, 0, encryptedMsg, this.pooledBuffer.Length, bytesReceived); this.pooledBuffer = null; } else { encryptedMsg = new byte[bytesReceived]; Array.Copy(recvBuffer, encryptedMsg, bytesReceived); } byte[] extraData = null; // Do decryption SecurityBuffer[] securityBuffers = new SecurityBuffer[] { new SecurityBuffer(SecurityBufferType.Data, encryptedMsg), new SecurityBuffer(SecurityBufferType.Empty, null), new SecurityBuffer(SecurityBufferType.Empty, null), new SecurityBuffer(SecurityBufferType.Empty, null) }; context.Decrypt(securityBuffers); for (int i = 0; i < securityBuffers.Length; i++) { if (securityBuffers[i].BufferType == SecurityBufferType.Data) { decryptedMsg = ArrayUtility.ConcatenateArrays(decryptedMsg, securityBuffers[i].Buffer); } else if (securityBuffers[i].BufferType == SecurityBufferType.Extra) { extraData = ArrayUtility.ConcatenateArrays(extraData, securityBuffers[i].Buffer); } } if (extraData != null && extraData.Length > 0) { this.pooledBuffer = extraData; } } Array.Copy(decryptedMsg, 0, this.decryptedBuffer, this.endIndex, decryptedMsg.Length); this.endIndex += decryptedMsg.Length; return(Read(buffer, offset, count)); }
private void ShowPoint(int index, Vector3 point) { if (!CanShowPoint(index)) { return; } Handles.color = ModeColors[(int)m_splineBase.GetControlPointMode(index)]; if (index % 3 == 0) { Handles.color = Color.green; } float size = HandleUtility.GetHandleSize(point); Handles.CapFunction dcf = Handles.DotHandleCap; if (index == 0) { size *= 2f; } if (Handles.Button(point, m_handleRotation, size * HandleSize, size * PickSize, dcf)) { m_selectedIndex = index; SplineControlPoint controlPoint = m_splineBase.GetComponentsInChildren <SplineControlPoint>(true).Where(cpt => cpt.Index == index).FirstOrDefault(); if (controlPoint != null) { if (Event.current.control || Event.current.shift) { GameObject[] objects = Selection.gameObjects; Selection.activeGameObject = controlPoint.gameObject; if (!objects.Contains(controlPoint.gameObject)) { ArrayUtility.Add(ref objects, controlPoint.gameObject); } else { if (!Event.current.shift) { ArrayUtility.Remove(ref objects, controlPoint.gameObject); } } Selection.objects = objects; } else { Selection.activeGameObject = controlPoint.gameObject; } } Repaint(); } if (m_selectedIndex == index) { int curveIndex = (m_selectedIndex - 1) / 3; int prevCurveIndex = curveIndex - 1; int nextCurveIndex = curveIndex + 1; if (m_splineBase.Loop) { if (prevCurveIndex < 0) { prevCurveIndex = m_splineBase.CurveCount - 1; } if (nextCurveIndex > m_splineBase.CurveCount - 1) { nextCurveIndex = 0; } } GUIStyle style = new GUIStyle(); style.normal.textColor = Color.green; if (prevCurveIndex >= 0) { float prevLen = m_splineBase.EvalLength(prevCurveIndex); float prevCur = m_splineBase.EvalCurveLength(prevCurveIndex, GetStepsPerCurve()); Handles.Label(m_splineBase.GetPoint(0.5f, prevCurveIndex), string.Format("Len: {0:0.00} m, Cur: {1:0.00} m", prevLen, prevCur), style); } if (nextCurveIndex < m_splineBase.CurveCount) { float nextLen = m_splineBase.EvalLength(nextCurveIndex); float nextCur = m_splineBase.EvalCurveLength(nextCurveIndex, GetStepsPerCurve()); Handles.Label(m_splineBase.GetPoint(0.5f, nextCurveIndex), string.Format("Len: {0:0.00} m, Cur: {1:0.00} m", nextLen, nextCur), style); } float cur = m_splineBase.EvalCurveLength(curveIndex, GetStepsPerCurve()); float len = m_splineBase.EvalLength(curveIndex); Handles.Label(m_splineBase.GetPoint(0.5f, curveIndex), string.Format("Len: {0:0.00} m, Cur: {1:0.00} m", len, cur), style); } }
public static Vector3 SnapToWorld(Camera camera, CSGPlane snapPlane, Vector3 unsnappedPosition, Vector3 snappedPosition, ref List <Vector3> snappingEdges, out CSGBrush snappedOnBrush, CSGBrush[] ignoreBrushes = null) { snappedOnBrush = null; test_points[0] = unsnappedPosition; test_points[1] = snappedPosition; worldIntersections.Clear(); for (int i = 0; i < test_points.Length; i++) { var test_point2D = CameraUtility.WorldToGUIPoint(test_points[i]); LegacyBrushIntersection intersection; if (SceneQueryUtility.FindWorldIntersection(camera, test_point2D, out intersection)) { if (intersection.brush && intersection.brush.ControlMesh != null) { intersection.worldIntersection = GeometryUtility.ProjectPointOnPlane(snapPlane, intersection.worldIntersection); worldIntersections.Add(intersection); } } } var old_difference = snappedPosition - unsnappedPosition; var old_difference_magnitude = old_difference.magnitude * 1.5f; Vector3 newSnappedPoint = snappedPosition; CSGPlane?snappingPlane = snapPlane; for (int i = 0; i < worldIntersections.Count; i++) { if (ignoreBrushes != null && ArrayUtility.Contains(ignoreBrushes, worldIntersections[i].brush)) { continue; } List <Vector3> outEdgePoints; Vector3 outPosition; if (GridUtility.SnapToVertices(worldIntersections[i].brush, snappingPlane, unsnappedPosition, out outEdgePoints, out outPosition)) { var new_difference = outPosition - unsnappedPosition; var new_difference_magnitude = new_difference.magnitude; if (new_difference_magnitude <= old_difference_magnitude + MathConstants.EqualityEpsilon) { old_difference_magnitude = new_difference_magnitude; newSnappedPoint = outPosition; snappingEdges = outEdgePoints; snappedOnBrush = worldIntersections[i].brush; } } if (GridUtility.SnapToEdge(camera, worldIntersections[i].brush, snappingPlane ?? worldIntersections[i].worldPlane, worldIntersections[i].worldIntersection, out outEdgePoints, out outPosition)) { var new_difference = outPosition - unsnappedPosition; var new_difference_magnitude = new_difference.magnitude * 1.1f; if (new_difference_magnitude <= old_difference_magnitude + MathConstants.EqualityEpsilon) { old_difference_magnitude = new_difference_magnitude; newSnappedPoint = outPosition; snappingEdges = outEdgePoints; snappedOnBrush = worldIntersections[i].brush; } } } //snappingEdges = FindAllEdgesThatTouchPoint(snappedOnBrush, newSnappedPoint); return(newSnappedPoint); }
public static void Export(CSGModel model, ExportType exportType, bool exportColliders) { string typeName; string extension; switch (exportType) { case ExportType.FBX: typeName = "FBX"; extension = @"fbx"; break; default: //case ExportType.UnityMesh: typeName = "Mesh"; extension = @"prefab"; exportType = ExportType.UnityMesh; break; } var newPath = model.exportPath; if (exportType != ExportType.UnityMesh) { newPath = UnityFBXExporter.ExporterMenu.GetNewPath(model.gameObject, typeName, extension, model.exportPath); if (string.IsNullOrEmpty(newPath)) { return; } } model.ShowGeneratedMeshes = false; var foundModels = model.GetComponentsInChildren <CSGModel>(true); for (var index = 0; index < foundModels.Length; index++) { if (!foundModels[index].ShowGeneratedMeshes) { continue; } foundModels[index].ShowGeneratedMeshes = false; UpdateGeneratedMeshesVisibility(foundModels[index]); } GameObject tempExportObject; if (!string.IsNullOrEmpty(model.exportPath)) { tempExportObject = new GameObject { name = System.IO.Path.GetFileNameWithoutExtension(model.exportPath) }; if (string.IsNullOrEmpty(tempExportObject.name)) { tempExportObject.name = model.name; } } else { tempExportObject = new GameObject { name = model.name } }; tempExportObject.transform.position = MathConstants.zeroVector3; tempExportObject.transform.rotation = MathConstants.identityQuaternion; tempExportObject.transform.localScale = MathConstants.oneVector3; int colliderCounter = 1; int shadowOnlyCounter = 1; var materialMeshCounters = new Dictionary <Material, int>(); var currentScene = model.gameObject.scene; var foundMeshContainers = SceneQueryUtility.GetAllComponentsInScene <GeneratedMeshes>(currentScene); var bounds = new AABB(); bounds.Reset(); var foundMeshFilters = new List <MeshFilter>(); var foundMeshColliders = new List <MeshCollider>(); foreach (var meshContainer in foundMeshContainers) { var owner = meshContainer.owner; if (!owner || !ArrayUtility.Contains(foundModels, owner)) { continue; } if (!meshContainer || meshContainer.meshInstances == null) { continue; } var instances = meshContainer.meshInstances.Values; foreach (var instance in instances) { if (!instance) { continue; } Refresh(instance, model, postProcessScene: true); var surfaceType = GetRenderSurfaceType(owner, instance); if (surfaceType != RenderSurfaceType.Normal && surfaceType != RenderSurfaceType.ShadowOnly && surfaceType != RenderSurfaceType.Collider) { continue; } int counter = 0; if (instance.RenderMaterial) { if (!materialMeshCounters.TryGetValue(instance.RenderMaterial, out counter)) { counter = 1; } else { counter++; } } var mesh = instance.SharedMesh; if (!mesh.isReadable) { //bounds.Extend(mesh.bounds.min); //bounds.Extend(mesh.bounds.max); } else { var vertices = mesh.vertices; for (int v = 0; v < vertices.Length; v++) { bounds.Extend(vertices[v]); } } var subObj = UnityEngine.Object.Instantiate(instance.gameObject, MathConstants.zeroVector3, MathConstants.identityQuaternion) as GameObject; subObj.hideFlags = HideFlags.None; subObj.transform.position = owner.transform.position; subObj.transform.rotation = owner.transform.rotation; subObj.transform.localScale = owner.transform.localScale; subObj.transform.SetParent(tempExportObject.transform, false); var genMeshInstance = subObj.GetComponent <GeneratedMeshInstance>(); UnityEngine.Object.DestroyImmediate(genMeshInstance); if (surfaceType == RenderSurfaceType.Collider) { subObj.name = "no-material (" + colliderCounter + ") COLLIDER"; colliderCounter++; } else { if (surfaceType == RenderSurfaceType.ShadowOnly) { subObj.name = "shadow-only (" + shadowOnlyCounter + ")"; shadowOnlyCounter++; var meshRenderer = subObj.GetComponent <MeshRenderer>(); if (meshRenderer) { meshRenderer.sharedMaterial = AssetDatabase.GetBuiltinExtraResource <Material>("Default-Diffuse.mat"); } } else { subObj.name = instance.RenderMaterial.name + " (" + counter + ")"; counter++; materialMeshCounters[instance.RenderMaterial] = counter; } var meshFilter = subObj.GetComponent <MeshFilter>(); if (meshFilter) { foundMeshFilters.Add(meshFilter); } } var meshCollider = subObj.GetComponent <MeshCollider>(); if (meshCollider) { foundMeshColliders.Add(meshCollider); } } } Undo.IncrementCurrentGroup(); var groupIndex = Undo.GetCurrentGroup(); Undo.SetCurrentGroupName("Exported model"); try { Vector3 position = model.transform.position; if (float.IsInfinity(position.x) || float.IsNaN(position.x)) { position.x = 0; } if (float.IsInfinity(position.y) || float.IsNaN(position.y)) { position.y = 0; } if (float.IsInfinity(position.z) || float.IsNaN(position.z)) { position.z = 0; } Vector3 center = bounds.Center; switch (model.originType) { default: case OriginType.ModelCenter: center = bounds.Center + position; break; case OriginType.ModelPivot: center = position; break; case OriginType.WorldSpace: center = Vector3.zero; break; } if (float.IsInfinity(center.x) || float.IsNaN(center.x)) { center.x = 0; } if (float.IsInfinity(center.y) || float.IsNaN(center.y)) { center.y = 0; } if (float.IsInfinity(center.z) || float.IsNaN(center.z)) { center.z = 0; } var modifiedMeshes = new Dictionary <Mesh, Mesh>(); foreach (var meshFilter in foundMeshFilters) { var mesh = meshFilter.sharedMesh; if (!mesh.isReadable) { continue; } Mesh newMesh; if (!modifiedMeshes.TryGetValue(mesh, out newMesh)) { newMesh = (Mesh)UnityEngine.Object.Instantiate(mesh); var vertices = mesh.vertices; for (int v = 0; v < vertices.Length; v++) { vertices[v] += position; vertices[v] -= center; } newMesh.vertices = vertices; modifiedMeshes[mesh] = newMesh; } meshFilter.sharedMesh = newMesh; meshFilter.transform.position = Vector3.zero; } foreach (var meshCollider in foundMeshColliders) { var mesh = meshCollider.sharedMesh; if (!mesh.isReadable) { continue; } Mesh newMesh; if (!modifiedMeshes.TryGetValue(mesh, out newMesh)) { newMesh = (Mesh)UnityEngine.Object.Instantiate(mesh); var vertices = mesh.vertices; for (int v = 0; v < vertices.Length; v++) { vertices[v] += position; vertices[v] -= center; } newMesh.vertices = vertices; modifiedMeshes[mesh] = newMesh; } meshCollider.sharedMesh = newMesh; meshCollider.transform.position = Vector3.zero; } UnityEngine.Object obj; GameObject modelGameObject; switch (exportType) { case ExportType.FBX: { if (!UnityFBXExporter.FBXExporter.ExportGameObjToFBX(tempExportObject, newPath, exportColliders: exportColliders)) { //InternalCSGModelManager.ClearMeshInstances(); EditorUtility.DisplayDialog("Warning", "Failed to export the FBX file.", "Ok"); return; } obj = AssetDatabase.LoadAssetAtPath <UnityEngine.Object>(newPath); modelGameObject = PrefabUtility.InstantiatePrefab(obj) as GameObject; foreach (var renderer in modelGameObject.GetComponentsInChildren <MeshRenderer>()) { var gameObject = renderer.gameObject; if (gameObject.name.EndsWith("COLLIDER")) { var filter = gameObject.GetComponent <MeshFilter>(); var meshCollider = gameObject.AddComponent <MeshCollider>(); meshCollider.sharedMesh = filter.sharedMesh; UnityEngine.Object.DestroyImmediate(renderer); UnityEngine.Object.DestroyImmediate(filter); } } model.exportPath = newPath; break; } default: //case ExportType.UnityMesh: { //PrefabUtility.CreatePrefab(newPath, tempExportObject, ReplacePrefabOptions.Default); obj = tempExportObject; // AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(newPath); modelGameObject = tempExportObject; foreach (var meshFilter in tempExportObject.GetComponentsInChildren <MeshFilter>()) { var mesh = meshFilter.sharedMesh; mesh.name = tempExportObject.name; meshFilter.mesh = mesh; } break; } } var prefabObj = obj as GameObject; model.exportPath = newPath; if (exportType == ExportType.FBX && prefabObj) { foreach (var meshRenderer in prefabObj.GetComponentsInChildren <MeshRenderer>()) { if (meshRenderer.sharedMaterials.Length != 1) { continue; } var gameObject = meshRenderer.gameObject; var nameSplit = gameObject.name.Split('|'); if (nameSplit.Length == 1) { continue; } int instanceId; if (!int.TryParse(nameSplit[1], out instanceId)) { continue; } var realMaterial = EditorUtility.InstanceIDToObject(instanceId) as Material; if (!realMaterial) { continue; } meshRenderer.sharedMaterial = realMaterial; gameObject.name = nameSplit[0]; } } var staticFlags = GameObjectUtility.GetStaticEditorFlags(model.gameObject); var modelLayer = model.gameObject.layer; foreach (var transform in modelGameObject.GetComponentsInChildren <Transform>()) { var gameObject = transform.gameObject; GameObjectUtility.SetStaticEditorFlags(gameObject, staticFlags); gameObject.layer = modelLayer; } modelGameObject.transform.SetParent(model.transform, true); modelGameObject.transform.SetSiblingIndex(0); modelGameObject.tag = model.gameObject.tag; modelGameObject.transform.localPosition = center - position; Undo.RegisterCreatedObjectUndo(modelGameObject, "Instantiated model"); var exported = model.gameObject.AddComponent <CSGModelExported>(); exported.containedModel = null; exported.containedExportedModel = modelGameObject; exported.disarm = true; Undo.RegisterCreatedObjectUndo(exported, "Created CSGModelExported"); Undo.RegisterCompleteObjectUndo(exported, "Created CSGModelExported"); var foundBrushes = model.GetComponentsInChildren <CSGBrush>(true); var foundOperations = model.GetComponentsInChildren <CSGOperation>(true); var foundContainers = model.GetComponentsInChildren <GeneratedMeshes>(true); var foundBehaviours = new HashSet <MonoBehaviour>(); foreach (var foundBrush in foundBrushes) { foundBehaviours.Add(foundBrush); } foreach (var foundOperation in foundOperations) { foundBehaviours.Add(foundOperation); } foreach (var foundModel in foundModels) { foundBehaviours.Add(foundModel); } foreach (var foundContainer in foundContainers) { foundBehaviours.Add(foundContainer); } exported.hiddenComponents = new HiddenComponentData[foundBehaviours.Count]; var index = 0; foreach (var foundBehaviour in foundBehaviours) { Undo.RegisterCompleteObjectUndo(foundBehaviour, "Hide component"); exported.hiddenComponents[index] = new HiddenComponentData { behaviour = foundBehaviour }; index++; } for (var i = 0; i < exported.hiddenComponents.Length; i++) { exported.hiddenComponents[i].hideFlags = exported.hiddenComponents[i].behaviour.hideFlags; exported.hiddenComponents[i].enabled = exported.hiddenComponents[i].behaviour.enabled; } for (var i = 0; i < exported.hiddenComponents.Length; i++) { exported.hiddenComponents[i].behaviour.hideFlags = exported.hiddenComponents[i].behaviour.hideFlags | ComponentHideFlags; exported.hiddenComponents[i].behaviour.enabled = false; } EditorSceneManager.MarkSceneDirty(currentScene); Undo.CollapseUndoOperations(groupIndex); groupIndex = 0; exported.disarm = false; } finally { switch (exportType) { case ExportType.FBX: { UnityEngine.Object.DestroyImmediate(tempExportObject); break; } } if (groupIndex != 0) { Undo.CollapseUndoOperations(groupIndex); } } }
//This is for curves that are tracked slightly differently from regular curves: Active curve and Z-index curve private void SetAdditionalCurves(Transform child, MainLineKey[] keys, TimeLine timeLine, AnimationClip clip, float defaultZ) { var positionChanged = false; var kfsZ = new List <Keyframe> (); var changedZ = false; var active = child.gameObject.activeSelf; //If the sprite or bone isn't present in the mainline, var kfsActive = new List <Keyframe> (); //Disable the GameObject if it isn't already disabled var childPath = GetPathToChild(child); foreach (var key in keys) //If it is present, enable the GameObject if it isn't already enabled { var mref = ArrayUtility.Find(key.objectRefs, x => x.timeline == timeLine.id); if (mref != null) { if (defaultZ == inf) { defaultZ = mref.z_index; positionChanged = true; } if (!changedZ && mref.z_index != defaultZ) { changedZ = true; if (key.time > 0) { kfsZ.Add(new Keyframe(0f, defaultZ, inf, inf)); } } if (changedZ) { kfsZ.Add(new Keyframe(key.time, mref.z_index, inf, inf)); } if (!active) { if (kfsActive.Count <= 0 && key.time > 0) { kfsActive.Add(new Keyframe(0f, 0f, inf, inf)); } kfsActive.Add(new Keyframe(key.time, 1f, inf, inf)); active = true; } } else if (active) { if (kfsActive.Count <= 0 && key.time > 0) { kfsActive.Add(new Keyframe(0f, 1f, inf, inf)); } kfsActive.Add(new Keyframe(key.time, 0f, inf, inf)); active = false; } } //Only add these curves if there is actually a mutation if (kfsZ.Count > 0) { clip.SetCurve(childPath, typeof(Transform), "localPosition.z", new AnimationCurve(kfsZ.ToArray())); if (!positionChanged) { var info = timeLine.keys [0].info; //If these curves don't actually exist, add some empty ones clip.SetCurve(childPath, typeof(Transform), "localPosition.x", new AnimationCurve(new Keyframe(0f, info.x))); clip.SetCurve(childPath, typeof(Transform), "localPosition.y", new AnimationCurve(new Keyframe(0f, info.y))); } } if (kfsActive.Count > 0) { clip.SetCurve(childPath, typeof(GameObject), "m_IsActive", new AnimationCurve(kfsActive.ToArray())); } }
/// <summary> /// Insert a number of new points to each edge. Points are evenly spaced out along the edge. /// </summary> /// <param name="mesh">The source mesh.</param> /// <param name="edges">The edges to split with points.</param> /// <param name="count">The number of new points to insert. Must be greater than 0.</param> /// <returns>The new edges created by inserting points.</returns> public static List <Edge> AppendVerticesToEdge(this ProBuilderMesh mesh, IList <Edge> edges, int count) { if (mesh == null) { throw new ArgumentNullException("mesh"); } if (edges == null) { throw new ArgumentNullException("edges"); } if (count < 1 || count > 512) { Log.Error("New edge vertex count is less than 1 or greater than 512."); return(null); } List <Vertex> vertices = new List <Vertex>(mesh.GetVertices()); Dictionary <int, int> lookup = mesh.sharedVertexLookup; Dictionary <int, int> lookupUV = mesh.sharedTextureLookup; List <int> indexesToDelete = new List <int>(); IEnumerable <Edge> commonEdges = EdgeUtility.GetSharedVertexHandleEdges(mesh, edges); List <Edge> distinctEdges = commonEdges.Distinct().ToList(); Dictionary <Face, FaceRebuildData> modifiedFaces = new Dictionary <Face, FaceRebuildData>(); int originalSharedIndexesCount = lookup.Count(); int sharedIndexesCount = originalSharedIndexesCount; foreach (Edge edge in distinctEdges) { Edge localEdge = EdgeUtility.GetEdgeWithSharedVertexHandles(mesh, edge); // Generate the new vertices that will be inserted on this edge List <Vertex> verticesToAppend = new List <Vertex>(count); for (int i = 0; i < count; i++) { verticesToAppend.Add(Vertex.Mix(vertices[localEdge.a], vertices[localEdge.b], (i + 1) / ((float)count + 1))); } List <SimpleTuple <Face, Edge> > adjacentFaces = ElementSelection.GetNeighborFaces(mesh, localEdge); // foreach face attached to common edge, append vertices foreach (SimpleTuple <Face, Edge> tup in adjacentFaces) { Face face = tup.item1; FaceRebuildData data; if (!modifiedFaces.TryGetValue(face, out data)) { data = new FaceRebuildData(); data.face = new Face(new int[0], face.submeshIndex, new AutoUnwrapSettings(face.uv), face.smoothingGroup, face.textureGroup, -1, face.manualUV); data.vertices = new List <Vertex>(ArrayUtility.ValuesWithIndexes(vertices, face.distinctIndexesInternal)); data.sharedIndexes = new List <int>(); data.sharedIndexesUV = new List <int>(); foreach (int i in face.distinctIndexesInternal) { int shared; if (lookup.TryGetValue(i, out shared)) { data.sharedIndexes.Add(shared); } if (lookupUV.TryGetValue(i, out shared)) { data.sharedIndexesUV.Add(shared); } } indexesToDelete.AddRange(face.distinctIndexesInternal); modifiedFaces.Add(face, data); } data.vertices.AddRange(verticesToAppend); for (int i = 0; i < count; i++) { data.sharedIndexes.Add(sharedIndexesCount + i); data.sharedIndexesUV.Add(-1); } } sharedIndexesCount += count; } // now apply the changes List <Face> dic_face = modifiedFaces.Keys.ToList(); List <FaceRebuildData> dic_data = modifiedFaces.Values.ToList(); List <EdgeLookup> appendedEdges = new List <EdgeLookup>(); for (int i = 0; i < dic_face.Count; i++) { Face face = dic_face[i]; FaceRebuildData data = dic_data[i]; Vector3 nrm = Math.Normal(mesh, face); Vector2[] projection = Projection.PlanarProject(data.vertices.Select(x => x.position).ToArray(), null, nrm); int vertexCount = vertices.Count; // triangulate and set new face indexes to end of current vertex list List <int> indexes; if (Triangulation.SortAndTriangulate(projection, out indexes)) { data.face.indexesInternal = indexes.ToArray(); } else { continue; } data.face.ShiftIndexes(vertexCount); face.CopyFrom(data.face); for (int n = 0; n < data.vertices.Count; n++) { lookup.Add(vertexCount + n, data.sharedIndexes[n]); } if (data.sharedIndexesUV.Count == data.vertices.Count) { for (int n = 0; n < data.vertices.Count; n++) { lookupUV.Add(vertexCount + n, data.sharedIndexesUV[n]); } } vertices.AddRange(data.vertices); foreach (Edge e in face.edgesInternal) { EdgeLookup el = new EdgeLookup(new Edge(lookup[e.a], lookup[e.b]), e); if (el.common.a >= originalSharedIndexesCount || el.common.b >= originalSharedIndexesCount) { appendedEdges.Add(el); } } } indexesToDelete = indexesToDelete.Distinct().ToList(); int delCount = indexesToDelete.Count; var newEdges = appendedEdges.Distinct().Select(x => x.local - delCount).ToList(); mesh.SetVertices(vertices); mesh.SetSharedVertices(lookup); mesh.SetSharedTextures(lookupUV); mesh.DeleteVertices(indexesToDelete); return(newEdges); }
public override void OnInspectorGUI() { Tapestry_Item i = target as Tapestry_Item; if (startup) { if (!ReferenceEquals(i.data.effect, null)) { if (!ReferenceEquals(i.data.effect.payload, null)) { pSel = ArrayUtility.IndexOf(Tapestry_Config.GetPayloadTypes().Values.ToArray(), i.data.effect.payload.GetType()); } } else { pSel = 0; } startup = false; } string displayTooltip = "What string will display on the player's HUD when looking at this object.", prefabTooltip = "What is the name of the prefab (placed in the Resources/Items folder) that should be instantiated when this object is dropped in world?\n\nGenerally this should be the object's in-world name, rather than its display name.", interactableTooltip = "Can the player take this object to their inventory?", displayNameTooltip = "Should the object still show its display name when the player's cursor is hovering over the object?", valueTooltip = "How valuable is this object?"; GUILayout.BeginVertical("box"); GUILayout.BeginHorizontal(); GUILayout.Label(new GUIContent("Display Name", displayTooltip)); GUILayout.FlexibleSpace(); i.displayName = EditorGUILayout.DelayedTextField(i.displayName, GUILayout.Width(270)); i.data.displayName = i.displayName; GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); GUILayout.Label(new GUIContent("Prefab Name", prefabTooltip)); GUILayout.FlexibleSpace(); i.data.prefabName = EditorGUILayout.DelayedTextField(i.data.prefabName, GUILayout.Width(270)); GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); i.isInteractable = EditorGUILayout.Toggle(i.isInteractable, GUILayout.Width(12)); GUILayout.Label(new GUIContent("Takeable?", interactableTooltip)); GUILayout.Space(20); if (!i.isInteractable) { i.displayNameWhenUnactivatable = EditorGUILayout.Toggle(i.displayNameWhenUnactivatable, GUILayout.Width(12)); GUILayout.Label(new GUIContent("Display Name Anyway?", displayNameTooltip)); GUILayout.FlexibleSpace(); } GUILayout.FlexibleSpace(); GUILayout.Label(new GUIContent("Value", valueTooltip)); i.data.value = EditorGUILayout.DelayedIntField(i.data.value, GUILayout.Width(50)); GUILayout.EndHorizontal(); GUILayout.EndVertical(); DrawSubTabItemData(i); DrawSubTabEffect(i); DrawSubTabKeywords(i); }
public override void UpdateCurveWrappers(CinemaClipCurveWrapper clipWrapper) { CinemaMultiActorCurveClip clipCurve = clipWrapper.Behaviour as CinemaMultiActorCurveClip; if (clipCurve == null) { return; } for (int i = 0; i < clipCurve.CurveData.Count; i++) { MemberClipCurveData member = clipCurve.CurveData[i]; CinemaMemberCurveWrapper memberWrapper = null; if (!clipWrapper.TryGetValue(member.PropertyType.ToString(), member.PropertyName, out memberWrapper)) { memberWrapper = new CinemaMemberCurveWrapper(); memberWrapper.Type = member.PropertyType.ToString(); memberWrapper.PropertyName = member.PropertyName; memberWrapper.Texture = EditorGUIUtility.ObjectContent(null, UnityPropertyTypeInfo.GetUnityType(member.Type)).image; ArrayUtility.Add <CinemaMemberCurveWrapper>(ref clipWrapper.MemberCurves, memberWrapper); int showingCurves = UnityPropertyTypeInfo.GetCurveCount(member.PropertyType); memberWrapper.AnimationCurves = new CinemaAnimationCurveWrapper[showingCurves]; for (int j = 0; j < showingCurves; j++) { memberWrapper.AnimationCurves[j] = new CinemaAnimationCurveWrapper(); memberWrapper.AnimationCurves[j].Id = j; memberWrapper.AnimationCurves[j].Curve = new AnimationCurve(member.GetCurve(j).keys); memberWrapper.AnimationCurves[j].Color = UnityPropertyTypeInfo.GetCurveColor(j); memberWrapper.AnimationCurves[j].Label = UnityPropertyTypeInfo.GetCurveName(member.PropertyType, j); } } else { int showingCurves = UnityPropertyTypeInfo.GetCurveCount(member.PropertyType); for (int j = 0; j < showingCurves; j++) { memberWrapper.AnimationCurves[j].Curve = new AnimationCurve(member.GetCurve(j).keys); } } } // Remove missing track items List <CinemaMemberCurveWrapper> itemRemovals = new List <CinemaMemberCurveWrapper>(); for (int i = 0; i < clipWrapper.MemberCurves.Length; i++) { CinemaMemberCurveWrapper cw = clipWrapper.MemberCurves[i]; bool found = false; for (int j = 0; j < clipCurve.CurveData.Count; j++) { MemberClipCurveData member = clipCurve.CurveData[j]; if (member.PropertyType.ToString() == cw.Type && member.PropertyName == cw.PropertyName) { found = true; break; } } if (!found) { itemRemovals.Add(cw); } } for (int i = 0; i < itemRemovals.Count; i++) { ArrayUtility.Remove <CinemaMemberCurveWrapper>(ref clipWrapper.MemberCurves, itemRemovals[i]); } }
/// <summary> /// Append a new face to the ProBuilderMesh. /// </summary> /// <param name="mesh">The mesh target.</param> /// <param name="positions">The new vertex positions to add.</param> /// <param name="colors">The new colors to add (must match positions length).</param> /// <param name="uvs">The new uvs to add (must match positions length).</param> /// <param name="face">A face with the new triangle indexes. The indexes should be 0 indexed.</param> /// <param name="common"></param> /// <returns>The new face as referenced on the mesh.</returns> internal static Face AppendFace(this ProBuilderMesh mesh, Vector3[] positions, Color[] colors, Vector2[] uvs, Face face, int[] common) { if (mesh == null) { throw new ArgumentNullException("mesh"); } if (positions == null) { throw new ArgumentNullException("positions"); } if (face == null) { throw new ArgumentNullException("face"); } int faceVertexCount = positions.Length; if (common == null) { common = new int[faceVertexCount]; for (int i = 0; i < faceVertexCount; i++) { common[i] = -1; } } int vertexCount = mesh.vertexCount; var mc = mesh.HasArrays(MeshArrays.Color); var fc = colors != null; var mt = mesh.HasArrays(MeshArrays.Texture0); var ft = uvs != null; Vector3[] newPositions = new Vector3[vertexCount + faceVertexCount]; Color[] newColors = (mc || fc) ? new Color[vertexCount + faceVertexCount] : null; Vector2[] newTextures = (mt || ft) ? new Vector2[vertexCount + faceVertexCount] : null; List <Face> faces = new List <Face>(mesh.facesInternal); Array.Copy(mesh.positionsInternal, 0, newPositions, 0, vertexCount); Array.Copy(positions, 0, newPositions, vertexCount, faceVertexCount); if (mc || fc) { Array.Copy(mc ? mesh.colorsInternal : ArrayUtility.Fill(Color.white, vertexCount), 0, newColors, 0, vertexCount); Array.Copy(fc ? colors : ArrayUtility.Fill(Color.white, faceVertexCount), 0, newColors, vertexCount, colors.Length); } if (mt || ft) { Array.Copy(mt ? mesh.texturesInternal : ArrayUtility.Fill(Vector2.zero, vertexCount), 0, newTextures, 0, vertexCount); Array.Copy(ft ? uvs : ArrayUtility.Fill(Vector2.zero, faceVertexCount), 0, newTextures, mesh.texturesInternal.Length, faceVertexCount); } face.ShiftIndexesToZero(); face.ShiftIndexes(vertexCount); faces.Add(face); for (int i = 0; i < common.Length; i++) { if (common[i] < 0) { mesh.AddSharedVertex(new SharedVertex(new int[] { i + vertexCount })); } else { mesh.AddToSharedVertex(common[i], i + vertexCount); } } mesh.positions = newPositions; mesh.colors = newColors; mesh.textures = newTextures; mesh.faces = faces; return(face); }
public void UpdateMesh(ControlMesh controlMesh, Vector3[] vertices = null) { if (controlMesh == null || controlMesh.Vertices == null || controlMesh.Edges == null || controlMesh.Polygons == null || PolygonPointIndices == null) { return; } if (vertices == null) { vertices = controlMesh.Vertices; } if (!BrushTransform) { return; } var pointCount = vertices.Length; if (WorldPoints.Length != pointCount) { AllocatePoints(pointCount); } var edgeCount = controlMesh.Edges.Length; if (Edges.Length != edgeCount) { AllocateEdges(edgeCount); } var polygonCount = controlMesh.Polygons.Length; if (PolygonControlId.Length != polygonCount) { AllocatePolygons(polygonCount); } var index = 0; for (var e = 0; e < edgeCount; e++) { if (e >= controlMesh.Edges.Length || index >= Edges.Length) { continue; } var twin = controlMesh.Edges[e].TwinIndex; if (twin < e || // if it's less than e then we've already handled our twin twin >= controlMesh.Edges.Length) { continue; } var polygonIndex = controlMesh.Edges[e].PolygonIndex; if (polygonIndex < 0 || polygonIndex >= controlMesh.Polygons.Length) { continue; } var twinPolygonIndex = controlMesh.Edges[twin].PolygonIndex; if (twinPolygonIndex < 0 || twinPolygonIndex >= controlMesh.Polygons.Length) { continue; } var vertexIndex1 = controlMesh.Edges[e].VertexIndex; var vertexIndex2 = controlMesh.Edges[twin].VertexIndex; if (vertexIndex1 < 0 || vertexIndex1 >= Selection.Points.Length || vertexIndex2 < 0 || vertexIndex2 >= Selection.Points.Length) { continue; } Edges[index] = vertexIndex1; Edges[index + 1] = vertexIndex2; EdgeStateToHalfEdge[index / 2] = e; HalfEdgeToEdgeStates[e] = index; HalfEdgeToEdgeStates[twin] = index; EdgeSurfaces[index] = polygonIndex; EdgeSurfaces[index + 1] = twinPolygonIndex; /* * if ((Selection.Points[vertexIndex1] & SelectState.Selected) == SelectState.Selected && * (Selection.Points[vertexIndex2] & SelectState.Selected) == SelectState.Selected) * Selection.Edges[index / 2] |= SelectState.Selected; * else * Selection.Edges[index / 2] &= ~SelectState.Selected; */ //edgeSelectState[index / 2] = SelectState.None; index += 2; } var polygonCountModified = false; while (polygonCount > PolygonPointIndices.Length) { ArrayUtility.Add(ref PolygonPointIndices, null); polygonCountModified = true; } while (polygonCount < PolygonPointIndices.Length) { ArrayUtility.RemoveAt(ref PolygonPointIndices, PolygonPointIndices.Length - 1); polygonCountModified = true; } if (polygonCountModified) { for (var i = 0; i < polygonCount; i++) { PolygonPointIndices[i] = null; } } UpdatePoints(controlMesh, vertices); }
public void OnPropertyDelete(CustomPropertyInfo property) { ArrayUtility.Remove <CustomPropertyInfo> (ref selectedProperties, property); SaveCurrentType(); CachePropertiesDrawer(); }
static public bool IsViewModelExisted(string name) { return(ArrayUtility.Contains(types, name)); }
private static async Task RegisterAsync(string lastName, string firstName, string username, byte[] password, Role role) { byte[] bytes = Encoding.UTF8.GetBytes("LastName=" + lastName + "&FirstName=" + firstName + "&Username="******"&Password="******"Role error"); } Array.Clear(bytes, 0, bytes.Length); Array.Clear(parameters, 0, parameters.Length); content.Dispose(); if (status == 200) { if (!String.Equals(body, "Success")) { if (body.Contains("exists")) { throw new UserExistsException(body); } else { throw new Exception("Message contents could not be parsed."); } } } else if (status == 400) { throw new Exception(body); } else if (status == 500) { throw new ServerException(); } else { throw new Exception("An error occurred"); } }
public static bool FindClickWorldIntersection(Vector2 screenPos, out GameObject foundObject) { var sceneView = SceneView.currentDrawingSceneView ? SceneView.currentDrawingSceneView : SceneView.lastActiveSceneView; var camera = sceneView ? sceneView.camera : Camera.current; foundObject = null; if (!camera) { return(false); } var worldRay = HandleUtility.GUIPointToWorldRay(screenPos); var rayStart = worldRay.origin; var rayVector = (worldRay.direction * (camera.farClipPlane - camera.nearClipPlane)); var rayEnd = rayStart + rayVector; CSGModel intersectionModel = null; if (_prevSceenPos == screenPos && _prevSceneView == sceneView && _deepClickIntersections != null) { var prevIntersection = (_deepIndex > 0 && _deepIndex < _deepClickIntersections.Length) ? _deepClickIntersections[_deepIndex] : null; if (_deepClickIntersections.Length > 1) { for (var i = _deepClickIntersections.Length - 1; i >= 0; i--) { if (_deepClickIntersections[i].brush) { continue; } ArrayUtility.RemoveAt(ref _deepClickIntersections, i); if (i <= _deepIndex) { _deepIndex--; } } } if (_deepClickIntersections.Length <= 1) { ResetDeepClick(); } else { _deepIndex = (_deepIndex + 1) % _deepClickIntersections.Length; var currentIntersection = (_deepIndex > 0 && _deepIndex < _deepClickIntersections.Length) ? _deepClickIntersections[_deepIndex] : null; if (currentIntersection != prevIntersection && currentIntersection != null) { foundObject = currentIntersection.gameObject; _prevSceenPos = screenPos; _prevSceneView = sceneView; intersectionModel = currentIntersection.model; } else { ResetDeepClick(); } } } if (_prevSceenPos != screenPos) { var wireframeShown = CSGSettings.IsWireframeShown(sceneView); if (FindMultiWorldIntersection(rayStart, rayEnd, out _deepClickIntersections, growDistance: 0, ignoreInvisibleSurfaces: !wireframeShown, ignoreUnrenderables: !wireframeShown)) { _deepIndex = 0; var intersection = _deepClickIntersections[0]; foundObject = intersection.gameObject; _prevSceenPos = screenPos; _prevSceneView = sceneView; intersectionModel = intersection.model; } else { ResetDeepClick(); } } GameObject[] modelMeshes = null; if (intersectionModel != null) { modelMeshes = CSGModelManager.GetModelMeshes(intersectionModel); } if (modelMeshes != null) { for (var i = 0; i < modelMeshes.Length; i++) { modelMeshes[i].hideFlags = HideFlags.None; } } var gameObject = HandleUtility.PickGameObject(screenPos, false); if (modelMeshes != null) { for (var i = 0; i < modelMeshes.Length; i++) { var modelMesh = modelMeshes[i]; if (!modelMesh) { continue; } if (gameObject == modelMesh) { gameObject = null; } modelMesh.hideFlags = MeshInstanceManager.ComponentHideFlags; } } if (!gameObject || gameObject.GetComponent <CSGModel>() || gameObject.GetComponent <CSGBrush>() || gameObject.GetComponent <CSGOperation>() || gameObject.GetComponent <GeneratedMeshInstance>() || gameObject.GetComponent <GeneratedMeshes>()) { return(foundObject != null); } foundObject = gameObject; return(true); }
/// <summary> /// Decode KILE PDUs from received message bytes /// </summary> /// <param name="endPoint">An endpoint from which the message bytes are received</param> /// <param name="receivedBytes">The received bytes to be decoded</param> /// <param name="consumedLength">Length of message bytes consumed by decoder</param> /// <param name="expectedLength">Length of message bytes the decoder expects to receive</param> /// <returns>The decoded KILE PDUs</returns> /// <exception cref="System.FormatException">thrown when a kile message type is unsupported</exception> internal KilePdu[] DecodePacketCallback(object endPoint, byte[] receivedBytes, out int consumedLength, out int expectedLength) { // initialize lengths consumedLength = 0; expectedLength = 0; if (null == receivedBytes || 0 == receivedBytes.Length) { return(null); } if (!isClientRole) { serverContext = null; if (serverContextList != null) { KileConnection kileConnection = new KileConnection((IPEndPoint)endPoint); if (!serverContextList.ContainsKey(kileConnection)) { serverContext = new KileServerContext(); serverContext.TransportType = connectionType; serverContextList.Add(kileConnection, serverContext); } else { serverContext = serverContextList[kileConnection]; } } if (serverContext == null) { throw new InvalidOperationException("The kileConnection related context does not exist."); } } // TCP has a 4 bytes length header, while UDP has not byte[] pduBytes = receivedBytes; if ((isClientRole && clientContext.TransportType == KileConnectionType.TCP) || (!isClientRole && serverContext.TransportType == KileConnectionType.TCP)) { // insufficient data, needs to receive more if (receivedBytes.Length < sizeof(int)) { return(null); } // get pdu data length byte[] lengthBytes = ArrayUtility.SubArray(receivedBytes, 0, sizeof(int)); Array.Reverse(lengthBytes); int pduLength = BitConverter.ToInt32(lengthBytes, 0); // insufficient data, needs to receive more expectedLength = sizeof(int) + pduLength; if (receivedBytes.Length < expectedLength) { return(null); } // check if it is a krb zero message if (pduLength == 0 && receivedBytes.Length == sizeof(int)) { consumedLength = sizeof(int); KrbZero krbZeroPdu = new KrbZero(clientContext); return(new KilePdu[] { krbZeroPdu }); } // remove length header from pdu bytes pduBytes = ArrayUtility.SubArray <byte>(receivedBytes, sizeof(int), pduLength); } else { // UDP has no length header expectedLength = pduBytes.Length; } // get message type // (the lower 5 bits indicates its kile message type) MsgType kileMessageType = (MsgType)(pduBytes[0] & 0x1f); // decode according to message type consumedLength = expectedLength; KilePdu pdu = null; switch (kileMessageType) { case MsgType.KRB_AS_REQ: pdu = new KileAsRequest(serverContext); break; case MsgType.KRB_AS_RESP: pdu = new KileAsResponse(clientContext); break; case MsgType.KRB_TGS_REQ: pdu = new KileTgsRequest(serverContext); break; case MsgType.KRB_TGS_RESP: pdu = new KileTgsResponse(clientContext); break; case MsgType.KRB_ERROR: pdu = new KileKrbError(); break; default: throw new FormatException( "Unsupported Message Type: " + kileMessageType.ToString()); } pdu.FromBytes(pduBytes); // update context if (isClientRole) { clientContext.UpdateContext(pdu); } else { serverContext.UpdateContext(pdu); } return(new KilePdu[] { pdu }); }
internal static bool IsFormatRequireCompressionSetting(TextureImporterFormat format) { return(ArrayUtility.Contains <TextureImporterFormat>(TexturePlatformSettingsModal.kFormatsWithCompressionSettings, format)); }
/* if (!Application.isPlaying) * El OnInspectorGUI y OnSceneGUI usan esta condicion porque hay ciertas * cosas del PlatformController que se inicializan en el Start, por lo que * si se pretende cambiar algo en el inspector o desde la escena mientras * esta en modo juego no va a funcionar bien. */ public override void OnInspectorGUI() { #region VELOCIDAD DE LA PLATAFORMA EditorGUI.BeginChangeCheck(); float speed = m_PlatformController.m_speed; speed = EditorGUILayout.FloatField("Velocidad", speed); if (speed < 0) { speed = 0; } if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(target, "changed speed"); m_PlatformController.m_speed = speed; } #endregion if (!Application.isPlaying) { #region EN QUE NODO EMPIEZA EditorGUI.BeginChangeCheck(); int begin = m_PlatformController.m_button; begin = EditorGUILayout.IntField("Empieza en", begin); if (begin > (m_PlatformController.localNodes.Length - 1)) { begin = m_PlatformController.localNodes.Length - 1; } else if (begin < 0) { begin = 0; } if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(target, "changed where it begins"); m_PlatformController.m_button = begin; for (int i = 0; i < m_PlatformController.localNodes.Length; ++i) { if (i != begin) { m_PlatformController.localNodes[i] -= m_PlatformController.localNodes[begin]; } } m_PlatformController.transform.position = m_PlatformController.transform.TransformPoint(m_PlatformController.localNodes[begin]); m_PlatformController.localNodes[begin] = Vector3.zero; } #endregion #region NODOS if (GUILayout.Button("Add Node")) // Crea el boton 'Add Node' { Undo.RecordObject(target, "added node"); // Guarda los cambios que se realicen a continuacion Vector3 position = m_PlatformController.localNodes[m_PlatformController.localNodes.Length - 1] + Vector3.right; // posicion del ultimo nodo ArrayUtility.Add(ref m_PlatformController.localNodes, position); // Anyade un nuevo nodo al array en la posicion 'position' } EditorGUIUtility.labelWidth = 64; int delete = -1; // Muestra y modifica la posicion de los nodos for (int i = 0; i < m_PlatformController.localNodes.Length; ++i) { EditorGUI.BeginChangeCheck(); EditorGUILayout.BeginHorizontal(); // HORIZONTAL int size = 64; EditorGUILayout.BeginVertical(GUILayout.Width(size)); // Crea menu desplegable? EditorGUILayout.LabelField("Node " + i, GUILayout.Width(size)); // Enumeracion de los nodos if ((i != 0) && (GUILayout.Button("Delete", GUILayout.Width(size)))) // Boton para eliminar un nodo (excepto el primero) { // !BOTON! No implementa aqui la eliminacion delete = i; } EditorGUILayout.EndVertical(); EditorGUILayout.BeginVertical(); // Muestra la posicion (x,y) de cada nuevo nodo Vector2 newPosition; // (excepto el primero que esta fijo) newPosition = EditorGUILayout.Vector2Field("Position", m_PlatformController.transform.TransformPoint(m_PlatformController.localNodes[i])); EditorGUILayout.EndVertical(); EditorGUILayout.EndHorizontal(); // HORIZONTAL: todo esto se escribe en una sola linea if (EditorGUI.EndChangeCheck()) { Undo.RecordObject(target, "changed position"); m_PlatformController.localNodes[i] = m_PlatformController.transform.InverseTransformPoint(newPosition); // Guarda la nueva posicion asignada } } EditorGUIUtility.labelWidth = 0; if (delete != -1) { Undo.RecordObject(target, "Removed node"); // Elimina un nodo ArrayUtility.RemoveAt(ref m_PlatformController.localNodes, delete); } #endregion } }
public override void OnGUI(Rect pos, SerializedProperty prop, GUIContent label) { if (!attributeScanned) { attributeScanned = true; // check for EventTargetVariable Attribute object[] _evenTargets = this.fieldInfo.GetCustomAttributes(typeof(EventTargetVariable), true); if (_evenTargets.Length > 0) { string variableName = (_evenTargets[0] as EventTargetVariable).variable; eventTargetVariable = prop.serializedObject.FindProperty(variableName); } /// check for the ShowOptions attribute object[] _showOptions = this.fieldInfo.GetCustomAttributes(typeof(ShowOptions), true); if (_showOptions.Length > 0) { showOptions = true; } } if (eventTargetVariable != null) { eventTarget = eventTargetVariable.FindPropertyRelative("eventTarget"); includeChildren = eventTargetVariable.FindPropertyRelative("includeChildren"); gameObject = eventTargetVariable.FindPropertyRelative("gameObject"); fsmComponent = eventTargetVariable.FindPropertyRelative("fsmComponent"); } eventName = prop.FindPropertyRelative("eventName"); string _eventName = eventName.stringValue; allowLocalEvents = prop.FindPropertyRelative("allowLocalEvents"); bool _allowEvent = allowLocalEvents.boolValue; defaultEventName = prop.FindPropertyRelative("defaultEventName"); defaultEventNameValue = defaultEventName.stringValue; CacheOwnerGameObject(prop.serializedObject); int row = 0; string[] _eventList = new string[0]; bool isEventImplemented = false; // Get the list of events if (eventTarget == null || eventTarget.enumValueIndex == 2) // Undefined || broadcastAll { _eventList = PlayMakerInspectorUtils.GetGlobalEvents(true); } else if (eventTarget.enumValueIndex == 0 || eventTarget.enumValueIndex == 1) // Owner || GameObject { _eventList = PlayMakerInspectorUtils.GetGlobalEvents(true); isEventImplemented = PlayMakerInspectorUtils.DoesTargetImplementsEvent((GameObject)gameObject.objectReferenceValue, _eventName, true); } else if (eventTarget.enumValueIndex == 3) // FsmComponent { PlayMakerFSM _fsm = (PlayMakerFSM)fsmComponent.objectReferenceValue; _eventList = PlayMakerInspectorUtils.GetImplementedGlobalEvents(_fsm, true); isEventImplemented = PlayMakerInspectorUtils.DoesTargetImplementsEvent(_fsm, _eventName); } // find the index of the serialized event name in the list of events int selected = 0; if (!string.IsNullOrEmpty(_eventName)) { selected = ArrayUtility.IndexOf <string>(_eventList, _eventName); } Rect _rect = GetRectforRow(pos, ++row - 1); if (showOptions) { _rect.width -= 18; } string _popupLabel = label.text; if (selected != 0 && eventTarget.enumValueIndex != 2) // not none and not broadcasting { if ((selected > 0 && !isEventImplemented) || selected == -1) { //_popup = GUI.skin.GetStyle("ErrorLabel"); GUIStyle labelStyle = GUI.skin.GetStyle("controlLabel"); labelStyle.richText = true; _popupLabel = "<color=red>" + _popupLabel + "</color>"; } } // Event Popup Rect _contentRect = EditorGUI.PrefixLabel(_rect, label); //_contentRect.width -= 0; if (GUI.Button( _contentRect, string.IsNullOrEmpty(_eventName)?"none":_eventName, EditorStyles.popup)) { GenericMenu menu = GenerateEventMenu(_eventList, _eventName); menu.DropDown(_rect); } /* * _rect.x =_rect.xMax-10; * _rect.width = 10; * * if (GUI.Button(_rect,"?","label")) * { * //buttonRect.x += FsmEditor.Window.position.x + FsmEditor.Window.position.width - FsmEditor.InspectorPanelWidth; * //buttonRect.y += FsmEditor.Window.position.y + StateInspector.ActionsPanelRect.y + 3 - FsmEditor.StateInspector.scrollPosition.y; * //var newVariableWindow = PlayMakerEditor. NewEventWindow.CreateDropdown("New Global Event", _contentRect, eventName); * //newVariableWindow.EditCommited += DoNewGlobalEvent; * } */ _rect.x = _rect.xMax + 2; _rect.width = 18; if (showOptions) { if (GUI.Button(_rect, FsmEditorContent.SettingsButton, "label")) { GenericMenu menu = new GenericMenu(); if (eventTarget != null && eventTarget.enumValueIndex != 2) // not a broadcast call { menu.AddItem(new GUIContent("Show All global Events"), false, ShowAllEvents); menu.AddItem(new GUIContent("Show local Event"), false, ShowImplementedEvents); menu.AddSeparator(""); } menu.AddItem(new GUIContent("Reset"), false, ResetToDefault); menu.ShowAsContext(); } } // feedback if (selected == -1) { EditorGUI.LabelField( GetRectforRow(pos, ++row - 1), "<color=red>missing event</color>", "<color=red>" + _eventName + "</color>" ); } if (selected != 0 && eventTarget.enumValueIndex != 2) // not none and not broadcasting { if (selected > 0 && !isEventImplemented) { EditorGUI.LabelField( GetRectforRow(pos, ++row - 1), " ", "<color=red>Not implemented on target</color>" ); } } // attempt to refresh UI and avoid glitch if (row != rowCount) { prop.serializedObject.ApplyModifiedProperties(); prop.serializedObject.Update(); } rowCount = row; }
public void Build(Animation animation, IDictionary <int, TimeLine> timeLines) { var clip = new AnimationClip(); clip.name = animation.name; var pendingTransforms = new Dictionary <string, Transform> (Transforms); //This Dictionary will shrink in size for every transform foreach (var key in animation.mainlineKeys) //that is considered "used" { var parentTimelines = new Dictionary <int, List <TimeLineKey> > (); var brefs = new Queue <Ref> (key.boneRefs ?? new Ref [0]); while (brefs.Count > 0) { var bref = brefs.Dequeue(); if (bref.parent < 0 || parentTimelines.ContainsKey(bref.parent)) { var timeLine = timeLines [bref.timeline]; parentTimelines [bref.id] = new List <TimeLineKey> (timeLine.keys); Transform bone; if (pendingTransforms.TryGetValue(timeLine.name, out bone)) //Skip it if it's already "used" { List <TimeLineKey> parentTimeline; parentTimelines.TryGetValue(bref.parent, out parentTimeline); SetCurves(bone, DefaultBones [timeLine.name], parentTimeline, timeLine, clip, animation); pendingTransforms.Remove(timeLine.name); } } else { brefs.Enqueue(bref); } } foreach (var sref in key.objectRefs) { var timeLine = timeLines [sref.timeline]; Transform sprite; if (pendingTransforms.TryGetValue(timeLine.name, out sprite)) { var defaultZ = sref.z_index; List <TimeLineKey> parentTimeline; parentTimelines.TryGetValue(sref.parent, out parentTimeline); SetCurves(sprite, DefaultSprites [timeLine.name], parentTimeline, timeLine, clip, animation, ref defaultZ); SetAdditionalCurves(sprite, animation.mainlineKeys, timeLine, clip, defaultZ); pendingTransforms.Remove(timeLine.name); } } foreach (var kvPair in pendingTransforms) //Disable the remaining tansforms if they are sprites and not already disabled { if (DefaultSprites.ContainsKey(kvPair.Key) && kvPair.Value.gameObject.activeSelf) { var curve = new AnimationCurve(new Keyframe(0f, 0f, inf, inf)); clip.SetCurve(GetPathToChild(kvPair.Value), typeof(GameObject), "m_IsActive", curve); } } } var settings = AnimationUtility.GetAnimationClipSettings(clip); settings.stopTime = animation.length; //Set the animation's length and other settings if (animation.looping) { clip.wrapMode = WrapMode.Loop; settings.loopTime = true; } else { clip.wrapMode = WrapMode.ClampForever; } AnimationUtility.SetAnimationClipSettings(clip, settings); if (OriginalClips.ContainsKey(animation.name)) //If the clip already exists, copy this clip into the old one { var oldClip = OriginalClips [animation.name]; var cachedEvents = oldClip.events; EditorUtility.CopySerialized(clip, oldClip); clip = oldClip; AnimationUtility.SetAnimationEvents(clip, cachedEvents); ProcessingInfo.ModifiedAnims.Add(clip); } else { switch (S2USettings.ImportStyle) { case AnimationImportOption.NestedInPrefab: AssetDatabase.AddObjectToAsset(clip, PrefabPath); //Otherwise create a new one break; case AnimationImportOption.SeparateFolder: if (!AssetDatabase.IsValidFolder(AnimationsPath)) { var splitIndex = AnimationsPath.LastIndexOf('/'); var path = AnimationsPath.Substring(0, splitIndex); var newFolder = AnimationsPath.Substring(splitIndex + 1); AssetDatabase.CreateFolder(path, newFolder); } AssetDatabase.CreateAsset(clip, string.Format("{0}/{1}.anim", AnimationsPath, clip.name)); break; } ProcessingInfo.NewAnims.Add(clip); } if (!ArrayUtility.Contains(Controller.animationClips, clip)) //Don't add the clip if it's already there { var state = GetStateFromController(clip.name); //Find a state of the same name if (state != null) { state.motion = clip; //If it exists, replace it } else { Controller.AddMotion(clip); //Otherwise add it as a new state } if (!ModdedController) { if (!ProcessingInfo.NewControllers.Contains(Controller) && !ProcessingInfo.ModifiedControllers.Contains(Controller)) { ProcessingInfo.ModifiedControllers.Add(Controller); } ModdedController = true; } } }
private bool m_displayAutocompleteBtn = false; // fix gui warning when button appears public void Display(Object target, uint[] aTileData, int[] tileIdxMap, int gridWidth, int gridHeight, Vector2 visualTileSize, int[] symbolIdxMap) { GUI.changed = m_hasChanged; m_hasChanged = false; m_target = target; m_aBrushTileData = aTileData; Event e = Event.current; bool isRightMouseReleased = e.type == EventType.MouseUp && e.button == 0; if (isRightMouseReleased && !m_tileSelectionRect.Contains(e.mousePosition)) { m_selectedTileIdx = -1; } GUILayout.BeginHorizontal(); // Draw Autotile Combination Control GUI.backgroundColor = Tileset.BackgroundColor; GUILayout.BeginScrollView(Vector2.zero, (GUIStyle)"Button", GUILayout.Width(visualTileSize.x * gridWidth), GUILayout.Height(visualTileSize.y * gridHeight + 1f)); GUI.backgroundColor = Color.white; for (int i = 0; i < gridWidth * gridHeight; ++i) { int gx = i % gridWidth; int gy = i / gridWidth; int tileIdx = tileIdxMap[i]; Rect rVisualTile = new Rect(gx * visualTileSize.x, gy * visualTileSize.y, visualTileSize.x, visualTileSize.y); int tileId = (int)(m_aBrushTileData[tileIdx] & Tileset.k_TileDataMask_TileId); if (tileId != Tileset.k_TileId_Empty) { //Rect tileUV = Tileset.Tiles[tileId].uv; //GUI.DrawTextureWithTexCoords(rVisualTile, Tileset.AtlasTexture, tileUV, true); TilesetEditor.DoGUIDrawTileFromTileData(rVisualTile, m_aBrushTileData[tileIdx], Tileset); } else if (symbolIdxMap != null) { GUI.DrawTexture(rVisualTile, GetTileSymbolTexture((byte)symbolIdxMap[i]), ScaleMode.ScaleToFit, true); } Color bgColor = new Color(1f - Tileset.BackgroundColor.r, 1f - Tileset.BackgroundColor.g, 1f - Tileset.BackgroundColor.b, Tileset.BackgroundColor.a); HandlesEx.DrawRectWithOutline(rVisualTile, m_selectedTileIdx == tileIdx ? new Color(0f, 0f, 0f, 0.1f) : new Color(), m_selectedTileIdx == tileIdx ? new Color(1f, 1f, 0f, 1f) : bgColor); if (isRightMouseReleased && rVisualTile.Contains(e.mousePosition)) { m_selectedTileIdx = tileIdx; EditorWindow wnd = EditorWindow.focusedWindow; TileSelectionWindow.Show(Tileset); TileSelectionWindow.Instance.Ping(); wnd.Focus(); GUI.FocusControl(""); } } GUILayout.EndScrollView(); uint brushTileData = m_selectedTileIdx >= 0 ? m_aBrushTileData[m_selectedTileIdx] : Tileset.k_TileData_Empty; brushTileData = DoTileDataPropertiesLayout(brushTileData, Tileset); if (m_selectedTileIdx >= 0) { m_aBrushTileData[m_selectedTileIdx] = brushTileData; } GUILayout.EndHorizontal(); if (e.type == EventType.Repaint) { m_tileSelectionRect = GUILayoutUtility.GetLastRect(); } bool hasEmptyTiles = ArrayUtility.Contains <uint>(m_aBrushTileData, Tileset.k_TileData_Empty); m_displayAutocompleteBtn = e.type == EventType.Layout ? !hasEmptyTiles && m_tileIdOff != 0 : m_displayAutocompleteBtn; if (m_displayAutocompleteBtn && GUILayout.Button("Autocomplete relative to last change")) { Undo.RecordObject(m_target, "MultipleTileChanged"); for (int i = 0; i < tileIdxMap.Length; ++i) { int tileIdx = tileIdxMap[i]; if (tileIdx != m_tileIdOffSkipIdx) { int brushTileId = (int)(m_aBrushTileData[tileIdx] & Tileset.k_TileDataMask_TileId); brushTileId += m_tileIdOff; if (brushTileId < 0 || brushTileId >= m_tileset.Tiles.Count) { m_aBrushTileData[tileIdx] = Tileset.k_TileData_Empty; } else { m_aBrushTileData[tileIdx] &= ~Tileset.k_TileDataMask_TileId; m_aBrushTileData[tileIdx] |= (uint)(brushTileId & Tileset.k_TileDataMask_TileId); } } } m_tileIdOff = 0; EditorUtility.SetDirty(m_target); } if (Tileset.TileSelection != null && Tileset.TileSelection.selectionData.Count == gridWidth * gridHeight && Tileset.TileSelection.rowLength == gridWidth) { if (GUILayout.Button("Autocomplete from selection")) { Undo.RecordObject(m_target, "MultipleTileChanged"); for (int i = 0; i < tileIdxMap.Length; ++i) { int tileIdx = tileIdxMap[i]; int selectionIdx = (i % gridWidth) + (gridHeight - 1 - i / gridWidth) * gridWidth; int brushTileId = (int)(Tileset.TileSelection.selectionData[selectionIdx] & Tileset.k_TileDataMask_TileId); m_aBrushTileData[tileIdx] = (uint)(brushTileId & Tileset.k_TileDataMask_TileId); } m_tileIdOff = 0; EditorUtility.SetDirty(m_target); } } if (ShowHelpBox) { EditorGUILayout.HelpBox("Select a tile from the grid, then select a tile from Tile Selection Window to change the tile.\nOr select a group of tiles and press Autocomplete from selection.", MessageType.Info); } }
internal static GameObject PickNodeOrGameObject(Camera camera, Vector2 pickposition, int layers, ref GameObject[] ignore, ref GameObject[] filter, out ChiselModel model, out ChiselNode node, out CSGTreeBrushIntersection intersection) { TryNextSelection: intersection = new CSGTreeBrushIntersection { surfaceID = -1, brushUserID = -1 }; model = null; node = null; Material sharedMaterial; var gameObject = PickModel(camera, pickposition, layers, ref ignore, ref filter, out model, out sharedMaterial); if (object.Equals(gameObject, null)) { return(null); } if (model) { int filterLayerParameter0 = (sharedMaterial) ? sharedMaterial.GetInstanceID() : 0; { var worldRay = camera.ScreenPointToRay(pickposition); var worldRayStart = worldRay.origin; var worldRayVector = (worldRay.direction * (camera.farClipPlane - camera.nearClipPlane)); var worldRayEnd = worldRayStart + worldRayVector; CSGTreeBrushIntersection tempIntersection; if (ChiselSceneQuery.FindFirstWorldIntersection(model, worldRayStart, worldRayEnd, filterLayerParameter0, layers, ignore, filter, out tempIntersection)) { var clickedBrush = tempIntersection.brush; node = ChiselNodeHierarchyManager.FindChiselNodeByInstanceID(clickedBrush.UserID); if (node) { if (ignore != null && ignore.Contains(node.gameObject)) { node = null; return(null); } intersection = tempIntersection; return(node.gameObject); } else { node = null; } } } if (ignore == null) { return(null); } ArrayUtility.Add(ref ignore, gameObject); goto TryNextSelection; } if (object.Equals(gameObject, null)) { return(null); } if (ignore != null && ignore.Contains(gameObject)) { return(null); } return(gameObject); }
private void ShowList(SerializedProperty list) { EditorGUI.indentLevel++; // remove the keywords already assigned from the registered list var handler = (SpeechInputHandler)target; var availableKeywords = new string[0]; if (handler.Keywords != null) { availableKeywords = registeredKeywords.Except(handler.Keywords.Select(keywordAndResponse => keywordAndResponse.Keyword)).ToArray(); } // keyword rows for (int index = 0; index < list.arraySize; index++) { // the element SerializedProperty speechCommandProperty = list.GetArrayElementAtIndex(index); EditorGUILayout.BeginHorizontal(); bool elementExpanded = EditorGUILayout.PropertyField(speechCommandProperty); GUILayout.FlexibleSpace(); // the remove element button bool elementRemoved = GUILayout.Button(RemoveButtonContent, EditorStyles.miniButton, MiniButtonWidth); if (elementRemoved) { list.DeleteArrayElementAtIndex(index); } EditorGUILayout.EndHorizontal(); SerializedProperty keywordProperty = speechCommandProperty.FindPropertyRelative("keyword"); bool invalidKeyword = true; foreach (string keyword in registeredKeywords) { if (keyword == keywordProperty.stringValue) { invalidKeyword = false; break; } } if (invalidKeyword) { EditorGUILayout.HelpBox("Registered keyword is not recognized in the speech command profile!", MessageType.Error); } if (!elementRemoved && elementExpanded) { string[] keywords = availableKeywords.Concat(new[] { keywordProperty.stringValue }).OrderBy(keyword => keyword).ToArray(); int previousSelection = ArrayUtility.IndexOf(keywords, keywordProperty.stringValue); int currentSelection = EditorGUILayout.Popup("Keyword", previousSelection, keywords); if (currentSelection != previousSelection) { keywordProperty.stringValue = keywords[currentSelection]; } SerializedProperty responseProperty = speechCommandProperty.FindPropertyRelative("response"); EditorGUILayout.PropertyField(responseProperty, true); } } // add button row EditorGUILayout.BeginHorizontal(); GUILayout.FlexibleSpace(); // the add element button if (GUILayout.Button(AddButtonContent, EditorStyles.miniButton, MiniButtonWidth)) { var index = list.arraySize; list.InsertArrayElementAtIndex(index); var elementProperty = list.GetArrayElementAtIndex(index); SerializedProperty keywordProperty = elementProperty.FindPropertyRelative("keyword"); keywordProperty.stringValue = string.Empty; } EditorGUILayout.EndHorizontal(); EditorGUI.indentLevel--; }
public override void OnInspectorGUI() { EditorGUILayout.BeginVertical(); var oldSize = map.mapSize; map.mapSize = EditorGUILayout.Vector2Field("Map Size:", map.mapSize); if (map.mapSize != oldSize) { UpdateCalculations(); } var oldTexture = map.texture2D; map.texture2D = (Texture2D)EditorGUILayout.ObjectField("Texture2D:", map.texture2D, typeof(Texture2D), false); if (oldTexture != map.texture2D) { UpdateCalculations(); map.tileID = 1; CreateBrush(); } if (map.texture2D == null) { EditorGUILayout.HelpBox("You have not selected a texture 2D yet.", MessageType.Warning); } else { EditorGUILayout.LabelField("Tile Size:", map.tileSize.x + "x" + map.tileSize.y); map.tilePadding = EditorGUILayout.Vector2Field("Tile Padding", map.tilePadding); EditorGUILayout.LabelField("Grid Size In Units:", map.gridSize.x + "x" + map.gridSize.y); EditorGUILayout.LabelField("Pixels To Units:", map.pixelsToUnits.ToString()); solidFlag = EditorGUILayout.Toggle("Solid", solidFlag); sortingOrder = EditorGUILayout.IntField("Order in Layer", sortingOrder); var layerNames = getLayerNames(); var index = ArrayUtility.IndexOf(layerNames, layerName); index = EditorGUILayout.Popup("Layer Name", index, layerNames); if (index > -1) { layerName = layerNames[index]; if (GUILayout.Button("Clear Layer")) { layerName = null; } } UpdateBrush(map.currentTileBrush); if (GUILayout.Button("Clear Tiles")) { if (EditorUtility.DisplayDialog("Clear map's tiles?", "Are you sure?", "Clear", "Do not clear")) { ClearMap(); } } } EditorGUILayout.EndVertical(); }
private void TryBuild(Entity entity, GameObject prefab, GameObject instance, string directory, string prefabPath, IDictionary <int, IDictionary <int, Sprite> > folders) { var controllerPath = string.Format("{0}/{1}.controller", directory, entity.name); var animator = instance.GetComponent <Animator> (); //Fetches the prefab's Animator if (animator == null) { animator = instance.AddComponent <Animator> (); //Or creates one if it doesn't exist } AnimatorController controller = null; if (animator.runtimeAnimatorController != null) //The controller we use is hopefully the controller attached to the animator { controller = animator.runtimeAnimatorController as AnimatorController ?? //Or the one that's referenced by an OverrideController (AnimatorController)((AnimatorOverrideController)animator.runtimeAnimatorController).runtimeAnimatorController; } if (controller == null) //Otherwise we have to check the AssetDatabase for our controller { controller = (AnimatorController)AssetDatabase.LoadAssetAtPath(controllerPath, typeof(AnimatorController)); if (controller == null) { controller = AnimatorController.CreateAnimatorControllerAtPath(controllerPath); //Or create a new one if it doesn't exist. ProcessingInfo.NewControllers.Add(controller); } animator.runtimeAnimatorController = controller; } var transforms = new Dictionary <string, Transform> (); //All of the bones and sprites, identified by TimeLine.name, because those are truly unique transforms ["rootTransform"] = instance.transform; //The root GameObject needs to be part of this hierarchy as well var defaultBones = new Dictionary <string, SpatialInfo> (); //These are basically the object states on the first frame of the first animation var defaultSprites = new Dictionary <string, SpriteInfo> (); //They are used as control values in determining whether something has changed var animBuilder = new AnimationBuilder(ProcessingInfo, folders, transforms, defaultBones, defaultSprites, prefabPath, controller); var firstAnim = true; //The prefab's graphic will be determined by the first frame of the first animation foreach (var animation in entity.animations) { var timeLines = new Dictionary <int, TimeLine> (); foreach (var timeLine in animation.timelines) //TimeLines hold all the critical data such as positioning and graphics used { timeLines [timeLine.id] = timeLine; } foreach (var key in animation.mainlineKeys) { var parents = new Dictionary <int, string> (); //Parents are referenced by different IDs V_V parents [-1] = "rootTransform"; //This is where "-1 == no parent" comes in handy var boneRefs = new Queue <Ref> (key.boneRefs ?? new Ref[0]); while (boneRefs.Count > 0) { var bone = boneRefs.Dequeue(); var timeLine = timeLines [bone.timeline]; parents [bone.id] = timeLine.name; if (!transforms.ContainsKey(timeLine.name)) //We only need to go through this once, so ignore it if it's already in the dict { if (parents.ContainsKey(bone.parent)) //If the parent cannot be found, it will probably be found later, so save it { var parentID = parents [bone.parent]; var parent = transforms [parentID]; var child = parent.Find(timeLine.name); //Try to find the child transform if it exists if (child == null) //Or create a new one { child = new GameObject(timeLine.name).transform; child.SetParent(parent); } transforms [timeLine.name] = child; var spatialInfo = defaultBones [timeLine.name] = ArrayUtility.Find(timeLine.keys, x => x.id == bone.key).info; if (!spatialInfo.processed) { SpatialInfo parentInfo; defaultBones.TryGetValue(parentID, out parentInfo); spatialInfo.Process(parentInfo); } child.localPosition = new Vector3(spatialInfo.x, spatialInfo.y, 0f); child.localRotation = spatialInfo.rotation; child.localScale = new Vector3(spatialInfo.scale_x, spatialInfo.scale_y, 1f); } else { boneRefs.Enqueue(bone); } } } foreach (var oref in key.objectRefs) { var timeLine = timeLines [oref.timeline]; if (!transforms.ContainsKey(timeLine.name)) //Same as above { var parentID = parents [oref.parent]; var parent = transforms [parentID]; var child = parent.Find(timeLine.name); if (child == null) { child = new GameObject(timeLine.name).transform; child.SetParent(parent); } transforms [timeLine.name] = child; var swapper = child.GetComponent <TextureController> (); //Destroy the Sprite Swapper, we'll make a new one later if (swapper != null) { DestroyImmediate(swapper); } var renderer = child.GetComponent <SpriteRenderer> (); //Get or create a Sprite Renderer if (renderer == null) { renderer = child.gameObject.AddComponent <SpriteRenderer> (); } var spriteInfo = defaultSprites [timeLine.name] = (SpriteInfo)ArrayUtility.Find(timeLine.keys, x => x.id == 0).info; renderer.sprite = folders [spriteInfo.folder] [spriteInfo.file]; if (!spriteInfo.processed) { SpatialInfo parentInfo; defaultBones.TryGetValue(parentID, out parentInfo); spriteInfo.Process(parentInfo); } child.localPosition = new Vector3(spriteInfo.x, spriteInfo.y, oref.z_index); //Z-index helps determine draw order child.localEulerAngles = new Vector3(0f, 0f, spriteInfo.angle); //The reason I don't use layers or layer orders is because child.localScale = new Vector3(spriteInfo.scale_x, spriteInfo.scale_y, 1f); //There tend to be a LOT of body parts, it's better to treat var color = renderer.color; //The entity as a single sprite for layer sorting purposes. color.a = spriteInfo.a; renderer.color = color; if (!firstAnim) { child.gameObject.SetActive(false); //Disable the GameObject if this isn't the first frame of the first animation } } } if (firstAnim) { firstAnim = false; } } try { animBuilder.Build(animation, timeLines); //Builds the currently processed AnimationClip, see AnimationBuilder for more info } catch (Exception e) { Debug.LogErrorFormat("Unable to build animation '{0}' for '{1}', reason: {2}", animation.name, entity.name, e); } } if (instance.GetComponent <EntityRenderer> () == null) { instance.AddComponent <EntityRenderer> (); //Adds an EntityRenderer if one is not already present } PrefabUtility.ReplacePrefab(instance, prefab, ReplacePrefabOptions.ConnectToPrefab); DestroyImmediate(instance); //Apply the instance's changes to the prefab, then destroy the instance. }
public static UnityEngine.Object[] GetSceneCustomActionDependencies() { UnityEngine.Object[] list = new UnityEngine.Object[0]; FsmEditor.RebuildFsmList(); List <PlayMakerFSM> fsms = FsmEditor.FsmComponentList; // List<System.Type> PlayMakerActions = FsmEditorUtility.Actionslist; foreach (PlayMakerFSM fsm in fsms) { //Debug.Log(FsmEditorUtility.GetFullFsmLabel(fsm)); //if (fsm.FsmStates != null) fsm.FsmStates.Initialize(); for (int s = 0; s < fsm.FsmStates.Length; ++s) { fsm.FsmStates[s].LoadActions(); Debug.Log(fsm.FsmStates[s].Name + " is loaded:" + fsm.FsmStates[s].ActionsLoaded); // Show SendEvent and SendMessage as we find them foreach (FsmStateAction action in fsm.FsmStates[s].Actions) { #if PLAYMAKER_1_8_OR_NEWER UnityEngine.Object _asset = ActionScripts.GetAsset(action); #else UnityEngine.Object _asset = FsmEditorUtility.GetActionScriptAsset(action); #endif string _name = action.Name; if (String.IsNullOrEmpty(_name)) { if (_asset != null) { _name = _asset.name; } else { #if PLAYMAKER_1_8_OR_NEWER _name = Labels.GetActionLabel(action) + "[WARNING: FILE NOT FOUND]"; #else _name = FsmEditorUtility.GetActionLabel(action) + "[WARNING: FILE NOT FOUND]"; #endif } } if (Enum.IsDefined(typeof(WikiPages), _name)) { // Debug.Log(_name+" : official action"); } else { // Debug.Log(_name+" : custom action"); if (_asset != null) { ArrayUtility.Add <UnityEngine.Object>(ref list, _asset); } } } } } return(list); } // GetSceneCustomActionDependencies
public static void PreferenceWindow() { if (constants == null) { constants = new LocalStyles(); } if (keyArray == null) { keyArray = GetKeys(); ReadKeys(); } int id = GUIUtility.GetControlID(s_KeysControlHash, FocusType.Keyboard); KeyPref prevKey = null; KeyPref nextKey = null; bool foundSelectedKey = false; var width = Mathf.Min(Mathf.Max(170f, EditorGUIUtility.currentViewWidth - 600), 400); GUILayout.BeginHorizontal(); GUILayout.BeginVertical(GUILayout.MaxWidth(width)); GUILayout.Label("Actions", constants.settingsBoxTitle, GUILayout.ExpandWidth(true)); Rect selectedRect = default(Rect); keyNamesScrollPos = GUILayout.BeginScrollView(keyNamesScrollPos); //, constants.settingsBox); { for (int i = 0; i < keyArray.Length; i++) { var keyPref = keyArray[i]; if (!foundSelectedKey) { if (keyPref == m_SelectedKey) { foundSelectedKey = true; } else { prevKey = keyPref; } } else { if (nextKey == null) { nextKey = keyPref; } } EditorGUI.BeginChangeCheck(); if (GUILayout.Toggle(keyPref == m_SelectedKey, keyPref.name, constants.keysElement)) { if (m_SelectedKey != keyPref) { checkBounds = true; } m_SelectedKeyIndex = i; m_SelectedKey = keyPref; newKey = new KeyCodeWithModifier(); if (Event.current.type == EventType.Repaint) { selectedRect = GUILayoutUtility.GetLastRect(); } } if (EditorGUI.EndChangeCheck()) { GUIUtility.keyboardControl = id; } } } GUILayout.EndScrollView(); GUILayout.EndVertical(); if (Event.current.type == EventType.Repaint && checkBounds) { checkBounds = false; Rect scrollViewRect = GUILayoutUtility.GetLastRect(); scrollViewRect.position = Vector2.zero; scrollViewRect.position += keyNamesScrollPos; scrollViewRect.yMax -= 34; if (selectedRect.yMax > scrollViewRect.yMax) { keyNamesScrollPos.y = selectedRect.yMax - scrollViewRect.height; HandleUtility.Repaint(); } if (selectedRect.yMin < scrollViewRect.yMin) { keyNamesScrollPos.y = selectedRect.yMin; HandleUtility.Repaint(); } if (keyNamesScrollPos.y < 0) { keyNamesScrollPos.y = 0; } } GUILayout.Space(10.0f); GUILayout.BeginVertical(); keySettingsScrollPos = GUILayout.BeginScrollView(keySettingsScrollPos); if (m_SelectedKey != null) { GUI.changed = false; var allKeys = m_SelectedKey.keyEvent.keys; for (int i = 0; i < allKeys.Length; i++) { PreferenceKey(ref allKeys, i); } PreferenceKeyItem(ref newKey); if (newKey.keyCode != KeyCode.None) { ArrayUtility.Add(ref allKeys, newKey); } m_SelectedKey.keyEvent.keys = allKeys; if (GUI.changed) { StoreKeys(); } else { if (GUIUtility.keyboardControl == id && Event.current.type == EventType.KeyDown) { switch (Event.current.keyCode) { case KeyCode.UpArrow: if (prevKey != null && prevKey != m_SelectedKey) { m_SelectedKey = prevKey; checkBounds = true; //m_ValidKeyChange = true; } Event.current.Use(); break; case KeyCode.DownArrow: if (nextKey != null && nextKey != m_SelectedKey) { m_SelectedKey = nextKey; checkBounds = true; //m_ValidKeyChange = true; } Event.current.Use(); break; } } } } GUILayout.EndScrollView(); GUILayout.EndVertical(); GUILayout.Space(10f); GUILayout.EndHorizontal(); GUILayout.Space(5f); if (GUILayout.Button("Use Defaults", GUILayout.Width(120))) { RevertKeys(); StoreKeys(); } }
/// <summary> /// update context on receiving RPCE CO Bind PDU. /// </summary> /// <param name="bindPdu">Bind PDU to receive.</param> internal void UpdateContextOnReceivingBindPdu(RpceCoBindPdu bindPdu) { this.MaxTransmitFragmentSize = bindPdu.max_xmit_frag; this.MaxReceiveFragmentSize = bindPdu.max_recv_frag; if (bindPdu.assoc_group_id != 0) { this.AssociateGroupId = bindPdu.assoc_group_id; } else { if (this.associateGroupIdList.Count == 0) { this.AssociateGroupId = bindPdu.assoc_group_id + 1; } else { this.associateGroupIdList.Sort(); this.AssociateGroupId = this.associateGroupIdList[this.associateGroupIdList.Count - 1] + 1; } } associateGroupIdList.Add(this.AssociateGroupId); if (bindPdu.p_context_elem.p_cont_elem != null && bindPdu.p_context_elem.p_cont_elem.Length > 0) { this.InterfaceId = bindPdu.p_context_elem.p_cont_elem[0].abstract_syntax.if_uuid; this.InterfaceMajorVersion = bindPdu.p_context_elem.p_cont_elem[0].abstract_syntax.if_vers_major; this.InterfaceMinorVersion = bindPdu.p_context_elem.p_cont_elem[0].abstract_syntax.if_vers_minor; this.NdrVersion = RpceNdrVersion.None; this.PresentationContextsTable.Clear(); for (int i = 0; i < bindPdu.p_context_elem.p_cont_elem.Length; i++) { p_cont_elem_t p_cont_elem = bindPdu.p_context_elem.p_cont_elem[i]; if (p_cont_elem.transfer_syntaxes == null) { continue; } for (int j = 0; j < p_cont_elem.transfer_syntaxes.Length; j++) { p_syntax_id_t transfer_syntax = p_cont_elem.transfer_syntaxes[j]; if (transfer_syntax.if_uuid == RpceUtility.NDR_INTERFACE_UUID && transfer_syntax.if_vers_major == RpceUtility.NDR_INTERFACE_MAJOR_VERSION && transfer_syntax.if_vers_minor == RpceUtility.NDR_INTERFACE_MINOR_VERSION) { this.NdrVersion |= RpceNdrVersion.NDR; this.PresentationContextsTable.Add(p_cont_elem.p_cont_id, RpceNdrVersion.NDR); } else if (transfer_syntax.if_uuid == RpceUtility.NDR64_INTERFACE_UUID && transfer_syntax.if_vers_major == RpceUtility.NDR64_INTERFACE_MAJOR_VERSION && transfer_syntax.if_vers_minor == RpceUtility.NDR64_INTERFACE_MINOR_VERSION) { this.NdrVersion |= RpceNdrVersion.NDR64; this.PresentationContextsTable.Add(p_cont_elem.p_cont_id, RpceNdrVersion.NDR64); } else { byte[] uuid = transfer_syntax.if_uuid.ToByteArray(); if (ArrayUtility.CompareArrays( ArrayUtility.SubArray( uuid, 0, RpceUtility.BIND_TIME_FEATURE_NEGOTIATION_BITMASK_PREFIX_LENGTH), ArrayUtility.SubArray( RpceUtility.BIND_TIME_FEATURE_NEGOTIATION_BITMASK_GUID_BYTES, 0, RpceUtility.BIND_TIME_FEATURE_NEGOTIATION_BITMASK_PREFIX_LENGTH)) && transfer_syntax.if_vers_major == 1 && transfer_syntax.if_vers_minor == 0) { this.BindTimeFeatureNegotiationBitmask = (RpceBindTimeFeatureNegotiationBitmask) uuid[RpceUtility.BIND_TIME_FEATURE_NEGOTIATION_BITMASK_PREFIX_LENGTH]; } } } } } }
/// <summary> /// GUI Player Settingsの描画を行います /// </summary> public void DrawGUI_PlayerSettings() { var currentParams = P.GetCurrentParams(); int opt = currentParams.platformOption; bool fold; using (new GUILayout.VerticalScope(Styles.helpBox)) { using (new GUILayout.HorizontalScope()) { EditorGUI.BeginChangeCheck(); fold = HEditorGUILayout.Foldout(E.i.fold.Has(E.FoldPlatform), "Player Settings"); E.i.fold.Toggle(E.FoldPlatform, fold); if (EditorGUI.EndChangeCheck()) { s_changed = true; } GUILayout.FlexibleSpace(); var r = EditorHelper.GetLayout(Styles.iconSettings, HEditorStyles.iconButton); if (HEditorGUI.IconButton(r, Styles.iconSettings, 1)) { if (PB.i.enableOldStyleProjectSettings) { Selection.activeObject = AssetDatabase.LoadAssetAtPath <UnityObject>(AssetDatabase.GUIDToAssetPath("00000000000000004000000000000000")); EditorUtils.InspectorWindow().Focus(); } else { UnityEditorMenu.Edit_Project_Settings(); } } } EditorGUI.BeginChangeCheck(); if (fold) { EditorGUI.indentLevel++; if (P.i.selectBuildTargetGroup == BuildTargetGroup.Standalone || P.i.selectBuildTargetGroup == BuildTargetGroup.Android) { currentParams.scriptingBackend = (ScriptingImplementation)EditorGUILayout.Popup(S._ScriptingBackend, (int)currentParams.scriptingBackend, B.kScriptingBackendNames); } bool backend = false; if (P.i.selectBuildTargetGroup == BuildTargetGroup.WebGL) { } else if (currentParams.scriptingBackend == ScriptingImplementation.Mono2x) { backend = true; } using (new EditorGUI.DisabledGroupScope(backend)) { currentParams.il2CppCompilerConfiguration = (Il2CppCompilerConfiguration)EditorGUILayout.EnumPopup(S._C__CompilerConfiguration, currentParams.il2CppCompilerConfiguration); } EditorGUILayout.LabelField($"{S._ScriptingDefineSymbols} ({S._Applybuildonly})"); using (new GUILayout.HorizontalScope()) { currentParams.scriptingDefineSymbols = EditorGUILayout.TextField(currentParams.scriptingDefineSymbols); var mm = R.Method("GetSymbolList", "Hananoki.SymbolSettings.SettingsProject", "Hananoki.SymbolSettings.Editor"); if (mm != null) { var tc = GUILayoutUtility.GetRect(EditorHelper.TempContent(Styles.iconPlus), HEditorStyles.iconButton, GUILayout.Width(16), GUILayout.Height(16)); if (HEditorGUI.IconButton(tc, Styles.iconPlus, 3)) { GUI.FocusControl(""); void add(object obj) { var s = obj as string; var ss = currentParams.scriptingDefineSymbols.Split(';'); ArrayUtility.Add(ref ss, s); currentParams.scriptingDefineSymbols = string.Join(";", ss.Where(x => !x.IsEmpty()).Distinct().ToArray()); } var hoge = (ValueTuple <string[], string[]>)mm.Invoke(null, null); var lst = new List <string>(); var m = new GenericMenu(); foreach (var s in hoge.Item1) { m.AddItem("Project/" + s, false, add, s); } foreach (var s in hoge.Item2) { m.AddItem("Editor/" + s, false, add, s); } m.DropDown(tc); } } } EditorGUILayout.LabelField($"{S._ScriptingDefineSymbols} ({S._Current})"); EditorGUI.BeginDisabledGroup(true); EditorGUILayout.TextField(B.scriptingDefineSymbols); EditorGUI.EndDisabledGroup(); EditorGUI.indentLevel--; GUILayout.Space(4); } if (EditorGUI.EndChangeCheck()) { currentParams.platformOption = opt; s_changed = true; } } }