static void OnGUIContents(bool isSceneGUI, EditModePlace tool) { EditModeCommonGUI.StartToolGUI(); var filteredSelection = EditModeManager.FilteredSelection; var defaultMoveOffset = CSGSettings.DefaultMoveOffset; var defaultRotateOffset = CSGSettings.DefaultRotateOffset; var displayNewCenter = GridUtility.CleanPosition((Tools.pivotRotation == PivotRotation.Local) ? tool.LocalSpacePivotCenter : tool.WorldSpacePivotCenter); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { ShowCSGOperations(isSceneGUI, tool, filteredSelection); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginDisabledGroup(!tool.HaveSelection); { if (Tools.current == Tool.Move) { EditorGUI.BeginDisabledGroup(defaultMoveOffset.sqrMagnitude < MathConstants.EqualityEpsilonSqr); { if (GUILayout.Button(MoveByOffsetContent)) { tool.MoveByOffset(RealtimeCSG.CSGSettings.DefaultMoveOffset); } TooltipUtility.SetToolTip(MoveByOffsetTooltip); if (GUILayout.Button(CloneMoveByOffsetContent)) { tool.CloneMoveByOffset(RealtimeCSG.CSGSettings.DefaultMoveOffset); } TooltipUtility.SetToolTip(CloneMoveByOffsetTooltip); } EditorGUI.EndDisabledGroup(); } else if (Tools.current == Tool.Rotate) { EditorGUI.BeginDisabledGroup(defaultMoveOffset.sqrMagnitude < MathConstants.EqualityEpsilonSqr); { if (GUILayout.Button(RotateByOffsetContent)) { tool.RotateByOffset(Quaternion.Euler(RealtimeCSG.CSGSettings.DefaultRotateOffset)); } TooltipUtility.SetToolTip(RotateByOffsetTooltip); if (GUILayout.Button(CloneRotateByOffsetContent)) { tool.CloneRotateByOffset(Quaternion.Euler(RealtimeCSG.CSGSettings.DefaultRotateOffset)); } TooltipUtility.SetToolTip(CloneRotateByOffsetTooltip); } EditorGUI.EndDisabledGroup(); if (GUILayout.Button(RecenterPivotContent)) { tool.RecenterPivot(); } TooltipUtility.SetToolTip(RecenterPivotTooltip); } } EditorGUI.EndDisabledGroup(); } GUILayout.EndVertical(); } GUILayout.EndHorizontal(); GUILayout.Space(5); if (Tools.current == Tool.Move) { var doubleFieldOptions = isSceneGUI ? MaxWidth150 : CSG_GUIStyleUtility.ContentEmpty; EditorGUI.BeginDisabledGroup(!tool.HaveSelection); { EditorGUI.BeginChangeCheck(); { GUILayout.Label(MoveOffsetContent); defaultMoveOffset = CSG_EditorGUIUtility.DistanceVector3Field(defaultMoveOffset, false, doubleFieldOptions); } if (EditorGUI.EndChangeCheck()) { RealtimeCSG.CSGSettings.DefaultMoveOffset = defaultMoveOffset; RealtimeCSG.CSGSettings.Save(); } } EditorGUI.EndDisabledGroup(); } else if (Tools.current == Tool.Rotate) { var doubleFieldOptions = isSceneGUI ? MaxWidth150 : CSG_GUIStyleUtility.ContentEmpty; EditorGUI.BeginDisabledGroup(Tools.pivotMode == PivotMode.Center || !tool.HaveSelection); { EditorGUI.BeginChangeCheck(); { GUILayout.Label(RotationCenterContent); defaultRotateOffset = CSG_EditorGUIUtility.EulerDegreeField(defaultRotateOffset); } if (EditorGUI.EndChangeCheck()) { RealtimeCSG.CSGSettings.DefaultRotateOffset = defaultRotateOffset; RealtimeCSG.CSGSettings.Save(); } EditorGUI.BeginChangeCheck(); { GUILayout.Label(PivotCenterContent); displayNewCenter = CSG_EditorGUIUtility.DistanceVector3Field(displayNewCenter, false, doubleFieldOptions); TooltipUtility.SetToolTip(PivotVectorTooltip); } if (EditorGUI.EndChangeCheck()) { if (Tools.pivotRotation == PivotRotation.Local) { tool.LocalSpacePivotCenter = displayNewCenter; } else { tool.WorldSpacePivotCenter = displayNewCenter; } } } EditorGUI.EndDisabledGroup(); } } GUILayout.EndVertical(); EditorGUI.showMixedValue = false; }
static public void OnInspectorGUI(Editor editor, UnityEngine.Object[] targets) { TooltipUtility.InitToolTip(editor); try { var models = new CSGModel[targets.Length]; for (int i = targets.Length - 1; i >= 0; i--) { models[i] = targets[i] as CSGModel; if (!models[i]) { ArrayUtility.RemoveAt(ref models, i); } } CSG_GUIStyleUtility.InitStyles(); ShowRealtimeCSGDisabledMessage(); if (models.Length > 0 && models.Length == targets.Length) { CSGModelComponentInspectorGUI.OnInspectorGUI(targets); return; } var filteredSelection = EditModeManager.FilteredSelection; var targetNodes = filteredSelection.NodeTargets; var targetModels = filteredSelection.ModelTargets; var targetBrushes = filteredSelection.BrushTargets; var targetOperations = filteredSelection.OperationTargets; if (targetNodes == null) { return; } bool?isPrefab = false; PrefabInstantiateBehaviour?prefabBehaviour = PrefabInstantiateBehaviour.Reference; PrefabSourceAlignment? prefabSourceAlignment = PrefabSourceAlignment.AlignedTop; PrefabDestinationAlignment?prefabDestinationAlignment = PrefabDestinationAlignment.AlignToSurface; if (targetNodes.Length > 0) { var gameObject = targetNodes[0].gameObject; isPrefab = CSGPrefabUtility.IsPrefabAsset(gameObject); prefabBehaviour = targetNodes[0].PrefabBehaviour; prefabSourceAlignment = targetNodes[0].PrefabSourceAlignment; prefabDestinationAlignment = targetNodes[0].PrefabDestinationAlignment; for (int i = 1; i < targetNodes.Length; i++) { gameObject = targetNodes[i].gameObject; var currentIsPrefab = CSGPrefabUtility.IsPrefabAsset(gameObject); var currentPrefabBehaviour = targetNodes[i].PrefabBehaviour; var currentPrefabSourceAlignment = targetNodes[i].PrefabSourceAlignment; var currentPrefabDestinationAlignment = targetNodes[i].PrefabDestinationAlignment; if (isPrefab.HasValue && isPrefab.Value != currentIsPrefab) { isPrefab = null; } if (prefabBehaviour.HasValue && prefabBehaviour.Value != currentPrefabBehaviour) { prefabBehaviour = null; } if (prefabSourceAlignment.HasValue && prefabSourceAlignment.Value != currentPrefabSourceAlignment) { prefabSourceAlignment = null; } if (prefabDestinationAlignment.HasValue && prefabDestinationAlignment.Value != currentPrefabDestinationAlignment) { prefabDestinationAlignment = null; } } } GUILayout.BeginVertical(GUI.skin.box); { if (isPrefab.HasValue && isPrefab.Value) { EditorGUILayout.LabelField(PrefabLabelContent); } else { EditorGUILayout.LabelField(RaySnappingLabelContent); TooltipUtility.SetToolTip(RaySnappingBehaviourTooltip); } EditorGUI.indentLevel++; { if (isPrefab.HasValue && isPrefab.Value) { EditorGUI.showMixedValue = !prefabBehaviour.HasValue; var prefabBehavour = prefabBehaviour.HasValue ? prefabBehaviour.Value : PrefabInstantiateBehaviour.Reference; EditorGUI.BeginChangeCheck(); { prefabBehavour = (PrefabInstantiateBehaviour)EditorGUILayout.EnumPopup(PrefabInstantiateBehaviourContent, prefabBehavour); TooltipUtility.SetToolTip(PrefabInstantiateBehaviourTooltip); } if (EditorGUI.EndChangeCheck()) { Undo.RecordObjects(targetNodes, "Changed CSG operation of nodes"); for (int i = 0; i < targetNodes.Length; i++) { targetNodes[i].PrefabBehaviour = prefabBehavour; } } EditorGUI.showMixedValue = false; } EditorGUI.showMixedValue = !prefabDestinationAlignment.HasValue; var destinationAlignment = prefabDestinationAlignment.HasValue ? prefabDestinationAlignment.Value : PrefabDestinationAlignment.AlignToSurface; EditorGUI.BeginChangeCheck(); { destinationAlignment = (PrefabDestinationAlignment)EditorGUILayout.EnumPopup(DestinationAlignmentContent, destinationAlignment); TooltipUtility.SetToolTip(DestinationAlignmentTooltip); } if (EditorGUI.EndChangeCheck()) { Undo.RecordObjects(targetNodes, "Changed CSG operation of nodes"); for (int i = 0; i < targetNodes.Length; i++) { targetNodes[i].PrefabDestinationAlignment = destinationAlignment; } } EditorGUI.showMixedValue = false; EditorGUI.showMixedValue = !prefabSourceAlignment.HasValue; var sourceAlignment = prefabSourceAlignment.HasValue ? prefabSourceAlignment.Value : PrefabSourceAlignment.AlignedFront; EditorGUI.BeginChangeCheck(); { sourceAlignment = (PrefabSourceAlignment)EditorGUILayout.EnumPopup(SourceAlignmentContent, sourceAlignment); TooltipUtility.SetToolTip(SourceAlignmentTooltip); } if (EditorGUI.EndChangeCheck()) { Undo.RecordObjects(targetNodes, "Changed CSG operation of nodes"); for (int i = 0; i < targetNodes.Length; i++) { targetNodes[i].PrefabSourceAlignment = sourceAlignment; } } EditorGUI.showMixedValue = false; } EditorGUI.indentLevel--; } GUILayout.EndVertical(); GUILayout.Space(10); if (targetModels.Length == 0) { int invalidOperationType = 999; bool? handleAsOne = null; bool selMixedValues = false; CSGOperationType operationType = (CSGOperationType)invalidOperationType; bool opMixedValues = false; if (targetBrushes.Length > 0) { operationType = targetBrushes[0].OperationType; } for (int b = 1; b < targetBrushes.Length; b++) { var brush = targetBrushes[b]; if (operationType != brush.OperationType) { opMixedValues = true; } } foreach (var operation in targetOperations) { if (operationType == (CSGOperationType)invalidOperationType) { operationType = operation.OperationType; } else if (operationType != operation.OperationType) { opMixedValues = true; } if (!handleAsOne.HasValue) { handleAsOne = operation.HandleAsOne; } else if (handleAsOne.Value != operation.HandleAsOne) { selMixedValues = true; } } GUILayout.BeginVertical(GUI.skin.box); { bool passThroughValue = false; if (targetBrushes.Length == 0 && targetOperations.Length > 0) // only operations { bool?passThrough = targetOperations[0].PassThrough; for (int i = 1; i < targetOperations.Length; i++) { if (passThrough.HasValue && passThrough.Value != targetOperations[i].PassThrough) { passThrough = null; break; } } opMixedValues = !passThrough.HasValue || passThrough.Value; var ptMixedValues = !passThrough.HasValue; passThroughValue = passThrough.HasValue ? passThrough.Value : false; if (CSG_EditorGUIUtility.PassThroughButton(passThroughValue, ptMixedValues)) { Undo.RecordObjects(targetNodes, "Changed CSG operation of nodes"); foreach (var operation in targetOperations) { operation.PassThrough = true; } InternalCSGModelManager.CheckForChanges(); EditorApplication.RepaintHierarchyWindow(); } if (passThroughValue) { operationType = (CSGOperationType)255; } } EditorGUI.BeginChangeCheck(); { operationType = CSG_EditorGUIUtility.ChooseOperation(operationType, opMixedValues); } if (EditorGUI.EndChangeCheck()) { Undo.RecordObjects(targetNodes, "Changed CSG operation of nodes"); foreach (var brush in targetBrushes) { brush.OperationType = operationType; } foreach (var operation in targetOperations) { operation.PassThrough = false; operation.OperationType = operationType; } InternalCSGModelManager.CheckForChanges(); EditorApplication.RepaintHierarchyWindow(); } } GUILayout.EndVertical(); if (targetOperations.Length == 0 && targetModels.Length == 0) { GUILayout.Space(10); if (targetBrushes.Length == 1) { GUILayout.BeginVertical(GUI.skin.box); { EditorGUI.indentLevel++; OpenSurfaces = EditorGUILayout.Foldout(OpenSurfaces, SurfacesContent); EditorGUI.indentLevel--; if (OpenSurfaces) { var targetShape = targetBrushes[0].Shape; var texGens = targetShape.TexGens; var texGenFlagArray = targetShape.TexGenFlags; for (int t = 0; t < texGens.Length; t++) { GUILayout.Space(2); var texGenFlags = texGenFlagArray[t]; var material = targetShape.TexGens[t].RenderMaterial; var physicsMat = targetShape.TexGens[t].PhysicsMaterial; EditorGUI.BeginChangeCheck(); { GUILayout.BeginHorizontal(); { GUILayout.Space(4); material = CSG_EditorGUIUtility.MaterialImage(material); GUILayout.Space(2); GUILayout.BeginVertical(); { //EditorGUI.BeginDisabledGroup(texGenFlags != TexGenFlags.None); { material = EditorGUILayout.ObjectField(material, typeof(Material), true) as Material; } //EditorGUI.EndDisabledGroup(); physicsMat = EditorGUILayout.ObjectField(physicsMat, typeof(PhysicMaterial), true) as PhysicMaterial; texGenFlags = EditModeCommonGUI.OnSurfaceFlagButtons(texGenFlags); } GUILayout.EndVertical(); GUILayout.Space(4); } GUILayout.EndHorizontal(); } if (EditorGUI.EndChangeCheck()) { var selectedBrushSurfaces = new [] { new SelectedBrushSurface(targetBrushes[0], t) }; using (new UndoGroup(selectedBrushSurfaces, "discarding surface")) { texGenFlagArray[t] = texGenFlags; targetShape.TexGens[t].RenderMaterial = material; targetShape.TexGens[t].PhysicsMaterial = physicsMat; } } GUILayout.Space(4); } } } GUILayout.EndVertical(); } } if (handleAsOne.HasValue) { EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = selMixedValues; handleAsOne = EditorGUILayout.Toggle(HandleAsOneLabel, handleAsOne.Value); } if (EditorGUI.EndChangeCheck()) { Undo.RecordObjects(targetNodes, "Changed CSG operation 'Handle as one object'"); foreach (var operation in targetOperations) { operation.HandleAsOne = handleAsOne.Value; } EditorApplication.RepaintHierarchyWindow(); } } } #if false if (targetNodes.Length == 1) { var node = targetNodes[0]; var brush = node as CSGBrush; if (brush != null) { var brush_cache = CSGSceneManager.GetBrushCache(brush); if (brush_cache == null || brush_cache.childData == null || brush_cache.childData.modelTransform == null) { EditorGUILayout.LabelField("brush-cache: null"); } else { EditorGUILayout.LabelField("node-id: " + brush.brushNodeID); } } var operation = node as CSGOperation; if (operation != null) { var operation_cache = CSGSceneManager.GetOperationCache(operation); if (operation_cache == null || operation_cache.childData == null || operation_cache.childData.modelTransform == null) { EditorGUILayout.LabelField("operation-cache: null"); } else { EditorGUILayout.LabelField("operation-id: " + operation.operationNodeID); } } var model = node as CSGModel; if (model != null) { var model_cache = CSGSceneManager.GetModelCache(model); if (model_cache == null || model_cache.meshContainer == null) { EditorGUILayout.LabelField("model-cache: null"); } else { EditorGUILayout.LabelField("model-id: " + model.modelNodeID); } } } #endif } finally { TooltipUtility.DrawToolTip(getLastRect: true, goUp: true); } }
static void OnGUIContents(bool isSceneGUI, EditModeClip tool) { EditModeCommonGUI.StartToolGUI(); if (tool.ClipBrushCount == 0) { GUILayout.Label(string.Format("no brushes selected", tool.ClipBrushCount), CSG_GUIStyleUtility.redTextArea); } else { if (tool.ClipBrushCount == 1) { GUILayout.Label(string.Format("{0} brush selected", tool.ClipBrushCount)); } else { GUILayout.Label(string.Format("{0} brushes selected", tool.ClipBrushCount)); } } EditorGUILayout.Space(); EditorGUI.BeginDisabledGroup(tool == null); { GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); { var newClipMode = (tool != null) ? tool.clipMode : ((ClipMode)999); var skin = CSG_GUIStyleUtility.Skin; for (int i = 0; i < clipModeValues.Length; i++) { var selected = newClipMode == clipModeValues[i]; GUIContent content; GUIStyle style; if (selected) { style = CSG_GUIStyleUtility.selectedIconLabelStyle; content = skin.clipNamesOn[i]; } else { style = CSG_GUIStyleUtility.unselectedIconLabelStyle; content = skin.clipNames[i]; } if (GUILayout.Toggle(selected, content, style)) { newClipMode = clipModeValues[i]; } TooltipUtility.SetToolTip(CSG_GUIStyleUtility.clipTooltips[i]); } if (tool != null && tool.clipMode != newClipMode) { tool.SetClipMode(newClipMode); } } GUILayout.EndVertical(); if (!isSceneGUI) { GUILayout.Space(10); } bool disabled = (tool == null || tool.editMode != EditModeClip.EditMode.EditPoints); var defaultMaterial = CSGSettings.DefaultMaterial; GUILayout.BeginVertical(isSceneGUI ? MaterialSceneWidth : CSG_GUIStyleUtility.ContentEmpty); { GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (isSceneGUI) { EditorGUI.BeginChangeCheck(); { defaultMaterial = CSG_EditorGUIUtility.MaterialImage(defaultMaterial); } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); } { EditorGUI.BeginDisabledGroup(disabled); { if (GUILayout.Button(ContentCancel)) { doCancel = true; } TooltipUtility.SetToolTip(CancelTooltip); if (GUILayout.Button(ContentCommit)) { doCommit = true; } TooltipUtility.SetToolTip(CommitTooltip); } EditorGUI.EndDisabledGroup(); } if (isSceneGUI) { GUILayout.EndVertical(); } } GUILayout.EndHorizontal(); if (isSceneGUI) { GUILayout.Space(2); EditorGUI.BeginChangeCheck(); { defaultMaterial = EditorGUILayout.ObjectField(defaultMaterial, typeof(Material), true) as Material; } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } } } if (!isSceneGUI) { EditorGUILayout.Space(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { EditorGUILayout.LabelField(ContentDefaultMaterial, largeLabelWidth); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginChangeCheck(); { defaultMaterial = EditorGUILayout.ObjectField(defaultMaterial, typeof(Material), true) as Material; } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } } GUILayout.Space(2); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { GUILayout.Space(5); defaultMaterial = CSG_EditorGUIUtility.MaterialImage(defaultMaterial, small: false); } GUILayout.EndHorizontal(); GUILayout.EndVertical(); } GUILayout.EndHorizontal(); /* * // Unity won't let us do this * GUILayout.BeginVertical(GUIStyleUtility.ContentEmpty); * OnGUIContentsMaterialInspector(first_material, multiple_materials); * GUILayout.EndVertical(); */ } GUILayout.EndVertical(); } EditorGUI.EndDisabledGroup(); }
/* * GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty); * { * * GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); * { * //GUILayout.Label(Keys.VerticalMoveMode.ToString() + " to dragging brush up/down", EditorStyles.miniLabel); * GUILayout.Label("Control (hold) to drag polygon on it's plane", EditorStyles.miniLabel); * GUILayout.Label("Shift (hold) to drag extrude polygon", EditorStyles.miniLabel); * GUILayout.Label("Shift (hold) to chamfer edges and vertices", EditorStyles.miniLabel); * } * GUILayout.EndVertical(); * } * GUILayout.EndHorizontal();*/ static void OnGUIContents(bool isSceneGUI, EditModeMeshEdit tool) { EditModeCommonGUI.StartToolGUI(); var filteredSelection = EditModeManager.FilteredSelection; var left = EditorStyles.miniButtonLeft; var middle = EditorStyles.miniButtonMid; var right = EditorStyles.miniButtonRight; var button = GUI.skin.button; var defaultMaterial = CSGSettings.DefaultMaterial; GUILayout.BeginVertical(isSceneGUI ? InSceneWidth : CSG_GUIStyleUtility.ContentEmpty); { ShowCSGOperations(isSceneGUI, tool, filteredSelection); GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); { var selectionIgnoreBackfaced = CSGSettings.HiddenSurfacesNotSelectable; var selectionVertex = CSGSettings.SelectionVertex; var selectionEdge = CSGSettings.SelectionEdge; var selectionSurface = CSGSettings.SelectionSurface; EditorGUILayout.LabelField(ContentSelection); EditorGUI.BeginChangeCheck(); { GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { selectionIgnoreBackfaced = GUILayout.Toggle(selectionIgnoreBackfaced, ContentIgnoreHidden, button); TooltipUtility.SetToolTip(TooltipIgnoreHidden); } GUILayout.EndHorizontal(); if (!selectionVertex && !selectionEdge && !selectionSurface) { GUILayout.Label("No selection mode has been selected and nothing can be selected", CSG_GUIStyleUtility.redTextArea); } GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { selectionVertex = GUILayout.Toggle(selectionVertex, ContentVertex, button); TooltipUtility.SetToolTip(TooltipVertex); selectionEdge = GUILayout.Toggle(selectionEdge, ContentEdge, button); TooltipUtility.SetToolTip(TooltipEdge); selectionSurface = GUILayout.Toggle(selectionSurface, ContentSurface, button); TooltipUtility.SetToolTip(TooltipSurface); } GUILayout.EndHorizontal(); } if (EditorGUI.EndChangeCheck()) { CSGSettings.HiddenSurfacesNotSelectable = selectionIgnoreBackfaced; CSGSettings.SelectionVertex = selectionVertex; CSGSettings.SelectionEdge = selectionEdge; CSGSettings.SelectionSurface = selectionSurface; CSGSettings.Save(); } GUILayout.Space(3); } GUILayout.EndVertical(); GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); { var autoCommitExtrusion = CSGSettings.AutoCommitExtrusion; EditorGUI.BeginChangeCheck(); { autoCommitExtrusion = GUILayout.Toggle(autoCommitExtrusion, ContentAutoCommitExtrusion, button); TooltipUtility.SetToolTip(TooltipAutoCommitExtrusion); } if (EditorGUI.EndChangeCheck()) { CSGSettings.AutoCommitExtrusion = autoCommitExtrusion; CSGSettings.Save(); } } GUILayout.EndVertical(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (isSceneGUI) { GUILayout.Space(4); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginChangeCheck(); { defaultMaterial = CSG_EditorGUIUtility.MaterialImage(defaultMaterial, small: true); } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } } GUILayout.EndVertical(); } bool have_nodes = tool != null && (filteredSelection.NodeTargets.Length > 0); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginDisabledGroup(!have_nodes); { GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (isSceneGUI) { EditorGUILayout.LabelField(ContentFlip, labelWidth); } else { EditorGUILayout.LabelField(ContentFlip, largeLabelWidth); } if (GUILayout.Button(ContentFlipX, left)) { tool.FlipX(); } TooltipUtility.SetToolTip(TooltipFlipX); if (GUILayout.Button(ContentFlipY, middle)) { tool.FlipY(); } TooltipUtility.SetToolTip(TooltipFlipY); if (GUILayout.Button(ContentFlipZ, right)) { tool.FlipZ(); } TooltipUtility.SetToolTip(TooltipFlipZ); } GUILayout.EndHorizontal(); /* * EditorGUILayout.LabelField(ContentEdgesLabel); * GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty); * { * EditorGUI.BeginDisabledGroup(!tool.CanSmooth()); * { * if (GUILayout.Button("Smooth")) { tool.Smooth(); } * } * EditorGUI.EndDisabledGroup(); * EditorGUI.BeginDisabledGroup(!tool.CanUnSmooth()); * { * if (GUILayout.Button("Un-smooth")) { tool.UnSmooth(); } * } * EditorGUI.EndDisabledGroup(); * } * GUILayout.EndHorizontal(); */ if (GUILayout.Button(ContentSnapToGrid)) { tool.SnapToGrid(Camera.current); } TooltipUtility.SetToolTip(TooltipSnapToGrid); } EditorGUI.EndDisabledGroup(); } GUILayout.EndVertical(); } GUILayout.EndHorizontal(); GUILayout.Space(2); if (!isSceneGUI) { EditorGUILayout.Space(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { EditorGUILayout.LabelField(ContentDefaultMaterial, largeLabelWidth); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginChangeCheck(); { defaultMaterial = EditorGUILayout.ObjectField(defaultMaterial, typeof(Material), true) as Material; } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } } GUILayout.Space(2); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { GUILayout.Space(5); defaultMaterial = CSG_EditorGUIUtility.MaterialImage(defaultMaterial, small: false); } GUILayout.EndHorizontal(); GUILayout.EndVertical(); } GUILayout.EndHorizontal(); /* * // Unity won't let us do this * GUILayout.BeginVertical(GUIStyleUtility.ContentEmpty); * OnGUIContentsMaterialInspector(first_material, multiple_materials); * GUILayout.EndVertical(); */ } else { EditorGUI.BeginChangeCheck(); { defaultMaterial = EditorGUILayout.ObjectField(defaultMaterial, typeof(Material), true) as Material; } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } } } GUILayout.EndVertical(); EditorGUI.showMixedValue = false; }
/* * static void OnGUIContentsMaterialInspector(Material material, bool mixedValues) * { * //if (materialEditor == null || prevMaterial != material) * { * var editor = materialEditor as Editor; * Editor.CreateCachedEditor(material, typeof(MaterialEditor), ref editor); * materialEditor = editor as MaterialEditor; * } * * if (materialEditor != null) * { * EditorGUI.showMixedValue = mixedValues; * try * { * materialEditor.DrawHeader(); * if (materialEditor.PropertiesGUI()) * { * materialEditor.PropertiesChanged(); * } * } * catch * {} * EditorGUI.showMixedValue = false; * } * } */ private static void OnGUIContents(bool isSceneGUI, EditModeSurface tool) { EditModeCommonGUI.StartToolGUI(); var selectedBrushSurfaces = (tool == null) ? new SelectedBrushSurface[0] : tool.GetSelectedSurfaces(); var enabled = selectedBrushSurfaces.Length > 0; EditorGUI.BeginDisabledGroup(!enabled); { Material material = null; var currentTexGen = new TexGen(); var haveTexgen = false; var multipleColors = !enabled; var multipleTranslationX = !enabled; var multipleTranslationY = !enabled; var multipleScaleX = !enabled; var multipleScaleY = !enabled; var multipleRotationAngle = !enabled; var multipleMaterials = !enabled; bool?textureLocked = null; bool foundHelperMaterial = false; RenderSurfaceType?firstRenderSurfaceType = null; Material firstMaterial = null; if (selectedBrushSurfaces.Length > 0) { for (var i = 0; i < selectedBrushSurfaces.Length; i++) { var brush = selectedBrushSurfaces[i].brush; if (!brush) { continue; } var surfaceIndex = selectedBrushSurfaces[i].surfaceIndex; if (surfaceIndex >= brush.Shape.Surfaces.Length) { Debug.LogWarning("surface_index >= brush.Shape.Surfaces.Length"); continue; } var texGenIndex = brush.Shape.Surfaces[surfaceIndex].TexGenIndex; if (texGenIndex >= brush.Shape.TexGens.Length) { Debug.LogWarning("texGen_index >= brush.Shape.TexGens.Length"); continue; } var brushCache = InternalCSGModelManager.GetBrushCache(brush); var model = (brushCache != null) ? brushCache.childData.Model : null; Material foundMaterial; var texGenFlags = brush.Shape.TexGenFlags[texGenIndex]; if (model && (!model.IsRenderable || model.ShadowsOnly)) { foundHelperMaterial = true; if (!firstRenderSurfaceType.HasValue) { firstRenderSurfaceType = ModelTraits.GetModelSurfaceType(model); } foundMaterial = null; } else if ((texGenFlags & TexGenFlags.NoRender) == TexGenFlags.NoRender) { foundHelperMaterial = true; if (!firstRenderSurfaceType.HasValue) { if ((texGenFlags & TexGenFlags.NoCastShadows) != TexGenFlags.NoCastShadows) { firstRenderSurfaceType = RenderSurfaceType.ShadowOnly; } else if ((texGenFlags & TexGenFlags.NoCollision) != TexGenFlags.NoCollision) { firstRenderSurfaceType = RenderSurfaceType.Collider; } else { firstRenderSurfaceType = RenderSurfaceType.Hidden; } } foundMaterial = null; } else { var surfaceMaterial = brush.Shape.TexGens[texGenIndex].RenderMaterial; if (!foundHelperMaterial) { var surfaceType = MaterialUtility.GetMaterialSurfaceType(surfaceMaterial); if (!firstRenderSurfaceType.HasValue) { firstRenderSurfaceType = surfaceType; } foundHelperMaterial = surfaceType != RenderSurfaceType.Normal; } foundMaterial = surfaceMaterial; } if ((texGenFlags & TexGenFlags.WorldSpaceTexture) == TexGenFlags.WorldSpaceTexture) { if (i == 0) { textureLocked = false; } else if (textureLocked.HasValue && textureLocked.Value) { textureLocked = null; } } else { if (i == 0) { textureLocked = true; } else if (textureLocked.HasValue && !textureLocked.Value) { textureLocked = null; } } if (foundMaterial != material) { if (!material) { firstMaterial = foundMaterial; material = foundMaterial; } else { multipleMaterials = true; } } if (!haveTexgen) { currentTexGen = brush.Shape.TexGens[texGenIndex]; haveTexgen = true; } else { if (!multipleColors) { var color = brush.Shape.TexGens[texGenIndex].Color; multipleColors = currentTexGen.Color.a != color.a || currentTexGen.Color.b != color.b || currentTexGen.Color.g != color.g || currentTexGen.Color.r != color.r; } if (!multipleScaleX || !multipleScaleY) { var scale = brush.Shape.TexGens[texGenIndex].Scale; multipleScaleX = multipleScaleX || currentTexGen.Scale.x != scale.x; multipleScaleY = multipleScaleY || currentTexGen.Scale.y != scale.y; } if (!multipleTranslationX || !multipleTranslationY) { var translation = brush.Shape.TexGens[texGenIndex].Translation; multipleTranslationX = multipleTranslationX || currentTexGen.Translation.x != translation.x; multipleTranslationY = multipleTranslationY || currentTexGen.Translation.y != translation.y; } if (!multipleRotationAngle) { var rotationAngle = brush.Shape.TexGens[texGenIndex].RotationAngle; multipleRotationAngle = currentTexGen.RotationAngle != rotationAngle; } } } if (foundHelperMaterial && !firstMaterial) { if (firstRenderSurfaceType.HasValue) { firstMaterial = MaterialUtility.GetSurfaceMaterial(firstRenderSurfaceType.Value); } else { firstMaterial = MaterialUtility.HiddenMaterial; } } } GUILayout.BeginVertical(isSceneGUI ? materialDoubleWidth : CSG_GUIStyleUtility.ContentEmpty); { GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); { /* * Color new_color; * EditorGUI.BeginChangeCheck(); * { * EditorGUI.showMixedValue = multipleColors; * // why doesn't the colorfield return a modified color? * try * { * new_color = EditorGUILayout.ColorField(GUIContent.none, currentTexGen.Color); * } * catch * { * new_color = currentTexGen.Color; * } * } * if (EditorGUI.EndChangeCheck() || currentTexGen.Color != new_color) * { * SurfaceUtility.SetColors(selectedBrushSurfaces, new_color); * } */ if (isSceneGUI) { GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginDisabledGroup(material == null); { GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { GUILayout.Space(1); /* * Color new_color; * EditorGUI.BeginChangeCheck(); * { * EditorGUI.showMixedValue = multipleColors; * // why doesn't the colorfield return a modified color? * try * { * new_color = EditorGUILayout.ColorField(GUIContent.none, currentTexGen.Color); * } * catch * { * new_color = currentTexGen.Color; * } * } * if (EditorGUI.EndChangeCheck() || currentTexGen.Color != new_color) * { * SurfaceUtility.SetColors(selectedBrushSurfaces, new_color); * } * * GUILayout.Space(1); */ Material newMaterial; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = multipleMaterials; newMaterial = EditorGUILayout.ObjectField(material, typeof(Material), true) as Material; EditorGUI.showMixedValue = false; } if (EditorGUI.EndChangeCheck()) { if (newMaterial) { SurfaceUtility.SetMaterials(selectedBrushSurfaces, newMaterial); CSGSettings.DefaultMaterial = newMaterial; CSGSettings.Save(); } } } GUILayout.EndVertical(); GUILayout.Space(1); } EditorGUI.EndDisabledGroup(); } GUILayout.EndHorizontal(); GUILayout.Space(4); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { GUILayout.Space(2); OnGUIContentsMaterialImage(isSceneGUI, firstMaterial, multipleMaterials, selectedBrushSurfaces); GUILayout.BeginHorizontal(materialWidth); { GUILayout.FlexibleSpace(); GUILayout.BeginVertical(materialHeight); { OnGUIContentsJustify(isSceneGUI, selectedBrushSurfaces); GUILayout.FlexibleSpace(); } GUILayout.EndVertical(); } GUILayout.EndHorizontal(); GUILayout.FlexibleSpace(); } GUILayout.EndHorizontal(); } } GUILayout.EndVertical(); if (!isSceneGUI) { EditorGUILayout.Space(); } if (currentTexGen.Scale.x == 0.0f) { currentTexGen.Scale.x = 1.0f; } if (currentTexGen.Scale.y == 0.0f) { currentTexGen.Scale.y = 1.0f; } const float scale_round = 10000.0f; currentTexGen.Scale.x = Mathf.RoundToInt(currentTexGen.Scale.x * scale_round) / scale_round; currentTexGen.Scale.y = Mathf.RoundToInt(currentTexGen.Scale.y * scale_round) / scale_round; currentTexGen.Translation.x = Mathf.RoundToInt(currentTexGen.Translation.x * scale_round) / scale_round; currentTexGen.Translation.y = Mathf.RoundToInt(currentTexGen.Translation.y * scale_round) / scale_round; currentTexGen.RotationAngle = Mathf.RoundToInt(currentTexGen.RotationAngle * scale_round) / scale_round; var leftStyle = isSceneGUI ? EditorStyles.miniButtonLeft : GUI.skin.button; var middleStyle = isSceneGUI ? EditorStyles.miniButtonMid : GUI.skin.button; var rightStyle = isSceneGUI ? EditorStyles.miniButtonRight : GUI.skin.button; GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); { EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !textureLocked.HasValue; textureLocked = EditorGUILayout.ToggleLeft(ContentLockTexture, textureLocked.HasValue ? textureLocked.Value : false); TooltipUtility.SetToolTip(ToolTipLockTexture); } if (EditorGUI.EndChangeCheck()) { SurfaceUtility.SetTextureLock(selectedBrushSurfaces, textureLocked.Value); } } GUILayout.EndVertical(); GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); { GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (isSceneGUI) { EditorGUILayout.LabelField(ContentUVScale, EditorStyles.miniLabel, labelWidth); } else { EditorGUILayout.LabelField(ContentUVScale, largeLabelWidth); } TooltipUtility.SetToolTip(ToolTipScaleUV); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (!isSceneGUI) { EditorGUILayout.LabelField(ContentUSymbol, unitWidth); } EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = multipleScaleX; currentTexGen.Scale.x = EditorGUILayout.FloatField(currentTexGen.Scale.x, minFloatFieldWidth); } if (EditorGUI.EndChangeCheck()) { SurfaceUtility.SetScaleX(selectedBrushSurfaces, currentTexGen.Scale.x); } if (!isSceneGUI) { EditorGUILayout.LabelField(ContentVSymbol, unitWidth); } EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = multipleScaleY; currentTexGen.Scale.y = EditorGUILayout.FloatField(currentTexGen.Scale.y, minFloatFieldWidth); } if (EditorGUI.EndChangeCheck()) { SurfaceUtility.SetScaleY(selectedBrushSurfaces, currentTexGen.Scale.y); } } GUILayout.EndHorizontal(); } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (isSceneGUI) { EditorGUILayout.LabelField(ContentOffset, EditorStyles.miniLabel, labelWidth); } else { EditorGUILayout.LabelField(ContentOffset, largeLabelWidth); } TooltipUtility.SetToolTip(ToolTipOffsetUV); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (!isSceneGUI) { EditorGUILayout.LabelField(ContentUSymbol, unitWidth); } EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = multipleTranslationX; currentTexGen.Translation.x = EditorGUILayout.FloatField(currentTexGen.Translation.x, minFloatFieldWidth); } if (EditorGUI.EndChangeCheck()) { SurfaceUtility.SetTranslationX(selectedBrushSurfaces, currentTexGen.Translation.x); } if (!isSceneGUI) { EditorGUILayout.LabelField(ContentVSymbol, unitWidth); } EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = multipleTranslationY; currentTexGen.Translation.y = EditorGUILayout.FloatField(currentTexGen.Translation.y, minFloatFieldWidth); } if (EditorGUI.EndChangeCheck()) { SurfaceUtility.SetTranslationY(selectedBrushSurfaces, currentTexGen.Translation.y); } } GUILayout.EndHorizontal(); } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (isSceneGUI) { EditorGUILayout.LabelField(ContentRotate, EditorStyles.miniLabel, labelWidth); } else { EditorGUILayout.LabelField(ContentRotate, largeLabelWidth); } TooltipUtility.SetToolTip(ToolTipRotation); if (!isSceneGUI) { GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); } GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = multipleRotationAngle; currentTexGen.RotationAngle = EditorGUILayout.FloatField(currentTexGen.RotationAngle, minFloatFieldWidth); if (!isSceneGUI) { EditorGUILayout.LabelField(ContentAngleSymbol, unitWidth); } } if (EditorGUI.EndChangeCheck()) { SurfaceUtility.SetRotationAngle(selectedBrushSurfaces, currentTexGen.RotationAngle); } } GUILayout.EndHorizontal(); var buttonWidth = isSceneGUI ? new GUILayoutOption[] { angleButtonWidth } : new GUILayoutOption[0]; GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (GUILayout.Button(ContentRotate90Negative, leftStyle, buttonWidth)) { SurfaceUtility.AddRotationAngle(selectedBrushSurfaces, -90.0f); } TooltipUtility.SetToolTip(ToolTipRotate90Negative); if (GUILayout.Button(ContentRotate90Positive, rightStyle, buttonWidth)) { SurfaceUtility.AddRotationAngle(selectedBrushSurfaces, +90.0f); } TooltipUtility.SetToolTip(ToolTipRotate90Positive); } GUILayout.EndHorizontal(); if (!isSceneGUI) { GUILayout.EndVertical(); } } GUILayout.EndHorizontal(); } GUILayout.EndVertical(); if (!isSceneGUI) { EditorGUILayout.Space(); } GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); { GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (!isSceneGUI) { GUILayout.Label(ContentFit, largeLabelWidth); } else { GUILayout.Label(ContentFit, EditorStyles.miniLabel, smallLabelWidth); } if (GUILayout.Button(ContentFitX, leftStyle)) { SurfaceUtility.FitSurfaceX(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipFitX); if (GUILayout.Button(ContentFitXY, middleStyle)) { SurfaceUtility.FitSurface(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipFitXY); if (GUILayout.Button(ContentFitY, rightStyle)) { SurfaceUtility.FitSurfaceY(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipFitY); } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (!isSceneGUI) { GUILayout.Label(ContentReset, largeLabelWidth); } else { GUILayout.Label(ContentReset, EditorStyles.miniLabel, smallLabelWidth); } if (GUILayout.Button(ContentResetX, leftStyle)) { SurfaceUtility.ResetSurfaceX(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipResetX); if (GUILayout.Button(ContentResetXY, middleStyle)) { SurfaceUtility.ResetSurface(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipResetXY); if (GUILayout.Button(ContentResetY, rightStyle)) { SurfaceUtility.ResetSurfaceY(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipResetY); } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (!isSceneGUI) { GUILayout.Label(ContentFlip, largeLabelWidth); } else { GUILayout.Label(ContentFlip, EditorStyles.miniLabel, smallLabelWidth); } if (GUILayout.Button(ContentFlipX, leftStyle)) { SurfaceUtility.FlipX(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipFlipX); if (GUILayout.Button(ContentFlipXY, middleStyle)) { SurfaceUtility.FlipXY(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipFlipXY); if (GUILayout.Button(ContentFlipY, rightStyle)) { SurfaceUtility.FlipY(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipFlipY); } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (!isSceneGUI) { GUILayout.Label(ContentScale, largeLabelWidth); } else { GUILayout.Label(ContentScale, EditorStyles.miniLabel, smallLabelWidth); } if (GUILayout.Button(ContentDoubleScale, leftStyle)) { SurfaceUtility.MultiplyScale(selectedBrushSurfaces, 2.0f); } TooltipUtility.SetToolTip(ToolTipDoubleScale); if (GUILayout.Button(ContentHalfScale, rightStyle)) { SurfaceUtility.MultiplyScale(selectedBrushSurfaces, 0.5f); } TooltipUtility.SetToolTip(ToolTipHalfScale); } GUILayout.EndHorizontal(); } GUILayout.EndVertical(); if (!isSceneGUI) { EditorGUILayout.Space(); } if (!isSceneGUI) { OnGUIContentsJustify(isSceneGUI, selectedBrushSurfaces); } if (!isSceneGUI) { EditorGUILayout.Space(); } GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); { EditModeCommonGUI.OnSurfaceFlagButtons(selectedBrushSurfaces, isSceneGUI); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginDisabledGroup(!SurfaceUtility.CanSmooth(selectedBrushSurfaces)); { if (GUILayout.Button(ContentSmoothSurfaces, leftStyle)) { SurfaceUtility.Smooth(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipSmoothSurfaces); } EditorGUI.EndDisabledGroup(); EditorGUI.BeginDisabledGroup(!SurfaceUtility.CanUnSmooth(selectedBrushSurfaces)); { if (GUILayout.Button(ContentUnSmoothSurfaces, rightStyle)) { SurfaceUtility.UnSmooth(selectedBrushSurfaces); } TooltipUtility.SetToolTip(ToolTipUnSmoothSurfaces); } EditorGUI.EndDisabledGroup(); } GUILayout.EndHorizontal(); } GUILayout.EndVertical(); if (!isSceneGUI) { EditorGUILayout.Space(); Material new_material; GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { EditorGUILayout.LabelField(ContentMaterial, largeLabelWidth); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = multipleMaterials; new_material = EditorGUILayout.ObjectField(material, typeof(Material), true) as Material; EditorGUI.showMixedValue = false; } if (EditorGUI.EndChangeCheck()) { if (!new_material) { new_material = MaterialUtility.MissingMaterial; } SurfaceUtility.SetMaterials(selectedBrushSurfaces, new_material); } } GUILayout.Space(2); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { GUILayout.Space(5); OnGUIContentsMaterialImage(isSceneGUI, firstMaterial, multipleMaterials, selectedBrushSurfaces); } GUILayout.EndHorizontal(); GUILayout.EndVertical(); } GUILayout.EndHorizontal(); // Unity won't let us do this //GUILayout.BeginVertical(GUIStyleUtility.ContentEmpty); //OnGUIContentsMaterialInspector(first_material, multiple_materials); //GUILayout.EndVertical(); } } GUILayout.EndVertical(); } EditorGUI.EndDisabledGroup(); EditorGUI.showMixedValue = false; }
static void OnGUIContents(EditModeGenerate tool, bool isSceneGUI, float height) { if (!isSceneGUI) { Rect shapeModeBounds; var csg_skin = CSG_GUIStyleUtility.Skin; tool.BuilderMode = (ShapeMode)CSG_EditorGUIUtility.ToolbarWrapped((int)tool.BuilderMode, ref shapeModeRects, out shapeModeBounds, csg_skin.shapeModeNames, tooltips: CSG_GUIStyleUtility.shapeModeTooltips, yOffset: height, areaWidth: EditorGUIUtility.currentViewWidth - 4); GUILayout.Space(shapeModeBounds.height); EditModeCommonGUI.StartToolGUI(); scrollPos = EditorGUILayout.BeginScrollView(scrollPos); { ChooseOperation(tool, isSceneGUI); tool.CurrentGenerator.OnShowGUI(isSceneGUI); CommitOrCancel(isSceneGUI, tool); EditorGUILayout.Space(); var defaultMaterial = CSGSettings.DefaultMaterial; GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { EditorGUILayout.LabelField(ContentDefaultMaterial, largeLabelWidth); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginChangeCheck(); { defaultMaterial = EditorGUILayout.ObjectField(defaultMaterial, typeof(Material), true) as Material; } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; tool.CurrentGenerator.OnDefaultMaterialModified(); CSGSettings.Save(); } } GUILayout.Space(2); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { GUILayout.Space(5); EditorGUI.BeginChangeCheck(); { defaultMaterial = CSG_EditorGUIUtility.MaterialImage(defaultMaterial, small: false); } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; tool.CurrentGenerator.OnDefaultMaterialModified(); CSGSettings.Save(); } } GUILayout.EndHorizontal(); GUILayout.EndVertical(); } GUILayout.EndHorizontal(); /* * // Unity won't let us do this * GUILayout.BeginVertical(GUIStyleUtility.ContentEmpty); * OnGUIContentsMaterialInspector(first_material, multiple_materials); * GUILayout.EndVertical(); */ } EditorGUILayout.EndScrollView(); } if (isSceneGUI) { GUILayout.BeginHorizontal(GUILayout.MinHeight(100)); { GUILayout.BeginVertical(GUILayout.Width(100)); { GUILayout.FlexibleSpace(); var rect = GUILayoutUtility.GetLastRect(); var csg_skin = CSG_GUIStyleUtility.Skin; Rect shapeModeBounds; tool.BuilderMode = (ShapeMode)CSG_EditorGUIUtility.ToolbarWrapped((int)tool.BuilderMode, ref shapeModeRects, out shapeModeBounds, csg_skin.shapeModeNames, tooltips: CSG_GUIStyleUtility.shapeModeTooltips, yOffset: rect.y, xOffset: rect.x, areaWidth: 100); GUILayout.Space(shapeModeBounds.height); ChooseOperation(tool, isSceneGUI); } GUILayout.EndVertical(); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { tool.CurrentGenerator.OnShowGUI(isSceneGUI); GUILayout.FlexibleSpace(); CommitOrCancel(isSceneGUI, tool); } GUILayout.EndVertical(); } GUILayout.EndHorizontal(); } }
public static void OnInspectorGUI(UnityEngine.Object[] targets) { InitReflection(); if (!localStyles) { popupStyle = new GUIStyle(EditorStyles.popup); //popupStyle.padding.top += 2; popupStyle.margin.top += 2; localStyles = true; } bool updateMeshes = false; var models = new CSGModel[targets.Length]; for (int i = targets.Length - 1; i >= 0; i--) { models[i] = targets[i] as CSGModel; if (!models[i]) { ArrayUtility.RemoveAt(ref models, i); } } if (models.Length == 0) { return; } var settings = models[0].Settings; var vertexChannels = models[0].VertexChannels; ExportType? exportType = models[0].exportType; OriginType? originType = models[0].originType; bool? exportColliders = models[0].exportColliders; bool? VertexChannelColor = (vertexChannels & VertexChannelFlags.Color) == VertexChannelFlags.Color; bool? VertexChannelTangent = (vertexChannels & VertexChannelFlags.Tangent) == VertexChannelFlags.Tangent; bool? VertexChannelNormal = (vertexChannels & VertexChannelFlags.Normal) == VertexChannelFlags.Normal; bool? VertexChannelUV0 = (vertexChannels & VertexChannelFlags.UV0) == VertexChannelFlags.UV0; bool? InvertedWorld = (settings & ModelSettingsFlags.InvertedWorld) == ModelSettingsFlags.InvertedWorld; bool? NoCollider = (settings & ModelSettingsFlags.NoCollider) == ModelSettingsFlags.NoCollider; bool? IsTrigger = (settings & ModelSettingsFlags.IsTrigger) == ModelSettingsFlags.IsTrigger; bool? SetToConvex = (settings & ModelSettingsFlags.SetColliderConvex) == ModelSettingsFlags.SetColliderConvex; bool? AutoGenerateRigidBody = (settings & ModelSettingsFlags.AutoUpdateRigidBody) == ModelSettingsFlags.AutoUpdateRigidBody; bool? DoNotRender = (settings & ModelSettingsFlags.DoNotRender) == ModelSettingsFlags.DoNotRender; bool? ReceiveShadows = !((settings & ModelSettingsFlags.DoNotReceiveShadows) == ModelSettingsFlags.DoNotReceiveShadows); bool? AutoRebuildUVs = (settings & ModelSettingsFlags.AutoRebuildUVs) == ModelSettingsFlags.AutoRebuildUVs; bool? AutoRebuildColliders = (settings & ModelSettingsFlags.NoAutoRebuildColliders) != ModelSettingsFlags.NoAutoRebuildColliders; bool? PreserveUVs = (settings & ModelSettingsFlags.PreserveUVs) == ModelSettingsFlags.PreserveUVs; bool? ShowGeneratedMeshes = models[0].ShowGeneratedMeshes; ShadowCastingMode?ShadowCastingMode = (ShadowCastingMode)(settings & ModelSettingsFlags.ShadowCastingModeFlags); var defaultPhysicsMaterial = models[0].DefaultPhysicsMaterial; var defaultPhysicsMaterialMixed = false; for (int i = 1; i < models.Length; i++) { settings = models[i].Settings; vertexChannels = models[i].VertexChannels; ExportType currExportType = models[i].exportType; OriginType currOriginType = models[i].originType; bool currExportColliders = models[i].exportColliders; bool currVertexChannelColor = (vertexChannels & VertexChannelFlags.Color) == VertexChannelFlags.Color; bool currVertexChannelTangent = (vertexChannels & VertexChannelFlags.Tangent) == VertexChannelFlags.Tangent; bool currVertexChannelNormal = (vertexChannels & VertexChannelFlags.Normal) == VertexChannelFlags.Normal; bool currVertexChannelUV0 = (vertexChannels & VertexChannelFlags.UV0) == VertexChannelFlags.UV0; bool currInvertedWorld = (settings & ModelSettingsFlags.InvertedWorld) == ModelSettingsFlags.InvertedWorld; bool currNoCollider = (settings & ModelSettingsFlags.NoCollider) == ModelSettingsFlags.NoCollider; bool currIsTrigger = (settings & ModelSettingsFlags.IsTrigger) == ModelSettingsFlags.IsTrigger; bool currSetToConvex = (settings & ModelSettingsFlags.SetColliderConvex) == ModelSettingsFlags.SetColliderConvex; bool currAutoGenerateRigidBody = (settings & ModelSettingsFlags.AutoUpdateRigidBody) == ModelSettingsFlags.AutoUpdateRigidBody; bool currDoNotRender = (settings & ModelSettingsFlags.DoNotRender) == ModelSettingsFlags.DoNotRender; bool currReceiveShadows = !((settings & ModelSettingsFlags.DoNotReceiveShadows) == ModelSettingsFlags.DoNotReceiveShadows); bool currAutoRebuildUVs = (settings & ModelSettingsFlags.AutoRebuildUVs) == ModelSettingsFlags.AutoRebuildUVs; bool currAutoRebuildColliders = (settings & ModelSettingsFlags.NoAutoRebuildColliders) != ModelSettingsFlags.NoAutoRebuildColliders; bool currPreserveUVs = (settings & ModelSettingsFlags.PreserveUVs) == ModelSettingsFlags.PreserveUVs; bool currShowGeneratedMeshes = models[i].ShowGeneratedMeshes; var currdefaultPhysicsMaterial = models[i].DefaultPhysicsMaterial; ShadowCastingMode currShadowCastingMode = (ShadowCastingMode)(settings & ModelSettingsFlags.ShadowCastingModeFlags); if (VertexChannelColor.HasValue && VertexChannelColor.Value != currVertexChannelColor) { VertexChannelColor = null; } if (VertexChannelTangent.HasValue && VertexChannelTangent.Value != currVertexChannelTangent) { VertexChannelTangent = null; } if (VertexChannelNormal.HasValue && VertexChannelNormal.Value != currVertexChannelNormal) { VertexChannelNormal = null; } if (VertexChannelUV0.HasValue && VertexChannelUV0.Value != currVertexChannelUV0) { VertexChannelUV0 = null; } if (exportType.HasValue && exportType.Value != currExportType) { exportType = null; } if (originType.HasValue && originType.Value != currOriginType) { originType = null; } if (exportColliders.HasValue && exportColliders.Value != currExportColliders) { exportColliders = null; } if (InvertedWorld.HasValue && InvertedWorld.Value != currInvertedWorld) { InvertedWorld = null; } if (NoCollider.HasValue && NoCollider.Value != currNoCollider) { NoCollider = null; } if (IsTrigger.HasValue && IsTrigger.Value != currIsTrigger) { IsTrigger = null; } if (SetToConvex.HasValue && SetToConvex.Value != currSetToConvex) { SetToConvex = null; } if (AutoGenerateRigidBody.HasValue && AutoGenerateRigidBody.Value != currAutoGenerateRigidBody) { AutoGenerateRigidBody = null; } if (DoNotRender.HasValue && DoNotRender.Value != currDoNotRender) { DoNotRender = null; } if (ReceiveShadows.HasValue && ReceiveShadows.Value != currReceiveShadows) { ReceiveShadows = null; } if (ShadowCastingMode.HasValue && ShadowCastingMode.Value != currShadowCastingMode) { ShadowCastingMode = null; } if (AutoRebuildUVs.HasValue && AutoRebuildUVs.Value != currAutoRebuildUVs) { AutoRebuildUVs = null; } if (AutoRebuildColliders.HasValue && AutoRebuildColliders.Value != currAutoRebuildColliders) { AutoRebuildColliders = null; } if (PreserveUVs.HasValue && PreserveUVs.Value != currPreserveUVs) { PreserveUVs = null; } if (ShowGeneratedMeshes.HasValue && ShowGeneratedMeshes.Value != currShowGeneratedMeshes) { ShowGeneratedMeshes = null; } if (defaultPhysicsMaterial != currdefaultPhysicsMaterial) { defaultPhysicsMaterialMixed = true; } } GUILayout.BeginVertical(GUI.skin.box); { EditorGUILayout.LabelField("Behaviour"); EditorGUI.indentLevel++; { bool inverted_world = InvertedWorld.HasValue ? InvertedWorld.Value : false; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !InvertedWorld.HasValue; inverted_world = EditorGUILayout.Toggle(InvertedWorldContent, inverted_world); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (inverted_world) { models[i].Settings |= ModelSettingsFlags.InvertedWorld; } else { models[i].Settings &= ~ModelSettingsFlags.InvertedWorld; } } GUI.changed = true; InvertedWorld = inverted_world; } } EditorGUI.indentLevel--; } GUILayout.EndVertical(); if (models != null && models.Length == 1) { GUILayout.Space(10); GUILayout.BeginVertical(GUI.skin.box); { EditorGUILayout.LabelField(ExportLabel); { GUILayout.BeginHorizontal(); { GUILayout.Space(20); EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !originType.HasValue; originType = (OriginType)EditorGUILayout.EnumPopup(ExportOriginLabel, originType ?? OriginType.ModelCenter, popupStyle); EditorGUI.showMixedValue = false; } if (EditorGUI.EndChangeCheck() && originType.HasValue) { for (int i = 0; i < models.Length; i++) { models[i].originType = originType.Value; } } } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); { GUILayout.Space(20); var exportColliderToggle = exportColliders ?? true; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !originType.HasValue; exportColliderToggle = EditorGUILayout.Toggle(ExportColliderLabel, exportColliderToggle); EditorGUI.showMixedValue = false; } if (EditorGUI.EndChangeCheck() && originType.HasValue) { for (int i = 0; i < models.Length; i++) { models[i].exportColliders = exportColliderToggle; } exportColliders = exportColliderToggle; } } GUILayout.EndHorizontal(); GUILayout.BeginHorizontal(); { GUILayout.Space(20); EditorGUI.BeginDisabledGroup(!exportType.HasValue); { if (GUILayout.Button(ExportToButtonLabel) && exportType.HasValue) { #if !EVALUATION MeshInstanceManager.Export(models[0], exportType.Value, exportColliders ?? true); #else Debug.LogWarning("Export is disabled in evaluation version"); #endif } } EditorGUI.EndDisabledGroup(); EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !exportType.HasValue; exportType = (ExportType)EditorGUILayout.EnumPopup(exportType ?? ExportType.FBX, popupStyle); EditorGUI.showMixedValue = false; } if (EditorGUI.EndChangeCheck() && exportType.HasValue) { for (int i = 0; i < models.Length; i++) { models[i].exportType = exportType.Value; } } } GUILayout.EndHorizontal(); } } GUILayout.EndVertical(); } GUILayout.Space(10); GUILayout.BeginVertical(GUI.skin.box); { EditorGUILayout.LabelField("Physics"); EditorGUI.indentLevel++; { bool collider_value = NoCollider.HasValue ? NoCollider.Value : false; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !NoCollider.HasValue; collider_value = !EditorGUILayout.Toggle(GenerateColliderContent, !collider_value); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (collider_value) { models[i].Settings |= ModelSettingsFlags.NoCollider; } else { models[i].Settings &= ~ModelSettingsFlags.NoCollider; } } GUI.changed = true; NoCollider = collider_value; updateMeshes = true; } } { EditorGUI.indentLevel++; var autoRebuildColliders = AutoRebuildColliders ?? false; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !AutoRebuildUVs.HasValue; autoRebuildColliders = EditorGUILayout.Toggle(AutoRebuildCollidersContent, autoRebuildColliders); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (autoRebuildColliders) { models[i].Settings &= ~ModelSettingsFlags.NoAutoRebuildColliders; } else { models[i].Settings |= ModelSettingsFlags.NoAutoRebuildColliders; } } GUI.changed = true; AutoRebuildColliders = autoRebuildColliders; updateMeshes = true; } EditorGUI.indentLevel--; } var have_no_collider = NoCollider.HasValue && NoCollider.Value; EditorGUI.BeginDisabledGroup(have_no_collider); { bool trigger_value_mixed = have_no_collider ? true : !IsTrigger.HasValue; bool trigger_value = IsTrigger.HasValue ? IsTrigger.Value : false; { EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = trigger_value_mixed; trigger_value = EditorGUILayout.Toggle(ModelIsTriggerContent, trigger_value); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (trigger_value) { models[i].Settings |= ModelSettingsFlags.IsTrigger; } else { models[i].Settings &= ~ModelSettingsFlags.IsTrigger; } } GUI.changed = true; IsTrigger = trigger_value; updateMeshes = true; } } bool set_convex_value_mixed = have_no_collider ? true : !SetToConvex.HasValue; bool set_convex_value = have_no_collider ? false : (SetToConvex.HasValue ? SetToConvex.Value : false); { EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = set_convex_value_mixed; var prevColor = GUI.color; if (!set_convex_value && trigger_value) { var color = new Color(1, 0.25f, 0.25f); GUI.color = color; } set_convex_value = EditorGUILayout.Toggle(ColliderSetToConvexContent, set_convex_value); GUI.color = prevColor; } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (set_convex_value) { models[i].Settings |= ModelSettingsFlags.SetColliderConvex; } else { models[i].Settings &= ~ModelSettingsFlags.SetColliderConvex; } } GUI.changed = true; SetToConvex = set_convex_value; updateMeshes = true; } } { EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = defaultPhysicsMaterialMixed; GUILayout.BeginHorizontal(); EditorGUILayout.PrefixLabel(DefaultPhysicsMaterialContent); defaultPhysicsMaterial = EditorGUILayout.ObjectField(defaultPhysicsMaterial, typeof(PhysicMaterial), true) as PhysicMaterial; GUILayout.EndHorizontal(); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { models[i].DefaultPhysicsMaterial = defaultPhysicsMaterial; } GUI.changed = true; //MeshInstanceManager.Clear(); updateMeshes = true; } } if (!have_no_collider && !set_convex_value && trigger_value) { var prevColor = GUI.color; var color = new Color(1, 0.25f, 0.25f); GUI.color = color; GUILayout.Label("Warning:\r\nFor performance reasons colliders need to\r\nbe convex!"); GUI.color = prevColor; } } EditorGUI.EndDisabledGroup(); { bool autoRigidbody = (AutoGenerateRigidBody.HasValue ? AutoGenerateRigidBody.Value : false); EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !AutoGenerateRigidBody.HasValue; autoRigidbody = !EditorGUILayout.Toggle(ColliderAutoRigidBodyContent, !autoRigidbody); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (autoRigidbody) { models[i].Settings |= ModelSettingsFlags.AutoUpdateRigidBody; } else { models[i].Settings &= ~ModelSettingsFlags.AutoUpdateRigidBody; } } GUI.changed = true; AutoGenerateRigidBody = autoRigidbody; } } EditorGUI.indentLevel--; } GUILayout.EndVertical(); GUILayout.Space(10); GUILayout.BeginVertical(GUI.skin.box); { ShadowCastingMode shadowcastingValue = ShadowCastingMode.HasValue ? ShadowCastingMode.Value : UnityEngine.Rendering.ShadowCastingMode.On; var castOnlyShadow = (shadowcastingValue == UnityEngine.Rendering.ShadowCastingMode.ShadowsOnly); EditorGUILayout.LabelField("Rendering"); EditorGUI.indentLevel++; EditorGUI.BeginDisabledGroup(castOnlyShadow); { bool donotrender_value = castOnlyShadow ? true : (DoNotRender.HasValue ? DoNotRender.Value : false); EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = castOnlyShadow ? true : !DoNotRender.HasValue; donotrender_value = EditorGUILayout.Toggle(DoNotRenderContent, donotrender_value); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (donotrender_value) { models[i].Settings |= ModelSettingsFlags.DoNotRender; } else { models[i].Settings &= ~ModelSettingsFlags.DoNotRender; } } GUI.changed = true; DoNotRender = donotrender_value; updateMeshes = true; } } EditorGUI.EndDisabledGroup(); GUILayout.Space(10); EditorGUI.BeginDisabledGroup(DoNotRender.HasValue && DoNotRender.Value); { EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !ShadowCastingMode.HasValue; shadowcastingValue = (ShadowCastingMode)EditorGUILayout.EnumPopup(CastShadows, shadowcastingValue); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { settings = models[i].Settings; settings &= ~ModelSettingsFlags.ShadowCastingModeFlags; settings |= (ModelSettingsFlags)(((int)shadowcastingValue) & (int)ModelSettingsFlags.ShadowCastingModeFlags); models[i].Settings = settings; } GUI.changed = true; ShadowCastingMode = shadowcastingValue; updateMeshes = true; } var isUsingDeferredRenderingPath = false; //IsUsingDeferredRenderingPath(); EditorGUI.BeginDisabledGroup(castOnlyShadow || isUsingDeferredRenderingPath); { var receiveshadowsValue = !castOnlyShadow && (isUsingDeferredRenderingPath || (ReceiveShadows ?? false)); EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = (castOnlyShadow || !ReceiveShadows.HasValue) && !isUsingDeferredRenderingPath; receiveshadowsValue = EditorGUILayout.Toggle(CSGModelComponentInspectorGUI.ReceiveShadowsContent, receiveshadowsValue || isUsingDeferredRenderingPath); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (receiveshadowsValue) { models[i].Settings &= ~ModelSettingsFlags.DoNotReceiveShadows; } else { models[i].Settings |= ModelSettingsFlags.DoNotReceiveShadows; } } GUI.changed = true; ReceiveShadows = receiveshadowsValue; } } EditorGUI.EndDisabledGroup(); } EditorGUI.EndDisabledGroup(); EditorGUI.BeginDisabledGroup(castOnlyShadow); EditorGUI.showMixedValue = false; UpdateTargets(models); if (_probesInstance != null && _probesOnGUIMethod != null && _probesTargets != null && _probesSerializedObject != null && _probesInitialized) { GUILayout.Space(10); try { #if UNITY_5_6_OR_NEWER _probesSerializedObject.UpdateIfRequiredOrScript(); #else _probesSerializedObject.UpdateIfDirtyOrScript(); #endif _probesOnGUIMethod.Invoke(_probesInstance, new System.Object[] { _probesTargets, (Renderer)_probesTargets[0], false }); _probesSerializedObject.ApplyModifiedProperties(); } catch { } } EditorGUI.EndDisabledGroup(); EditorGUI.indentLevel--; } GUILayout.EndVertical(); GUILayout.Space(10); GUILayout.BeginVertical(GUI.skin.box); { EditorGUILayout.LabelField("Lighting"); EditorGUI.indentLevel++; { EditorGUI.indentLevel++; EditModeCommonGUI.UpdateButtons(models); EditorGUI.indentLevel--; EditorGUILayout.LabelField("UV Settings"); EditorGUI.indentLevel++; { var autoRebuildUvs = AutoRebuildUVs ?? false; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !AutoRebuildUVs.HasValue; autoRebuildUvs = EditorGUILayout.Toggle(AutoRebuildUVsContent, autoRebuildUvs); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (autoRebuildUvs) { models[i].Settings |= ModelSettingsFlags.AutoRebuildUVs; } else { models[i].Settings &= ~ModelSettingsFlags.AutoRebuildUVs; } } GUI.changed = true; AutoRebuildUVs = autoRebuildUvs; updateMeshes = true; } } { var preserveUVs = PreserveUVs ?? false; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !PreserveUVs.HasValue; preserveUVs = EditorGUILayout.Toggle(PreserveUVsContent, preserveUVs); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { if (preserveUVs) { models[i].Settings |= ModelSettingsFlags.PreserveUVs; } else { models[i].Settings &= ~ModelSettingsFlags.PreserveUVs; } } GUI.changed = true; PreserveUVs = preserveUVs; updateMeshes = true; } } EditorGUI.indentLevel--; } EditorGUI.indentLevel--; } GUILayout.EndVertical(); GUILayout.Space(10); GUILayout.BeginVertical(GUI.skin.box); { EditorGUILayout.LabelField("Mesh (advanced)"); EditorGUI.indentLevel++; { var showGeneratedMeshes = ShowGeneratedMeshes ?? false; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !ShowGeneratedMeshes.HasValue; showGeneratedMeshes = EditorGUILayout.Toggle(ShowGeneratedMeshesContent, showGeneratedMeshes); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { models[i].ShowGeneratedMeshes = showGeneratedMeshes; MeshInstanceManager.UpdateGeneratedMeshesVisibility(models[i]); } } GUILayout.Space(10); EditorGUILayout.LabelField("Used Vertex Channels"); EditorGUI.indentLevel++; { var vertex_channel_color = VertexChannelColor ?? false; var vertex_channel_tangent = VertexChannelTangent ?? false; var vertex_channel_normal = VertexChannelNormal ?? false; var vertex_channel_UV0 = VertexChannelUV0 ?? false; EditorGUI.BeginChangeCheck(); { EditorGUI.showMixedValue = !VertexChannelColor.HasValue; vertex_channel_color = EditorGUILayout.Toggle(VertexChannelColorContent, vertex_channel_color); EditorGUI.showMixedValue = !VertexChannelTangent.HasValue; vertex_channel_tangent = EditorGUILayout.Toggle(VertexChannelTangentContent, vertex_channel_tangent); EditorGUI.showMixedValue = !VertexChannelNormal.HasValue; vertex_channel_normal = EditorGUILayout.Toggle(VertexChannelNormalContent, vertex_channel_normal); EditorGUI.showMixedValue = !VertexChannelUV0.HasValue; vertex_channel_UV0 = EditorGUILayout.Toggle(VertexChannelUV1Content, vertex_channel_UV0); } if (EditorGUI.EndChangeCheck()) { for (int i = 0; i < models.Length; i++) { var vertexChannel = models[i].VertexChannels; vertexChannel &= ~(VertexChannelFlags.Color | VertexChannelFlags.Tangent | VertexChannelFlags.Normal | VertexChannelFlags.UV0); if (vertex_channel_color) { vertexChannel |= VertexChannelFlags.Color; } if (vertex_channel_tangent) { vertexChannel |= VertexChannelFlags.Tangent; } if (vertex_channel_normal) { vertexChannel |= VertexChannelFlags.Normal; } if (vertex_channel_UV0) { vertexChannel |= VertexChannelFlags.UV0; } models[i].VertexChannels = vertexChannel; } GUI.changed = true; } } EditorGUI.indentLevel--; } EditorGUI.indentLevel--; } GUILayout.EndVertical(); if (models != null && models.Length == 1) { GUILayout.Space(10); GUILayout.BeginVertical(GUI.skin.box); _showDetails = EditorGUILayout.BeginToggleGroup("Statistics", _showDetails); if (_showDetails) { var model_cache = InternalCSGModelManager.GetModelCache(models[0]); if (model_cache == null || model_cache.GeneratedMeshes == null || !model_cache.GeneratedMeshes) { GUILayout.Label("Could not find model cache for this model."); } else { var meshContainer = model_cache.GeneratedMeshes; var totalTriangles = 0; var totalVertices = 0; var totalMeshes = 0; var materialMeshes = new Dictionary <Material, List <MeshData> >(); foreach (var instance in meshContainer.meshInstances.Values) { var mesh = instance.SharedMesh; if (!MeshInstanceManager.HasVisibleMeshRenderer(instance)) { continue; } List <MeshData> meshes; if (!materialMeshes.TryGetValue(instance.RenderMaterial, out meshes)) { meshes = new List <MeshData>(); materialMeshes[instance.RenderMaterial] = meshes; } var meshData = new MeshData(); meshData.Mesh = mesh; meshData.VertexCount = mesh.vertexCount; meshData.TriangleCount = mesh.triangles.Length / 3; meshes.Add(meshData); totalVertices += meshData.VertexCount; totalTriangles = meshData.TriangleCount; totalMeshes++; } EditorGUI.indentLevel++; EditorGUILayout.Space(); EditorGUILayout.LabelField("total:"); EditorGUILayout.LabelField("vertices: " + totalVertices + " triangles: " + totalTriangles + " materials: " + materialMeshes.Count + " meshes: " + totalMeshes); GUILayout.Space(10); EditorGUILayout.LabelField("meshes:"); foreach (var item in materialMeshes) { var material = item.Key; var meshes = item.Value; GUILayout.BeginHorizontal(); { EditorGUI.BeginDisabledGroup(true); { EditorGUILayout.ObjectField(material, typeof(Material), true); } GUILayout.BeginVertical(); { if (meshes.Count == 1) { EditorGUILayout.ObjectField(meshes[0].Mesh, typeof(Mesh), true); EditorGUILayout.LabelField("vertices " + meshes[0].VertexCount + " triangles " + meshes[0].TriangleCount); } else { for (int i = 0; i < meshes.Count; i++) { EditorGUILayout.ObjectField(meshes[i].Mesh, typeof(Mesh), true); EditorGUILayout.LabelField("vertices " + meshes[i].VertexCount + " triangles " + meshes[i].TriangleCount); } } } GUILayout.EndVertical(); EditorGUI.EndDisabledGroup(); } GUILayout.EndHorizontal(); EditorGUILayout.Space(); } EditorGUI.indentLevel--; } } EditorGUILayout.EndToggleGroup(); GUILayout.EndVertical(); } EditorGUI.showMixedValue = false; if (updateMeshes) { InternalCSGModelManager.DoForcedMeshUpdate(); UpdateLoop.ResetUpdateRoutine(); } }
static void OnGUIContents(bool isSceneGUI, EditModeMeshEdit tool) { EditModeCommonGUI.StartToolGUI(); var filteredSelection = EditModeManager.FilteredSelection; var defaultMaterial = CSGSettings.DefaultMaterial; GUILayout.BeginVertical(isSceneGUI ? InSceneWidth : CSG_GUIStyleUtility.ContentEmpty); { /* * GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty); * { * * GUILayout.BeginVertical(isSceneGUI ? GUI.skin.box : GUIStyle.none); * { * //GUILayout.Label(Keys.VerticalMoveMode.ToString() + " to dragging brush up/down", EditorStyles.miniLabel); * GUILayout.Label("Control (hold) to drag polygon on it's plane", EditorStyles.miniLabel); * GUILayout.Label("Shift (hold) to drag extrude polygon", EditorStyles.miniLabel); * GUILayout.Label("Shift (hold) to chamfer edges and vertices", EditorStyles.miniLabel); * } * GUILayout.EndVertical(); * } * GUILayout.EndHorizontal();*/ ChooseCSGOperation(filteredSelection, isSceneGUI, tool); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (isSceneGUI) { GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginChangeCheck(); { defaultMaterial = CSG_EditorGUIUtility.MaterialImage(defaultMaterial, small: true); } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } } GUILayout.EndVertical(); } GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { bool have_nodes = tool != null && (filteredSelection.NodeTargets.Length > 0); EditorGUI.BeginDisabledGroup(!have_nodes); { GUIStyle left = EditorStyles.miniButtonLeft; GUIStyle middle = EditorStyles.miniButtonMid; GUIStyle right = EditorStyles.miniButtonRight; GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { if (isSceneGUI) { EditorGUILayout.LabelField(ContentFlip, labelWidth); } else { EditorGUILayout.LabelField(ContentFlip, largeLabelWidth); } if (GUILayout.Button(ContentFlipX, left)) { tool.FlipX(); } TooltipUtility.SetToolTip(TooltipFlipX); if (GUILayout.Button(ContentFlipY, middle)) { tool.FlipY(); } TooltipUtility.SetToolTip(TooltipFlipY); if (GUILayout.Button(ContentFlipZ, right)) { tool.FlipZ(); } TooltipUtility.SetToolTip(TooltipFlipZ); } GUILayout.EndHorizontal(); /* * EditorGUILayout.LabelField(ContentEdgesLabel); * GUILayout.BeginHorizontal(GUIStyleUtility.ContentEmpty); * { * EditorGUI.BeginDisabledGroup(!tool.CanSmooth()); * { * if (GUILayout.Button("Smooth")) { tool.Smooth(); } * } * EditorGUI.EndDisabledGroup(); * EditorGUI.BeginDisabledGroup(!tool.CanUnSmooth()); * { * if (GUILayout.Button("Un-smooth")) { tool.UnSmooth(); } * } * EditorGUI.EndDisabledGroup(); * } * GUILayout.EndHorizontal(); */ if (GUILayout.Button(ContentSnapToGrid)) { tool.SnapToGrid(); } TooltipUtility.SetToolTip(TooltipSnapToGrid); } EditorGUI.EndDisabledGroup(); } GUILayout.EndVertical(); } GUILayout.EndHorizontal(); GUILayout.Space(2); if (!isSceneGUI) { EditorGUILayout.Space(); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { EditorGUILayout.LabelField(ContentDefaultMaterial, largeLabelWidth); GUILayout.BeginVertical(CSG_GUIStyleUtility.ContentEmpty); { EditorGUI.BeginChangeCheck(); { defaultMaterial = EditorGUILayout.ObjectField(defaultMaterial, typeof(Material), true) as Material; } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } } GUILayout.Space(2); GUILayout.BeginHorizontal(CSG_GUIStyleUtility.ContentEmpty); { GUILayout.Space(5); defaultMaterial = CSG_EditorGUIUtility.MaterialImage(defaultMaterial, small: false); } GUILayout.EndHorizontal(); GUILayout.EndVertical(); } GUILayout.EndHorizontal(); /* * // Unity won't let us do this * GUILayout.BeginVertical(GUIStyleUtility.ContentEmpty); * OnGUIContentsMaterialInspector(first_material, multiple_materials); * GUILayout.EndVertical(); */ } else { EditorGUI.BeginChangeCheck(); { defaultMaterial = EditorGUILayout.ObjectField(defaultMaterial, typeof(Material), true) as Material; } if (EditorGUI.EndChangeCheck() && defaultMaterial) { CSGSettings.DefaultMaterial = defaultMaterial; CSGSettings.Save(); } } } GUILayout.EndVertical(); EditorGUI.showMixedValue = false; }