public static CSGBrush CreateBrushInstanceInScene()
{
#if EVALUATION
if (NativeMethodBindings.BrushesAvailable() <= 0)
{
return(null);
}
#endif
var lastUsedModelTransform = !SelectionUtility.LastUsedModel ? null : SelectionUtility.LastUsedModel.transform;
if (lastUsedModelTransform == null)
{
lastUsedModelTransform = CreateModelInstanceInScene().transform;
}
var name = UnityEditor.GameObjectUtility.GetUniqueNameForSibling(lastUsedModelTransform, "Brush");
var gameObject = new GameObject(name);
var brush = gameObject.AddComponent <CSGBrush>();
gameObject.transform.SetParent(lastUsedModelTransform, true);
gameObject.transform.position = new Vector3(0.5f, 0.5f, 0.5f); // this aligns it's vertices to the grid
BrushFactory.CreateCubeControlMesh(out brush.ControlMesh, out brush.Shape, Vector3.one);
UnityEditor.Selection.activeGameObject = gameObject;
Undo.RegisterCreatedObjectUndo(gameObject, "Created brush");
InternalCSGModelManager.Refresh();
InternalCSGModelManager.UpdateMeshes();
return(brush);
}
public static GameObject CreateBrush(ControlMesh controlMesh, Shape shape, Transform parent, string name, bool worldPositionStays)
{
#if EVALUATION
if (NativeMethodBindings.BrushesAvailable() <= 0)
{
return(null);
}
#endif
var gameObject = CreateGameObject(parent, name, worldPositionStays);
var brush = gameObject.AddComponent <CSGBrush>();
brush.ControlMesh = controlMesh;
brush.Shape = shape;
gameObject.SetActive(shape != null && controlMesh != null);
Undo.RegisterCreatedObjectUndo(gameObject, "Created brush");
InternalCSGModelManager.Refresh();
return(gameObject);
}
protected bool UpdateExtrudedShape(bool registerUndo = true)
{
if (polygons == null || polygons.Length == 0)
{
return(false);
}
#if EVALUATION
if (NativeMethodBindings.BrushesAvailable() < polygons.Length)
{
Debug.Log("Evaluation brush limit hit (" + NativeMethodBindings.BrushesAvailable() + " available, " + polygons.Length + " required), for the ability to create more brushes please purchase Realtime - CSG");
return(false);
}
#endif
bool failures = false;
bool modifiedHierarchy = false;
if (HaveExtrusion)
{
UpdateBrushOperation();
if (generatedGameObjects != null && generatedGameObjects.Length > 0)
{
for (int i = generatedGameObjects.Length - 1; i >= 0; i--)
{
if (generatedGameObjects[i])
{
continue;
}
ArrayUtility.RemoveAt(ref generatedGameObjects, i);
}
}
if (generatedGameObjects == null || generatedGameObjects.Length == 0)
{
Cancel();
return(false);
}
if (generatedGameObjects != null && generatedGameObjects.Length > 0)
{
if (registerUndo)
{
Undo.RecordObjects(generatedGameObjects, "Extruded shape");
}
int brushIndex = 0;
for (int slice = 0; slice < extrusionPoints.Length - 1; slice++)
{
for (int p = 0; p < polygons.Length; p++)
{
var brush = generatedBrushes[brushIndex]; brushIndex++;
if (!brush || !brush.gameObject)
{
continue;
}
var direction = haveForcedDirection ? forcedDirection : buildPlane.normal;
var distance = new CSGPlane(direction, extrusionPoints[slice].Position).Distance(extrusionPoints[slice + 1].Position);
if (float.IsInfinity(distance) || float.IsNaN(distance))
{
distance = 1.0f;
}
var poly2dToWorldMatrix = brush.transform.worldToLocalMatrix *
Matrix4x4.TRS(extrusionPoints[slice].Position, Quaternion.FromToRotation(MathConstants.upVector3, buildPlane.normal),
Vector3.one); // * parentModel.transform.localToWorldMatrix;
ControlMesh newControlMesh;
Shape newShape;
if (!CreateControlMeshForBrushIndex(parentModel, brush, polygons[p], poly2dToWorldMatrix, distance, out newControlMesh, out newShape))
{
failures = true;
if (brush.gameObject.activeSelf)
{
modifiedHierarchy = true;
brush.gameObject.SetActive(false);
}
continue;
}
if (!brush.gameObject.activeSelf)
{
modifiedHierarchy = true;
brush.gameObject.SetActive(true);
}
brush.ControlMesh.SetDirty();
if (registerUndo)
{
EditorUtility.SetDirty(brush);
}
}
}
}
}
else
{
if (generatedGameObjects != null)
{
if (registerUndo)
{
Undo.RecordObjects(generatedGameObjects, "Extruded brush");
}
InternalCSGModelManager.skipCheckForChanges = false;
int brushIndex = 0;
for (int slice = 0; slice < extrusionPoints.Length - 1; slice++)
{
for (int p = 0; p < polygons.Length; p++)
{
if (p >= generatedBrushes.Length)
{
continue;
}
var brush = generatedBrushes[brushIndex];
brushIndex++;
brush.ControlMesh.SetDirty();
if (registerUndo)
{
EditorUtility.SetDirty(brush);
}
}
}
HideGenerateBrushes();
}
}
try
{
InternalCSGModelManager.skipCheckForChanges = true;
if (registerUndo)
{
EditorUtility.SetDirty(this);
}
//CSGModelManager.External.SetDirty(parentModel.modelNodeID);
InternalCSGModelManager.CheckForChanges(forceHierarchyUpdate: modifiedHierarchy);
}
finally
{
InternalCSGModelManager.skipCheckForChanges = false;
}
if (shapeEdges != null && smearTextures)
{
CSGBrush lastBrush = null;
int lastSurfaceIndex = -1;
for (int slice = 0; slice < extrusionPoints.Length - 1; slice++)
{
for (int se = 0; se < shapeEdges.Length; se++)
{
var brushIndex = shapeEdges[se].PolygonIndex + (slice * shapeEdges.Length);
var surfaceIndex = shapeEdges[se].EdgeIndex;
if (brushIndex < 0 ||
brushIndex >= generatedBrushes.Length ||
surfaceIndex == -1)
{
continue;
}
var brush = generatedBrushes[brushIndex];
if (brush && brush.brushNodeID != CSGNode.InvalidNodeID)
{
if (lastBrush && lastBrush.brushNodeID != CSGNode.InvalidNodeID)
{
SurfaceUtility.CopyLastMaterial(brush, surfaceIndex, false,
lastBrush, lastSurfaceIndex, false,
registerUndo = false);
}
else
{
brush.Shape.TexGens[surfaceIndex].Translation = Vector3.zero;
brush.Shape.TexGens[surfaceIndex].Scale = Vector2.one;
brush.Shape.TexGens[surfaceIndex].RotationAngle = 0;
}
lastBrush = brush;
lastSurfaceIndex = surfaceIndex;
}
}
}
}
InternalCSGModelManager.RefreshMeshes();
return(!failures);
}
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 EVALUATION
if (NativeMethodBindings.BrushesAvailable() < brushObjectCount)
{
Debug.Log("Evaluation brush limit hit (" + NativeMethodBindings.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);
}