protected void PaintSnapVisualisation()
{
if (visualSnappedEdges != null)
{
PaintUtility.DrawLines(visualSnappedEdges.ToArray(), ToolConstants.oldThickLineScale, ColorSettings.SnappedEdges);
}
var _origMatrix = Handles.matrix;
Handles.matrix = MathConstants.identityMatrix;
if (visualSnappedGrid != null)
{
PaintUtility.DrawDottedLines(visualSnappedGrid.ToArray(), ColorSettings.SnappedEdges);
}
if (visualSnappedBrush != null)
{
var brush_cache = InternalCSGModelManager.GetBrushCache(visualSnappedBrush);
if (brush_cache != null &&
brush_cache.compareTransformation != null &&
brush_cache.childData != null &&
brush_cache.childData.ModelTransform != null &&
brush_cache.childData.ModelTransform)
{
var color = ColorSettings.HoverOutlines;
var brush_translation = brush_cache.compareTransformation.modelLocalPosition + brush_cache.childData.ModelTransform.position;
CSGRenderer.DrawOutlines(visualSnappedBrush.brushID, brush_translation,
color, color, color, color, ToolConstants.oldThickLineScale);
}
}
Handles.matrix = _origMatrix;
}
public UndoGroup(SelectedBrushSurface[] selectedBrushSurfaces, string name, bool reregisterMaterials = false, bool ignoreGroup = false)
{
if (selectedBrushSurfaces == null)
{
return;
}
this._reregisterMaterials = reregisterMaterials;
var uniqueBrushes = new HashSet <CSGBrush>();
var uniqueModels = new HashSet <CSGModel>();
for (int i = 0; i < selectedBrushSurfaces.Length; i++)
{
if (!selectedBrushSurfaces[i].brush)
{
continue;
}
var brush = selectedBrushSurfaces[i].brush;
// var surface_index = selectedBrushSurfaces[i].surfaceIndex;
if (uniqueBrushes.Add(brush))
{
CSGBrushCache brushCache = InternalCSGModelManager.GetBrushCache(brush);
if (brushCache != null)
{
uniqueModels.Add(brushCache.childData.Model);
}
}
}
_undoGroupIndex = -1;
_brushes = uniqueBrushes.ToArray();
_models = uniqueModels.ToArray();
if (_brushes.Length > 0)
{
if (!ignoreGroup)
{
_undoGroupIndex = Undo.GetCurrentGroup();
Undo.IncrementCurrentGroup();
}
Undo.RegisterCompleteObjectUndo(_brushes, name);
for (int i = 0; i < _brushes.Length; i++)
{
if (!_brushes[i])
{
continue;
}
UnityEditor.EditorUtility.SetDirty(_brushes[i]);
if (reregisterMaterials)
{
CSGBrushCache brushCache = InternalCSGModelManager.GetBrushCache(_brushes[i]);
if (brushCache != null)
{
InternalCSGModelManager.UnregisterMaterials(brushCache.childData.Model, _brushes[i].Shape, false);
}
}
}
}
}
public override void OnPaint()
{
RealtimeCSG.Grid.RenderGrid();
if (hoverBrushSurface == null)
{
return;
}
var brush = hoverBrushSurface.brush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
brush_cache.childData.ModelTransform == null)
{
return;
}
var highlight_surface = hoverBrushSurface.surfaceIndex;
var highlight_texGen = brush.Shape.Surfaces[highlight_surface].TexGenIndex;
var model_translation = brush_cache.childData.Model.transform.position;
var brush_translation = brush_cache.compareTransformation.modelLocalPosition + model_translation;
CSGRenderer.DrawSelectedBrush(brush.brushID, brush.Shape,
brush_translation, ColorSettings.WireframeOutline,
highlight_texGen,
false, ToolConstants.oldLineScale);
}
public void OnPaint()
{
if (!hoverOnSelectedSurfaces)
{
var activetool = EditModeManager.ActiveTool as EditModeSurface;
if (activetool != null)
{
var selectedBrushSurfaces = activetool.GetSelectedSurfaces();
for (int i = 0; i < selectedBrushSurfaces.Length; i++)
{
var brush = selectedBrushSurfaces[i].brush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null)
{
return;
}
var highlight_surface = selectedBrushSurfaces[i].surfaceIndex;
var highlight_texGen = brush.Shape.Surfaces[highlight_surface].TexGenIndex;
var brush_translation = brush_cache.compareTransformation.modelLocalPosition + brush_cache.childData.ModelTransform.position;
CSGRenderer.DrawTexGenOutlines(brush.brushID, brush.Shape,
brush_translation, highlight_texGen,
ColorSettings.SurfaceInnerStateColor[2],
ColorSettings.SurfaceOuterStateColor[2],
//ColorSettings.SurfaceTriangleStateColor[2],
ToolConstants.oldThinLineScale);
}
}
}
if (hoverBrushSurfaces != null)
{
for (int i = 0; i < hoverBrushSurfaces.Length; i++)
{
var brush = hoverBrushSurfaces[i].brush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null)
{
return;
}
var brush_translation = brush_cache.compareTransformation.modelLocalPosition + brush_cache.childData.ModelTransform.position;
var highlight_surface = hoverBrushSurfaces[i].surfaceIndex;
if (highlight_surface == -1 || selectAllSurfaces)
{
CSGRenderer.DrawSelectedBrush(brush.brushID, brush.Shape, brush_translation, ColorSettings.WireframeOutline, 0, selectAllSurfaces, ToolConstants.oldLineScale);
}
else
{
var highlight_texGen = brush.Shape.Surfaces[highlight_surface].TexGenIndex;
CSGRenderer.DrawSelectedBrush(brush.brushID, brush.Shape, brush_translation, ColorSettings.WireframeOutline, highlight_texGen, selectAllSurfaces, ToolConstants.oldLineScale);
}
}
}
}
internal static void OnPaint(SceneView sceneView)
{
SceneDragToolManager.OnPaint();
if (sceneView == null ||
Event.current.type != EventType.Repaint)
{
return;
}
if (RealtimeCSG.CSGSettings.GridVisible)
{
RealtimeCSG.CSGGrid.RenderGrid();
}
if (RealtimeCSG.CSGSettings.IsWireframeShown(sceneView))
{
if (forceOutlineUpdate || meshGeneration != InternalCSGModelManager.MeshGeneration)
{
forceOutlineUpdate = false;
meshGeneration = InternalCSGModelManager.MeshGeneration;
lineMeshManager.Begin();
for (int i = 0; i < InternalCSGModelManager.Brushes.Length; i++)
{
var brush = InternalCSGModelManager.Brushes[i];
if (!brush)
{
continue;
}
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null)
{
continue;
}
if (!brush.outlineColor.HasValue)
{
brush.outlineColor = ColorSettings.GetBrushOutlineColor(brush);
}
var brush_translation = brush_cache.compareTransformation.modelLocalPosition +
brush_cache.childData.ModelTransform.position;
CSGRenderer.DrawSimpleOutlines(lineMeshManager, brush.brushID, brush_translation, brush.outlineColor.Value);
}
lineMeshManager.End();
}
MaterialUtility.LineDashMultiplier = 1.0f;
MaterialUtility.LineThicknessMultiplier = 1.0f;
MaterialUtility.LineAlphaMultiplier = 1.0f;
lineMeshManager.Render(MaterialUtility.NoZTestGenericLine);
}
}
void UpdateBrushMeshes(HashSet <CSGBrush> brushes, HashSet <CSGModel> models)
{
foreach (var brush in brushes)
{
brush.EnsureInitialized();
ShapeUtility.CheckMaterials(brush.Shape);
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
InternalCSGModelManager.RegisterMaterials(brush_cache.childData.Model, brush.Shape, false);
}
foreach (var model in models)
{
InternalCSGModelManager.UpdateMaterialCount(model);
}
foreach (var brush in brushes)
{
InternalCSGModelManager.CheckSurfaceModifications(brush, true);
InternalCSGModelManager.ValidateBrush(brush);
}
MeshInstanceManager.UpdateHelperSurfaceVisibility();
}
void RestoreMaterials(SelectedBrushSurface[] hoverBrushSurfaces)
{
if (hoverBrushSurfaces == null)
{
return;
}
var updateModels = new HashSet <CSGModel>();
var updateBrushes = new HashSet <CSGBrush>();
for (int i = 0; i < hoverBrushSurfaces.Length; i++)
{
var brush = hoverBrushSurfaces[i].brush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
brush_cache.childData.Model == null)
{
continue;
}
try
{
var model = brush_cache.childData.Model;
updateModels.Add(model);
if (updateBrushes.Add(brush))
{
var shape = brush.Shape;
for (int t = 0; t < shape.TexGens.Length; t++)
{
shape.TexGens[t].RenderMaterial = previousMaterials[i][t];
}
}
}
finally { }
}
UpdateBrushMeshes(updateBrushes, updateModels);
}
void RestoreMaterials(SelectedBrushSurface[] hoverBrushSurfaces)
{
if (hoverBrushSurfaces == null)
{
return;
}
var updateModels = new HashSet <CSGModel>();
var updateBrushes = new HashSet <CSGBrush>();
for (int i = 0; i < hoverBrushSurfaces.Length; i++)
{
var brush = hoverBrushSurfaces[i].brush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
brush_cache.childData.Model == null)
{
continue;
}
try
{
var model = brush_cache.childData.Model;
updateModels.Add(model);
if (updateBrushes.Add(brush))
{
InternalCSGModelManager.UnregisterMaterials(model, brush.Shape, false);
System.Array.Copy(previousMaterials[i], brush.Shape.Materials, brush.Shape.Materials.Length);
}
}
finally { }
}
UpdateBrushMeshes(updateBrushes, updateModels);
}
//void OnSceneGUI() <- paints -everything- again for every selected brush
public static void OnSceneGUI(SceneView sceneView)
{
if (EditorApplication.isPlayingOrWillChangePlaymode)
{
return;
}
/*
* int prevHotControl = GUIUtility.hotControl;
* int prevKeyboardControl = GUIUtility.keyboardControl;
*
* // make it impossible for the tool to click in the bottom bar area
* int bottomBarId = GUIUtility.GetControlID (BottomBarInputHash, FocusType.Passive);
* bool forceRevert = false;
* //if (GUIUtility.hotControl == 0)
* {
* var bottomBarRect = sceneView.position;
* var min = bottomBarRect.min;
* var max = bottomBarRect.max;
*
* min.y = max.y - (GUIStyleUtility.BottomToolBarHeight + 18);
*
* bottomBarRect.min = min;
* bottomBarRect.max = max;
*
* if (bottomBarRect.Contains(Event.current.mousePosition))
* {
* GUIUtility.hotControl = bottomBarId;
* GUIUtility.keyboardControl = bottomBarId;
* forceRevert = true;
* }
* }
*/
SelectionUtility.HandleEvents();
InitTools();
HandleBuilderEvents();
//HandleYMode();
{
UpdateTool();
if (instance.activeTool != null)
{
if (RealtimeCSG.CSGSettings.EnableRealtimeCSG)
{
// handle the tool
var sceneSize = sceneView.position.size;
var sceneRect = new Rect(0, 0, sceneSize.x, sceneSize.y - ((GUIStyleUtility.BottomToolBarHeight + 4) + 17));
//var originalEventType = Event.current.type;
//if (originalEventType == EventType.MouseMove ||
// originalEventType == EventType.MouseUp)
// holdingDownMouse = false;
//var mousePos = Event.current.mousePosition;
//if (originalEventType == EventType.Layout ||
// originalEventType == EventType.Repaint ||
// sceneRect.Contains(mousePos) ||
// holdingDownMouse)
instance.activeTool.HandleEvents(sceneRect);
//if (originalEventType == EventType.MouseDown ||
// originalEventType == EventType.MouseDrag)
// holdingDownMouse = true;
}
else
{
if (Event.current.type == EventType.Repaint)
{
var brushes = instance.filteredSelection.BrushTargets;
var wireframes = new List <GeometryWireframe>(brushes.Length);
var translations = new List <Vector3>(brushes.Length);
for (int i = 0; i < brushes.Length; i++)
{
var brush = brushes[i];
if (!brush)
{
continue;
}
var brushCache = InternalCSGModelManager.GetBrushCache(brush);
if (brushCache == null ||
brushCache.childData == null ||
!brushCache.childData.Model)
{
continue;
}
var brushTranslation = brushCache.compareTransformation.modelLocalPosition + brushCache.childData.ModelTransform.position;
wireframes.Add(BrushOutlineManager.GetBrushOutline(brushes[i].brushID));
translations.Add(brushTranslation);
}
if (wireframes.Count > 0)
{
CSGRenderer.DrawSelectedBrushes(instance.zTestLineMeshManager, instance.noZTestLineMeshManager,
wireframes.ToArray(), translations.ToArray(),
ColorSettings.SelectedOutlines, ToolConstants.thickLineScale);
}
MaterialUtility.LineDashMultiplier = 1.0f;
MaterialUtility.LineThicknessMultiplier = 1.0f;
MaterialUtility.LineAlphaMultiplier = 1.0f;
instance.zTestLineMeshManager.Render(MaterialUtility.ZTestGenericLine);
instance.zTestLineMeshManager.Render(MaterialUtility.ZTestGenericLine);
}
}
}
}
/*
* // reset the control so the bottom bar can take over
* if (forceRevert)
* {
* GUIUtility.hotControl = prevHotControl;
* GUIUtility.keyboardControl = prevKeyboardControl;
* }
*/
int sceneWindowId = GUIUtility.GetControlID(SceneWindowHash, FocusType.Passive);
var sceneWindowType = Event.current.GetTypeForControl(sceneWindowId);
if (sceneWindowType == EventType.Repaint)
{
if (currentEditorWindows.Count > 0)
{
for (int i = 0; i < currentEditorWindows.Count; i++)
{
currentEditorWindows[i].Repaint();
}
return;
}
}
if (sceneWindowType == EventType.MouseMove)
{
SceneTools.IsDraggingObjectInScene = false;
}
if (RealtimeCSG.CSGSettings.EnableRealtimeCSG)
{
if (sceneView != null && sceneWindowType != EventType.Used && !SceneTools.IsDraggingObjectInScene)
{
if (currentEditorWindows.Count == 0)
{
try
{
Handles.BeginGUI();
Rect windowRect = new Rect(Vector2.zero, sceneView.position.size);
CSGBrushEditorGUI.HandleWindowGUI(windowRect);
}
finally
{
Handles.EndGUI();
}
}
}
}
}
/*
* 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;
}
void ApplyMaterial(SelectedBrushSurface[] hoverBrushSurfaces)
{
if (hoverBrushSurfaces == null)
{
return;
}
var updateModels = new HashSet <CSGModel>();
var updateBrushes = new HashSet <CSGBrush>();
for (int i = 0; i < hoverBrushSurfaces.Length; i++)
{
var brush = hoverBrushSurfaces[i].brush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
brush_cache.childData.Model == null)
{
continue;
}
try
{
var model = brush_cache.childData.Model;
updateModels.Add(model);
if (updateBrushes.Add(brush))
{
// per brush
if (!selectAllSurfaces)
{
var shape = brush.Shape;
for (int t = 0; t < shape.TexGens.Length; t++)
{
shape.TexGens[t].RenderMaterial = previousMaterials[i][t];
}
}
else
{
var shape = brush.Shape;
var surfaceTexGens = shape.TexGens.ToArray();
if (dragMaterials.Count > 1)
{
for (int m = 0; m < surfaceTexGens.Length; m++)
{
surfaceTexGens[m].RenderMaterial = dragMaterials[Random.Range(0, dragMaterials.Count)];
}
}
else
{
var materialInstance = dragMaterials[0];
for (int m = 0; m < surfaceTexGens.Length; m++)
{
surfaceTexGens[m].RenderMaterial = materialInstance;
}
}
shape.TexGens = surfaceTexGens;
}
}
// per surface
if (!selectAllSurfaces)
{
var highlight_surface = hoverBrushSurfaces[i].surfaceIndex;
if (highlight_surface >= 0)
{
var highlight_texGen = brush.Shape.Surfaces[highlight_surface].TexGenIndex;
Material dragMaterial;
if (dragMaterials.Count > 1)
{
dragMaterial = dragMaterials[Random.Range(0, dragMaterials.Count)];
}
else
{
dragMaterial = dragMaterials[0];
}
brush.Shape.TexGens[highlight_texGen].RenderMaterial = dragMaterial;
}
}
}
finally {}
}
UpdateBrushMeshes(updateBrushes, updateModels);
}
protected override void HandleEditShapeEvents(Rect sceneRect)
{
if (settings.vertices.Length < 2)
{
if (editMode == EditMode.ExtrudeShape ||
editMode == EditMode.EditShape)
{
editMode = EditMode.CreatePlane;
}
}
if (!SceneDragToolManager.IsDraggingObjectInScene &&
Event.current.type == EventType.Repaint)
{
if (visualSnappedEdges != null)
{
PaintUtility.DrawLines(visualSnappedEdges.ToArray(), ToolConstants.oldThickLineScale, ColorSettings.SnappedEdges);
}
if (visualSnappedGrid != null)
{
var _origMatrix = Handles.matrix;
Handles.matrix = MathConstants.identityMatrix;
PaintUtility.DrawDottedLines(visualSnappedGrid.ToArray(), ColorSettings.SnappedEdges);
Handles.matrix = _origMatrix;
}
if (visualSnappedBrush != null)
{
var brush_cache = InternalCSGModelManager.GetBrushCache(visualSnappedBrush);
if (brush_cache != null &&
brush_cache.compareTransformation != null &&
brush_cache.childData != null &&
brush_cache.childData.ModelTransform != null &&
brush_cache.childData.ModelTransform)
{
var brush_translation = brush_cache.compareTransformation.modelLocalPosition + brush_cache.childData.ModelTransform.position;
CSGRenderer.DrawOutlines(visualSnappedBrush.brushID, brush_translation, ColorSettings.SelectedOutlines, ColorSettings.SelectedOutlines, ColorSettings.SelectedOutlines, ColorSettings.SelectedOutlines);
}
}
var origMatrix = Handles.matrix;
Handles.matrix = MathConstants.identityMatrix;
PaintBounds();
Handles.matrix = origMatrix;
}
HandleHeightHandles(sceneRect, false);
for (int i = 0; i < settings.vertices.Length; i++)
{
var id = settings.vertexIDs[i];
var point_type = Event.current.GetTypeForControl(id);
switch (point_type)
{
case EventType.Repaint:
{
if (SceneDragToolManager.IsDraggingObjectInScene)
{
break;
}
bool isSelected = id == GUIUtility.keyboardControl;
var temp = Handles.color;
var origMatrix = Handles.matrix;
Handles.matrix = MathConstants.identityMatrix;
var rotation = Camera.current.transform.rotation;
if (isSelected)
{
Handles.color = ColorSettings.PointInnerStateColor[3];
}
else
if (HandleUtility.nearestControl == id)
{
Handles.color = ColorSettings.PointInnerStateColor[1];
}
else
{
Handles.color = ColorSettings.PointInnerStateColor[0];
}
float handleSize = CSG_HandleUtility.GetHandleSize(settings.vertices[i]);
float scaledHandleSize = handleSize * ToolConstants.handleScale;
PaintUtility.SquareDotCap(id, settings.vertices[i], rotation, scaledHandleSize);
Handles.matrix = origMatrix;
Handles.color = temp;
break;
}
case EventType.Layout:
{
if ((Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan))
{
break;
}
var origMatrix = Handles.matrix;
Handles.matrix = MathConstants.identityMatrix;
float handleSize = CSG_HandleUtility.GetHandleSize(settings.vertices[i]);
float scaledHandleSize = handleSize * ToolConstants.handleScale;
HandleUtility.AddControl(id, HandleUtility.DistanceToCircle(settings.vertices[i], scaledHandleSize));
Handles.matrix = origMatrix;
break;
}
case EventType.ValidateCommand:
case EventType.KeyDown:
{
if (GUIUtility.hotControl == id)
{
if (Keys.CancelActionKey.IsKeyPressed())
{
Event.current.Use();
break;
}
}
break;
}
case EventType.KeyUp:
{
if (GUIUtility.hotControl == id)
{
if (Keys.CancelActionKey.IsKeyPressed())
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
EditorGUIUtility.editingTextField = false;
Event.current.Use();
break;
}
}
break;
}
case EventType.MouseDown:
{
if (!sceneRect.Contains(Event.current.mousePosition))
{
break;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
break;
}
if (GUIUtility.hotControl == 0 && HandleUtility.nearestControl == id && Event.current.button == 0)
{
GUIUtility.hotControl = id;
GUIUtility.keyboardControl = id;
EditorGUIUtility.editingTextField = false;
EditorGUIUtility.SetWantsMouseJumping(1);
Event.current.Use();
break;
}
break;
}
case EventType.MouseDrag:
{
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
break;
}
if (GUIUtility.hotControl == id && Event.current.button == 0)
{
Undo.RecordObject(this, "Modify shape");
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
RealtimeCSG.CSGGrid.SetForcedGrid(buildPlane);
var alignedPlane = new CSGPlane(RealtimeCSG.CSGGrid.CurrentWorkGridPlane.normal, settings.vertices[0]);
var worldPosition = buildPlane.Project(alignedPlane.Intersection(mouseRay));
if (float.IsInfinity(worldPosition.x) || float.IsNaN(worldPosition.x) ||
float.IsInfinity(worldPosition.y) || float.IsNaN(worldPosition.y) ||
float.IsInfinity(worldPosition.z) || float.IsNaN(worldPosition.z))
{
worldPosition = settings.vertices[i];
}
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, buildPlane, ref base.visualSnappedEdges, out snappedOnBrush, generatedBrushes);
}
base.visualSnappedGrid = RealtimeCSG.CSGGrid.FindAllGridEdgesThatTouchPoint(worldPosition);
settings.vertices[i] = worldPosition;
CenterExtrusionPoints(buildPlane);
UpdateBaseShape();
if (editMode == EditMode.ExtrudeShape)
{
StartExtrudeMode();
UpdateBaseShape();
}
UpdateExtrudedShape();
GUI.changed = true;
Event.current.Use();
break;
}
break;
}
case EventType.MouseUp:
{
if (GUIUtility.hotControl != id)
{
break;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
break;
}
if (Event.current.button == 0)
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
EditorGUIUtility.editingTextField = false;
EditorGUIUtility.SetWantsMouseJumping(0);
Event.current.Use();
ResetVisuals();
//if (Length == 0 || Width == 0)
//{
// Cancel();
//}
break;
}
break;
}
}
}
}
public void HandleEvents(Rect sceneRect)
{
if (CurrentGenerator == null)
{
return;
}
CurrentGenerator.HandleEvents(sceneRect);
switch (Event.current.type)
{
case EventType.ValidateCommand:
{
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedAdditiveKey.IsKeyPressed())
{
Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedSubtractiveKey.IsKeyPressed())
{
Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedIntersectingKey.IsKeyPressed())
{
Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.CancelActionKey.IsKeyPressed())
{
Event.current.Use(); break;
}
if (Keys.HandleSceneValidate(CSGBrushEditorManager.CurrentTool, false))
{
Event.current.Use(); HandleUtility.Repaint(); break;
}
break;
}
case EventType.KeyDown:
{
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedAdditiveKey.IsKeyPressed())
{
Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedSubtractiveKey.IsKeyPressed())
{
Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedIntersectingKey.IsKeyPressed())
{
Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.CancelActionKey.IsKeyPressed())
{
Event.current.Use(); break;
}
if (Keys.HandleSceneKeyDown(CSGBrushEditorManager.CurrentTool, false))
{
Event.current.Use(); HandleUtility.Repaint(); break;
}
break;
}
case EventType.KeyUp:
{
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedAdditiveKey.IsKeyPressed())
{
SetOperationType(CSGOperationType.Additive); Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedSubtractiveKey.IsKeyPressed())
{
SetOperationType(CSGOperationType.Subtractive); Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.MakeSelectedIntersectingKey.IsKeyPressed())
{
SetOperationType(CSGOperationType.Intersecting); Event.current.Use(); break;
}
if (!EditorGUIUtility.editingTextField && Keys.CancelActionKey.IsKeyPressed())
{
CurrentGenerator.PerformDeselectAll(); Event.current.Use(); break;
}
if (Keys.HandleSceneKeyUp(CSGBrushEditorManager.CurrentTool, false))
{
Event.current.Use(); HandleUtility.Repaint(); break;
}
break;
}
case EventType.Repaint:
{
if (lastLineMeshGeneration != InternalCSGModelManager.MeshGeneration)
{
lastLineMeshGeneration = InternalCSGModelManager.MeshGeneration;
var brush_translations = new Vector3[brushes.Length];
var brush_ids = new Int32[brushes.Length];
for (int i = brushes.Length - 1; i >= 0; i--)
{
var brush = brushes[i];
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush.brushID == -1 || // could be a prefab
brush_cache == null ||
brush_cache.compareTransformation == null ||
brush_cache.childData == null ||
brush_cache.childData.ModelTransform == null ||
!brush_cache.childData.ModelTransform)
{
ArrayUtility.RemoveAt(ref brush_translations, i);
ArrayUtility.RemoveAt(ref brush_ids, i);
continue;
}
brush_translations[i] = brush_cache.compareTransformation.modelLocalPosition + brush_cache.childData.ModelTransform.position;
brush_ids[i] = brush.brushID;
}
CSGRenderer.DrawSelectedBrushes(zTestLineMeshManager, noZTestLineMeshManager, brush_ids, brush_translations,
ColorSettings.SelectedOutlines, ToolConstants.lineScale);
}
MaterialUtility.LineAlphaMultiplier = 1.0f;
MaterialUtility.LineDashMultiplier = 2.0f;
MaterialUtility.LineThicknessMultiplier = 2.0f;
noZTestLineMeshManager.Render(MaterialUtility.NoZTestGenericLine);
MaterialUtility.LineThicknessMultiplier = 1.0f;
zTestLineMeshManager.Render(MaterialUtility.ZTestGenericLine);
break;
}
}
}
public static void OnSceneGUI(SceneView sceneView)
{
if (EditorApplication.isPlayingOrWillChangePlaymode)
{
return;
}
CameraUtility.InitDistanceChecks(sceneView);
SelectionUtility.HandleEvents();
InitTools();
HandleBuilderEvents();
{
UpdateTool();
if (instance.activeTool != null)
{
if (RealtimeCSG.CSGSettings.EnableRealtimeCSG)
{
// handle the tool
var sceneSize = sceneView.position.size;
var sceneRect = new Rect(0, 0, sceneSize.x, sceneSize.y - ((CSG_GUIStyleUtility.BottomToolBarHeight + 4) + 17));
instance.activeTool.HandleEvents(sceneRect);
}
else
{
if (Event.current.type == EventType.Repaint)
{
var brushes = instance.filteredSelection.BrushTargets;
var wireframes = new List <GeometryWireframe>(brushes.Length);
var translations = new List <Vector3>(brushes.Length);
for (int i = 0; i < brushes.Length; i++)
{
var brush = brushes[i];
if (!brush)
{
continue;
}
var brushCache = InternalCSGModelManager.GetBrushCache(brush);
if (brushCache == null ||
brushCache.childData == null ||
!brushCache.childData.Model)
{
continue;
}
var brushTranslation = brushCache.compareTransformation.modelLocalPosition + brushCache.childData.ModelTransform.position;
wireframes.Add(BrushOutlineManager.GetBrushOutline(brushes[i].brushID));
translations.Add(brushTranslation);
}
if (wireframes.Count > 0)
{
CSGRenderer.DrawSelectedBrushes(instance.zTestLineMeshManager, instance.noZTestLineMeshManager,
wireframes.ToArray(), translations.ToArray(),
ColorSettings.SelectedOutlines, ToolConstants.thickLineScale);
}
MaterialUtility.LineDashMultiplier = 1.0f;
MaterialUtility.LineThicknessMultiplier = 1.0f;
MaterialUtility.LineAlphaMultiplier = 1.0f;
instance.zTestLineMeshManager.Render(MaterialUtility.ZTestGenericLine);
instance.zTestLineMeshManager.Render(MaterialUtility.ZTestGenericLine);
}
}
}
}
int sceneWindowId = GUIUtility.GetControlID(SceneWindowHash, FocusType.Passive);
var sceneWindowType = Event.current.GetTypeForControl(sceneWindowId);
if (sceneWindowType == EventType.Repaint)
{
if (currentEditorWindows.Count > 0)
{
for (int i = 0; i < currentEditorWindows.Count; i++)
{
currentEditorWindows[i].Repaint();
}
return;
}
}
if (sceneWindowType == EventType.MouseMove)
{
SceneDragToolManager.IsDraggingObjectInScene = false;
}
if (RealtimeCSG.CSGSettings.EnableRealtimeCSG)
{
if (sceneView && sceneWindowType != EventType.Used && !SceneDragToolManager.IsDraggingObjectInScene)
{
if (currentEditorWindows.Count == 0)
{
try
{
Handles.BeginGUI();
Rect windowRect = new Rect(Vector2.zero, sceneView.position.size);
EditModeSelectionGUI.HandleWindowGUI(windowRect);
}
finally
{
Handles.EndGUI();
}
}
}
}
}
protected override void HandleCreateShapeEvents(Rect sceneRect)
{
bool pointOnEdge = false;
bool havePlane = false;
bool vertexOnGeometry = false;
CSGBrush vertexOnBrush = null;
CSGPlane hoverBuildPlane = buildPlane;
var sceneView = SceneView.currentDrawingSceneView; //(SceneView.currentDrawingSceneView != null) ? SceneView.currentDrawingSceneView : SceneView.lastActiveSceneView;
var camera = (sceneView == null) ? null : sceneView.camera;
var assume2DView = CSGSettings.Assume2DView(sceneView);
if (camera != null &&
camera.pixelRect.Contains(Event.current.mousePosition))
{
if (!hoverDefaultPlane.HasValue ||
settings.vertices.Length == 0)
{
bool forceGrid = RealtimeCSG.Grid.ForceGrid;
RealtimeCSG.Grid.ForceGrid = false;
hoverDefaultPlane = RealtimeCSG.Grid.CurrentGridPlane;
RealtimeCSG.Grid.ForceGrid = forceGrid;
firstSnappedEdges = null;
firstSnappedBrush = null;
firstSnappedPlanes = null;
base.geometryModel = null;
}
if (editMode == EditMode.CreatePlane)
{
BrushIntersection intersection;
if (!assume2DView && !havePlane &&
SceneQueryUtility.FindWorldIntersection(Event.current.mousePosition, out intersection, MathConstants.GrowBrushFactor))
{
worldPosition = intersection.worldIntersection;
if (intersection.surfaceInverted)
{
hoverBuildPlane = intersection.plane.Negated();
}
else
{
hoverBuildPlane = intersection.plane;
}
vertexOnBrush = intersection.brush;
vertexOnGeometry = true;
}
else
{
hoverBuildPlane = hoverDefaultPlane.Value;
vertexOnBrush = null;
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
worldPosition = hoverBuildPlane.Intersection(mouseRay);
vertexOnGeometry = false;
}
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes, ignoreAllBrushes: true);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
vertexOnGeometry = true;
}
}
if (settings.vertices.Length == 1)
{
if (hoverBuildPlane.normal != MathConstants.zeroVector3)
{
editMode = EditMode.CreateShape;
havePlane = true;
}
}
}
else
{
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
if (settings.vertices.Length == 2)
{
var startPoint = settings.vertices[1];
var forward = camera.transform.forward;
if (Vector3.Dot(forward, gridBinormal) < Vector3.Dot(forward, gridTangent))
{
hoverBuildPlane = new CSGPlane(gridBinormal, startPoint);
}
else
{
hoverBuildPlane = new CSGPlane(gridTangent, startPoint);
}
worldPosition = hoverBuildPlane.Intersection(mouseRay);
// the third point is always straight up from the second point
//worldPosition = startPoint + (Vector3.Dot(worldPosition - startPoint, gridNormal) * gridNormal);
RealtimeCSG.Grid.SetForcedGrid(hoverBuildPlane);
ResetVisuals();
if (raySnapFunction != null)
{
Ray ray = new Ray(startPoint, gridNormal);
CSGBrush snappedOnBrush;
worldPosition = raySnapFunction(worldPosition, ray, ref visualSnappedEdges, out snappedOnBrush);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
}
}
worldPosition = GeometryUtility.ProjectPointOnInfiniteLine(worldPosition, startPoint, gridNormal);
}
else
{
worldPosition = hoverBuildPlane.Intersection(mouseRay);
RealtimeCSG.Grid.SetForcedGrid(hoverBuildPlane);
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes, ignoreAllBrushes: true);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
}
}
}
}
if (geometryModel == null && vertexOnBrush != null)
{
var brush_cache = InternalCSGModelManager.GetBrushCache(vertexOnBrush);
if (brush_cache != null && brush_cache.childData != null && brush_cache.childData.Model)
{
geometryModel = brush_cache.childData.Model;
}
}
if (worldPosition != prevWorldPosition)
{
prevWorldPosition = worldPosition;
if (settings.vertices.Length > 0)
{
if ((settings.vertices[0] - worldPosition).sqrMagnitude > MathConstants.EqualityEpsilon)
{
UpdateSizes();
UpdateBaseShape(true);
}
}
if (Event.current.type != EventType.Repaint)
{
SceneView.RepaintAll();
}
}
visualSnappedGrid = RealtimeCSG.Grid.FindAllGridEdgesThatTouchPoint(worldPosition);
visualSnappedBrush = vertexOnBrush;
}
RealtimeCSG.Grid.SetForcedGrid(hoverBuildPlane);
if (!SceneTools.IsDraggingObjectInScene &&
Event.current.type == EventType.Repaint)
{
PaintSnapVisualisation();
PaintShape(base.shapeId);
}
var type = Event.current.GetTypeForControl(base.shapeId);
switch (type)
{
case EventType.Layout:
{
return;
}
case EventType.ValidateCommand:
case EventType.KeyDown:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.PerformActionKey.IsKeyPressed() ||
Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Event.current.Use();
}
}
return;
}
case EventType.KeyUp:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.CylinderBuilderMode.IsKeyPressed() ||
Keys.PerformActionKey.IsKeyPressed())
{
HotKeyReleased();
Event.current.Use();
return;
}
if (Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Cancel();
Event.current.Use();
return;
}
}
return;
}
case EventType.MouseDown:
{
if (!sceneRect.Contains(Event.current.mousePosition))
{
break;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
return;
}
if ((GUIUtility.hotControl != 0 && GUIUtility.hotControl != shapeEditId && GUIUtility.hotControl != base.shapeId) ||
Event.current.button != 0)
{
return;
}
Event.current.Use();
if (settings.vertices.Length == 0)
{
if ((GUIUtility.hotControl == 0 ||
GUIUtility.hotControl == base.shapeEditId) && base.shapeId != -1)
{
base.CalculateWorldSpaceTangents();
GUIUtility.hotControl = base.shapeId;
GUIUtility.keyboardControl = base.shapeId;
EditorGUIUtility.editingTextField = false;
}
}
if (GUIUtility.hotControl == base.shapeId &&
settings.vertices.Length < kMaxPoints)
{
if (!float.IsNaN(worldPosition.x) && !float.IsInfinity(worldPosition.x) &&
!float.IsNaN(worldPosition.y) && !float.IsInfinity(worldPosition.y) &&
!float.IsNaN(worldPosition.z) && !float.IsInfinity(worldPosition.z))
{
if (settings.vertices.Length < 2 &&
hoverBuildPlane.normal.sqrMagnitude != 0)
{
buildPlane = hoverBuildPlane;
}
CalculateWorldSpaceTangents();
if (settings.vertices.Length == 0)
{
if (pointOnEdge)
{
firstSnappedEdges = visualSnappedEdges.ToArray();
firstSnappedBrush = visualSnappedBrush;
firstSnappedPlanes = null;
}
else
{
firstSnappedBrush = null;
firstSnappedEdges = null;
firstSnappedPlanes = null;
}
planeOnGeometry = vertexOnGeometry;
}
else
{
if (firstSnappedEdges != null)
{
if (firstSnappedPlanes == null)
{
CreateSnappedPlanes();
}
bool outside = true;
for (int i = 0; i < firstSnappedPlanes.Length; i++)
{
if (firstSnappedPlanes[i].Distance(worldPosition) <= MathConstants.DistanceEpsilon)
{
outside = false;
break;
}
}
planeOnGeometry = !outside;
}
if (vertexOnGeometry)
{
var plane = hoverDefaultPlane.Value;
var distance = plane.Distance(worldPosition);
plane.d += distance;
hoverDefaultPlane = plane;
for (int i = 0; i < settings.vertices.Length; i++)
{
if (!settings.onGeometryVertices[i])
{
settings.SetPoint(i, GeometryUtility.ProjectPointOnPlane(plane, settings.vertices[i]));
settings.onGeometryVertices[i] = true;
}
}
}
}
ArrayUtility.Add(ref settings.onGeometryVertices, vertexOnGeometry);
settings.AddPoint(worldPosition);
UpdateSizes();
SceneView.RepaintAll();
if (settings.vertices.Length == kMaxPoints)
{
HotKeyReleased();
}
}
}
return;
}
case EventType.MouseDrag:
{
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
break;
}
if (GUIUtility.hotControl == base.shapeId && Event.current.button == 0)
{
Event.current.Use();
}
return;
}
case EventType.MouseUp:
{
if (GUIUtility.hotControl != base.shapeId)
{
return;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
return;
}
if (Event.current.button == 0)
{
Event.current.Use();
ResetVisuals();
if (settings.vertices.Length == kMaxPoints)
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
EditorGUIUtility.editingTextField = false;
editMode = EditMode.CreateShape;
HotKeyReleased();
}
}
return;
}
}
}
void ApplyMaterial(SelectedBrushSurface[] hoverBrushSurfaces)
{
if (hoverBrushSurfaces == null)
{
return;
}
var updateModels = new HashSet <CSGModel>();
var updateBrushes = new HashSet <CSGBrush>();
for (int i = 0; i < hoverBrushSurfaces.Length; i++)
{
var brush = hoverBrushSurfaces[i].brush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
brush_cache.childData.Model == null)
{
continue;
}
try
{
var model = brush_cache.childData.Model;
updateModels.Add(model);
if (updateBrushes.Add(brush))
{
InternalCSGModelManager.UnregisterMaterials(model, brush.Shape, false);
// per brush
if (!selectAllSurfaces)
{
System.Array.Copy(previousMaterials[i], brush.Shape.Materials, brush.Shape.Materials.Length);
}
else
{
var surfaceMaterials = brush.Shape.Materials.ToArray();
if (dragMaterials.Count > 1)
{
for (int m = 0; m < surfaceMaterials.Length; m++)
{
surfaceMaterials[m] = dragMaterials[Random.Range(0, dragMaterials.Count)];
}
}
else
{
for (int m = 0; m < surfaceMaterials.Length; m++)
{
surfaceMaterials[m] = dragMaterials[0];
}
}
System.Array.Copy(surfaceMaterials, brush.Shape.Materials, brush.Shape.Materials.Length);
}
}
// per surface
if (!selectAllSurfaces)
{
var highlight_surface = hoverBrushSurfaces[i].surfaceIndex;
if (highlight_surface >= 0)
{
var highlight_texGen = brush.Shape.Surfaces[highlight_surface].TexGenIndex;
Material dragMaterial;
if (dragMaterials.Count > 1)
{
dragMaterial = dragMaterials[Random.Range(0, dragMaterials.Count)];
}
else
{
dragMaterial = dragMaterials[0];
}
brush.Shape.Materials[highlight_texGen] = dragMaterial;
}
}
}
finally {}
}
UpdateBrushMeshes(updateBrushes, updateModels);
}
public bool UpdateSelection(HashSet <CSGNode> newTargetNodes, HashSet <Transform> newTargetOthers)
{
if (newTargetNodes == null)
{
newTargetNodes = new HashSet <CSGNode>();
}
if (newTargetOthers == null)
{
newTargetOthers = new HashSet <Transform>();
}
this.RemovedNodes = null;
this.RemovedOthers = null;
this.AddedNodes = null;
this.AddedOthers = null;
var foundRemovedNodes = new List <CSGNode>();
if (this.NodeTargets != null &&
this.NodeTargets.Length > 0)
{
if (newTargetNodes.Count == 0)
{
foundRemovedNodes.AddRange(this.NodeTargets);
}
else
{
for (int i = 0; i < this.NodeTargets.Length; i++)
{
if (!this.NodeTargets[i] ||
!newTargetNodes.Contains(this.NodeTargets[i]))
{
foundRemovedNodes.Add(this.NodeTargets[i]);
}
}
}
}
var foundRemovedOthers = new List <Transform>();
if (this.OtherTargets != null &&
this.OtherTargets.Length > 0)
{
if (newTargetOthers.Count == 0)
{
foundRemovedOthers.AddRange(this.OtherTargets);
}
else
{
for (int i = 0; i < this.OtherTargets.Length; i++)
{
if (!this.OtherTargets[i] ||
!newTargetOthers.Contains(this.OtherTargets[i]))
{
foundRemovedOthers.Add(this.OtherTargets[i]);
}
}
}
}
var originalTargetNodeCount = (this.NodeTargets == null) ? 0 : this.NodeTargets.Length;
var originalTargetOtherCount = (this.OtherTargets == null) ? 0 : this.OtherTargets.Length;
// If our counts are the same and nothing is removed (and nothing could've been added), nothing has changed.
if (newTargetNodes.Count == originalTargetNodeCount &&
newTargetOthers.Count == originalTargetOtherCount &&
foundRemovedNodes.Count == 0 &&
foundRemovedOthers.Count == 0)
{
//Debug.Log(originalTargetNodeCount + " " + originalTargetOtherCount + " " + newTargetNodes .Count + " " + newTargetOthers .Count);
return(false);
}
Validate();
foreach (var node in foundRemovedNodes)
{
ArrayUtility.Remove(ref this.NodeTargets, node);
var brush = node as CSGBrush;
if (brush != null)
{
ArrayUtility.Remove(ref this.BrushTargets, brush);
continue;
}
var operation = node as CSGOperation;
if (node is CSGOperation)
{
ArrayUtility.Remove(ref this.OperationTargets, operation);
continue;
}
var model = node as CSGModel;
if (node is CSGModel)
{
ArrayUtility.Remove(ref this.ModelTargets, model);
continue;
}
}
foreach (var other in foundRemovedOthers)
{
ArrayUtility.Remove(ref this.OtherTargets, other);
}
var foundAddedNodes = new List <CSGNode>();
foreach (var node in newTargetNodes)
{
if (this.NodeTargets != null &&
ArrayUtility.Contains(this.NodeTargets, node))
{
continue;
}
if (this.NodeTargets == null)
{
this.NodeTargets = new CSGNode[] { node };
}
else
{
ArrayUtility.Add(ref this.NodeTargets, node);
}
foundAddedNodes.Add(node);
if (SelectionUtility.IsPrefab(node.gameObject))
{
continue;
}
var brush = node as CSGBrush;
if (brush != null)
{
if (this.BrushTargets == null)
{
this.BrushTargets = new CSGBrush[] { brush }
}
;
else
{
ArrayUtility.Add(ref this.BrushTargets, brush);
}
continue;
}
var operation = node as CSGOperation;
if (node is CSGOperation)
{
if (this.OperationTargets == null)
{
this.OperationTargets = new CSGOperation[] { operation }
}
;
else
{
ArrayUtility.Add(ref this.OperationTargets, operation);
}
continue;
}
var model = node as CSGModel;
if (node is CSGModel)
{
if (this.ModelTargets == null)
{
this.ModelTargets = new CSGModel[] { model }
}
;
else
{
ArrayUtility.Add(ref this.ModelTargets, model);
}
continue;
}
}
var foundAddedOthers = new List <Transform>();
foreach (var other in newTargetOthers)
{
if (this.OtherTargets != null &&
ArrayUtility.Contains(this.OtherTargets, other))
{
continue;
}
if (this.OtherTargets == null)
{
this.OtherTargets = new Transform[] { other }
}
;
else
{
ArrayUtility.Add(ref this.OtherTargets, other);
}
foundAddedOthers.Add(other);
}
for (int i = foundAddedNodes.Count - 1; i >= 0; i--)
{
var node = foundAddedNodes[i];
var brush = node as CSGBrush;
if (brush != null)
{
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
brush_cache.childData.Model == null)
{
continue;
}
var childModel = brush_cache.childData.Model;
if (childModel &&
childModel.isActiveAndEnabled)
{
SelectionUtility.LastUsedModel = childModel;
}
break;
}
var operation = node as CSGOperation;
if (operation != null)
{
var operation_cache = InternalCSGModelManager.GetOperationCache(operation);
if (operation_cache == null ||
operation_cache.ChildData == null ||
operation_cache.ChildData.Model == null)
{
continue;
}
SelectionUtility.LastUsedModel = operation_cache.ChildData.Model;
break;
}
var model = node as CSGModel;
if (model &&
model.isActiveAndEnabled)
{
SelectionUtility.LastUsedModel = model;
break;
}
}
this.RemovedNodes = foundRemovedNodes.ToArray();
this.RemovedOthers = foundRemovedOthers.ToArray();
this.AddedNodes = foundAddedNodes.ToArray();
this.AddedOthers = foundAddedOthers.ToArray();
return(foundAddedNodes.Count > 0 || foundRemovedNodes.Count > 0 || foundAddedOthers.Count > 0 || foundRemovedOthers.Count > 0);
}
protected override void HandleCreateShapeEvents(Rect sceneRect)
{
if (settings.vertices.Length < 2)
{
if (editMode == EditMode.ExtrudeShape ||
editMode == EditMode.EditShape)
{
editMode = EditMode.CreatePlane;
}
}
bool pointOnEdge = false;
bool havePlane = false;
bool vertexOnGeometry = false;
CSGBrush vertexOnBrush = null;
CSGPlane hoverBuildPlane = buildPlane;
var sceneView = SceneView.currentDrawingSceneView; //(SceneView.currentDrawingSceneView != null) ? SceneView.currentDrawingSceneView : SceneView.lastActiveSceneView;
var camera = (sceneView == null) ? null : sceneView.camera;
if (camera != null &&
camera.pixelRect.Contains(Event.current.mousePosition))
{
if (!hoverDefaultPlane.HasValue ||
settings.vertices.Length == 0)
{
bool forceGrid = RealtimeCSG.CSGGrid.ForceGrid;
RealtimeCSG.CSGGrid.ForceGrid = false;
hoverDefaultPlane = RealtimeCSG.CSGGrid.CurrentGridPlane;
RealtimeCSG.CSGGrid.ForceGrid = forceGrid;
firstSnappedEdges = null;
firstSnappedBrush = null;
firstSnappedPlanes = null;
base.geometryModel = null;
}
if (editMode == EditMode.CreatePlane)
{
BrushIntersection intersection;
if (!IgnoreDepthForRayCasts(sceneView) && !havePlane &&
SceneQueryUtility.FindWorldIntersection(Event.current.mousePosition, out intersection))
{
worldPosition = intersection.worldIntersection;
if (intersection.surfaceInverted)
{
hoverBuildPlane = intersection.plane.Negated();
}
else
{
hoverBuildPlane = intersection.plane;
}
vertexOnBrush = intersection.brush;
vertexOnGeometry = true;
}
else
{
hoverBuildPlane = hoverDefaultPlane.Value;
vertexOnBrush = null;
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
worldPosition = hoverBuildPlane.Intersection(mouseRay);
vertexOnGeometry = false;
}
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
vertexOnGeometry = true;
}
}
if (settings.vertices.Length == 1)
{
if (hoverBuildPlane.normal != MathConstants.zeroVector3)
{
editMode = EditMode.CreateShape;
havePlane = true;
}
}
else
if (settings.vertices.Length == 2)
{
onLastPoint = true;
}
}
else
{
var mouseRay = HandleUtility.GUIPointToWorldRay(Event.current.mousePosition);
worldPosition = hoverBuildPlane.Intersection(mouseRay);
ResetVisuals();
if (snapFunction != null)
{
CSGBrush snappedOnBrush;
worldPosition = snapFunction(worldPosition, hoverBuildPlane, ref visualSnappedEdges, out snappedOnBrush, generatedBrushes);
if (snappedOnBrush != null)
{
pointOnEdge = (visualSnappedEdges != null &&
visualSnappedEdges.Count > 0);
vertexOnBrush = snappedOnBrush;
}
}
}
if (geometryModel == null && vertexOnBrush != null)
{
var brush_cache = InternalCSGModelManager.GetBrushCache(vertexOnBrush);
if (brush_cache != null && brush_cache.childData != null && brush_cache.childData.Model)
{
geometryModel = brush_cache.childData.Model;
}
}
if (worldPosition != prevWorldPosition)
{
prevWorldPosition = worldPosition;
if (Event.current.type != EventType.Repaint)
{
SceneView.RepaintAll();
}
}
visualSnappedGrid = RealtimeCSG.CSGGrid.FindAllGridEdgesThatTouchPoint(worldPosition);
visualSnappedBrush = vertexOnBrush;
}
RealtimeCSG.CSGGrid.SetForcedGrid(hoverBuildPlane);
if (!SceneDragToolManager.IsDraggingObjectInScene &&
Event.current.type == EventType.Repaint)
{
PaintSnapVisualisation();
PaintShape(base.shapeId);
}
var type = Event.current.GetTypeForControl(base.shapeId);
switch (type)
{
case EventType.Layout:
{
return;
}
case EventType.ValidateCommand:
case EventType.KeyDown:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.PerformActionKey.IsKeyPressed() ||
Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Event.current.Use();
}
}
return;
}
case EventType.KeyUp:
{
if (GUIUtility.hotControl == base.shapeId)
{
if (Keys.BoxBuilderMode.IsKeyPressed() ||
Keys.PerformActionKey.IsKeyPressed())
{
HotKeyReleased();
Event.current.Use();
return;
}
if (Keys.DeleteSelectionKey.IsKeyPressed() ||
Keys.CancelActionKey.IsKeyPressed())
{
Cancel();
Event.current.Use();
return;
}
}
return;
}
case EventType.MouseDown:
{
if (!sceneRect.Contains(Event.current.mousePosition))
{
break;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
return;
}
if ((GUIUtility.hotControl != 0 && GUIUtility.hotControl != shapeEditId && GUIUtility.hotControl != base.shapeId) ||
Event.current.button != 0)
{
return;
}
Event.current.Use();
if (settings.vertices.Length == 0)
{
if ((GUIUtility.hotControl == 0 ||
GUIUtility.hotControl == base.shapeEditId) && base.shapeId != -1)
{
base.CalculateWorldSpaceTangents();
GUIUtility.hotControl = base.shapeId;
GUIUtility.keyboardControl = base.shapeId;
EditorGUIUtility.editingTextField = false;
}
}
if (GUIUtility.hotControl == base.shapeId && settings.vertices.Length < 2)
{
if (!float.IsNaN(worldPosition.x) && !float.IsInfinity(worldPosition.x) &&
!float.IsNaN(worldPosition.y) && !float.IsInfinity(worldPosition.y) &&
!float.IsNaN(worldPosition.z) && !float.IsInfinity(worldPosition.z))
{
if (hoverBuildPlane.normal.sqrMagnitude != 0)
{
buildPlane = hoverBuildPlane;
}
CalculateWorldSpaceTangents();
if (settings.vertices.Length == 0)
{
if (pointOnEdge)
{
firstSnappedEdges = visualSnappedEdges.ToArray();
firstSnappedBrush = visualSnappedBrush;
firstSnappedPlanes = null;
}
else
{
firstSnappedBrush = null;
firstSnappedEdges = null;
firstSnappedPlanes = null;
}
geometryPlane = buildPlane;
planeOnGeometry = vertexOnGeometry;
}
else
{
if (firstSnappedEdges != null)
{
if (firstSnappedPlanes == null)
{
CreateSnappedPlanes();
}
bool outside = true;
for (int i = 0; i < firstSnappedPlanes.Length; i++)
{
if (firstSnappedPlanes[i].Distance(worldPosition) <= MathConstants.DistanceEpsilon)
{
outside = false;
break;
}
}
planeOnGeometry = !outside;
}
if (vertexOnGeometry)
{
var plane = hoverDefaultPlane.Value;
var distance = plane.Distance(worldPosition);
if (float.IsInfinity(distance) || float.IsNaN(distance))
{
distance = 1.0f;
}
plane.d += distance;
hoverDefaultPlane = plane;
for (int i = 0; i < settings.vertices.Length; i++)
{
if (!settings.onGeometryVertices[i])
{
settings.vertices[i] = GeometryUtility.ProjectPointOnPlane(plane, settings.vertices[i]);
settings.onGeometryVertices[i] = true;
}
}
}
}
ArrayUtility.Add(ref settings.onGeometryVertices, vertexOnGeometry);
settings.AddPoint(worldPosition);
SceneView.RepaintAll();
if (settings.vertices.Length == 2)
{
HotKeyReleased();
}
}
}
return;
}
case EventType.MouseDrag:
{
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
break;
}
if (GUIUtility.hotControl == base.shapeId && Event.current.button == 0)
{
Event.current.Use();
}
return;
}
case EventType.MouseUp:
{
if (GUIUtility.hotControl != base.shapeId)
{
return;
}
if (Tools.viewTool != ViewTool.None && Tools.viewTool != ViewTool.Pan)
{
return;
}
if (Event.current.button == 0)
{
Event.current.Use();
ResetVisuals();
if (onLastPoint)
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
EditorGUIUtility.editingTextField = false;
editMode = EditMode.CreateShape;
HotKeyReleased();
}
}
return;
}
}
return;
}
public void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
if (_brushes == null)
{
return;
}
if (_brushes.Length > 0)
{
for (int i = 0; i < _brushes.Length; i++)
{
if (!_brushes[i])
{
continue;
}
_brushes[i].EnsureInitialized();
ShapeUtility.CheckMaterials(_brushes[i].Shape);
if (_reregisterMaterials)
{
CSGBrushCache brushCache = InternalCSGModelManager.GetBrushCache(_brushes[i]);
if (brushCache != null)
{
InternalCSGModelManager.RegisterMaterials(brushCache.childData.Model, _brushes[i].Shape, false);
}
}
}
if (_reregisterMaterials)
{
for (int i = 0; i < _models.Length; i++)
{
if (!_models[i])
{
continue;
}
InternalCSGModelManager.UpdateMaterialCount(_models[i]);
}
}
for (int i = 0; i < _brushes.Length; i++)
{
if (!_brushes[i])
{
continue;
}
InternalCSGModelManager.CheckSurfaceModifications(_brushes[i], true);
}
if (_undoGroupIndex != -1)
{
Undo.CollapseUndoOperations(_undoGroupIndex);
Undo.FlushUndoRecordObjects();
}
}
}
_brushes = null;
_models = null;
disposedValue = true;
}
}
public static void DoSelectionClick()
{
GameObject gameobject;
SceneQueryUtility.FindClickWorldIntersection(Event.current.mousePosition, out gameobject);
gameobject = SceneQueryUtility.GetGroupGameObjectIfObjectIsPartOfGroup(gameobject);
var selectedObjectsOnClick = new List <int>(Selection.instanceIDs);
bool addedSelection = false;
if (EditorGUI.actionKey)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
if (selectedObjectsOnClick.Contains(instanceID))
{
selectedObjectsOnClick.Remove(instanceID);
}
else
{
selectedObjectsOnClick.Add(instanceID);
addedSelection = true;
}
if (selectedObjectsOnClick.Count == 0)
{
Selection.activeTransform = null;
}
else
{
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
}
}
}
else
if (Event.current.shift)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
selectedObjectsOnClick.Add(instanceID);
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
addedSelection = true;
}
}
else
if (Event.current.alt)
{
if (gameobject != null)
{
var instanceID = gameobject.GetInstanceID();
selectedObjectsOnClick.Remove(instanceID);
Selection.instanceIDs = selectedObjectsOnClick.ToArray();
return;
}
}
else
{
Selection.activeGameObject = gameobject;
addedSelection = true;
}
if (!addedSelection)
{
foreach (var item in Selection.GetFiltered(typeof(CSGBrush), SelectionMode.Deep))
{
var brush = item as CSGBrush;
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
!brush_cache.childData.Model ||
!brush_cache.childData.Model.isActiveAndEnabled)
{
continue;
}
SelectionUtility.LastUsedModel = brush_cache.childData.Model;
break;
}
}
else
if (gameobject != null)
{
var brush = gameobject.GetComponent <CSGBrush>();
if (brush != null)
{
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
!brush_cache.childData.Model ||
!brush_cache.childData.Model.isActiveAndEnabled)
{
return;
}
SelectionUtility.LastUsedModel = brush_cache.childData.Model;
}
}
}
protected bool GenerateBrushObjects(int brushObjectCount, bool inGridSpace = true)
{
Undo.IncrementCurrentGroup();
undoGroupIndex = Undo.GetCurrentGroup();
var lastUsedModel = SelectionUtility.LastUsedModel;
var lastUsedModelTransform = !lastUsedModel ? null : lastUsedModel.transform;
if (!lastUsedModelTransform ||
!lastUsedModel.isActiveAndEnabled)
{
if (prevSelection != null && prevSelection.Length > 0)
{
for (int i = 0; i < prevSelection.Length; i++)
{
UnityEngine.Object obj = prevSelection[i];
CSGBrush brush = obj as CSGBrush;
MonoBehaviour mono = obj as MonoBehaviour;
GameObject go = obj as GameObject;
if (!brush)
{
if (mono)
{
brush = mono.GetComponentInChildren <CSGBrush>();
}
if (go)
{
brush = go.GetComponentInChildren <CSGBrush>();
}
}
if (!brush)
{
continue;
}
if ((brush.gameObject.hideFlags & (HideFlags.HideInHierarchy | HideFlags.NotEditable | HideFlags.DontSaveInBuild)) != 0)
{
continue;
}
var brush_cache = InternalCSGModelManager.GetBrushCache(brush);
if (brush_cache == null ||
brush_cache.childData == null ||
brush_cache.childData.ModelTransform == null)
{
continue;
}
var model = brush_cache.childData.Model;
if (!model ||
!model.isActiveAndEnabled)
{
continue;
}
lastUsedModelTransform = brush_cache.childData.ModelTransform;
break;
}
}
}
if (generatedBrushes != null && generatedBrushes.Length > 0)
{
for (int i = generatedBrushes.Length - 1; i >= 0; i--)
{
if (generatedBrushes[i])
{
continue;
}
ArrayUtility.RemoveAt(ref generatedBrushes, i);
}
for (int i = generatedGameObjects.Length - 1; i >= 0; i--)
{
if (generatedGameObjects[i])
{
var brush = generatedGameObjects[i].GetComponentInChildren <CSGBrush>();
if (brush && ArrayUtility.Contains(generatedBrushes, brush))
{
continue;
}
}
ArrayUtility.RemoveAt(ref generatedGameObjects, i);
}
}
if (generatedGameObjects == null ||
generatedGameObjects.Length != brushObjectCount)
{
if (generatedBrushes != null && generatedBrushes.Length > 0)
{
for (int i = 0; i < generatedBrushes.Length; i++)
{
InternalCSGModelManager.OnDestroyed(generatedBrushes[i]);
GameObject.DestroyImmediate(generatedBrushes[i]);
}
}
if (generatedGameObjects != null && generatedGameObjects.Length > 0)
{
for (int i = 0; i < generatedGameObjects.Length; i++)
{
GameObject.DestroyImmediate(generatedGameObjects[i]);
}
}
if (parentGameObject != null)
{
GameObject.DestroyImmediate(parentGameObject);
}
//DebugEditorWindow.PrintDebugInfo();
#if DEMO
if (CSGBindings.BrushesAvailable() < brushObjectCount)
{
Debug.Log("Demo brush limit hit (" + CSGBindings.BrushesAvailable() + " available, " + brushObjectCount + " required), for the ability to create more brushes please purchase Realtime-CSG");
return(false);
}
#endif
if (lastUsedModelTransform == null)
{
parentGameObject = OperationsUtility.CreateGameObject(lastUsedModelTransform, "Model", true);
InternalCSGModelManager.CreateCSGModel(parentGameObject);
parentModel = parentGameObject.GetComponent <CSGModel>();
Undo.RegisterCreatedObjectUndo(parentGameObject, "Created model");
if (brushObjectCount > 1)
{
operationGameObject = OperationsUtility.CreateGameObject(parentGameObject.transform, "Operation", true);
var transform = operationGameObject.transform;
SetBrushTransformation(transform);
var operation = operationGameObject.AddComponent <CSGOperation>();
if (CurrentCSGOperationType != invalidCSGOperationType)
{
operation.OperationType = CurrentCSGOperationType;
}
operation.HandleAsOne = true;
Undo.RegisterCreatedObjectUndo(operationGameObject, "Created operation");
parentTransform = operationGameObject.transform;
}
else
{
parentTransform = parentGameObject.transform;
}
}
else
if (brushObjectCount > 1)
{
parentModel = lastUsedModelTransform.GetComponent <CSGModel>();
parentGameObject = OperationsUtility.CreateGameObject(lastUsedModelTransform, "Brushes", true);
var transform = parentGameObject.transform;
SetBrushTransformation(transform);
operationGameObject = parentGameObject;
var operation = operationGameObject.AddComponent <CSGOperation>();
if (CurrentCSGOperationType != invalidCSGOperationType)
{
operation.OperationType = CurrentCSGOperationType;
}
operation.HandleAsOne = true;
parentTransform = operationGameObject.transform;
Undo.RegisterCreatedObjectUndo(parentGameObject, "Created brush");
}
else
{
parentGameObject = null;
operationGameObject = null;
parentTransform = lastUsedModelTransform;
parentModel = lastUsedModelTransform.GetComponent <CSGModel>();
}
generatedGameObjects = new GameObject[brushObjectCount];
generatedBrushes = new CSGBrush[brushObjectCount];
for (int p = 0; p < brushObjectCount; p++)
{
string name;
if (brushObjectCount == 1)
{
name = "Brush";
}
else
{
name = "Brush (" + p + ")";
}
var gameObject = OperationsUtility.CreateGameObject(parentTransform, name, false);
gameObject.SetActive(false);
var brushComponent = gameObject.AddComponent <CSGBrush>();
if (operationGameObject == null)
{
if (CurrentCSGOperationType != invalidCSGOperationType)
{
brushComponent.OperationType = CurrentCSGOperationType;
}
operationGameObject = gameObject;
var transform = gameObject.transform;
SetBrushTransformation(transform);
}
generatedBrushes[p] = brushComponent;
generatedBrushes[p].ControlMesh = new ControlMesh();
generatedBrushes[p].Shape = new Shape();
Undo.RegisterCreatedObjectUndo(gameObject, "Created brush");
generatedGameObjects[p] = gameObject;
}
//InternalCSGModelManager.Refresh(forceHierarchyUpdate: true);
// brushes not registered at this point!??
//DebugEditorWindow.PrintDebugInfo();
//Selection.objects = generatedGameObjects;
}
else
{
UpdateBrushPosition();
}
return(generatedBrushes != null && generatedBrushes.Length > 0 && generatedBrushes.Length == brushObjectCount);
}
