public void SetEffectParticle(Object _BaseObj, float _ImageSize)
{
ReleaseParticleList();
if (m_objParticleList == null)
{
m_objParticleList = new List <GameObject>(DefineBaseManager.inst.EffectParticleMax);
}
if (m_renParticleList == null)
{
m_renParticleList = new List <ControlMesh>(DefineBaseManager.inst.EffectParticleMax);
}
for (int i = 0; i < DefineBaseManager.inst.EffectParticleMax; i++)
{
m_objParticleList.Add((GameObject)Instantiate(_BaseObj));
m_objParticleList[i].name = "EffectParticle_" + i;
m_objParticleList[i].layer = m_LayerMask;
m_objParticleList[i].transform.parent = this.transform;
// m_renParticleList.Add(m_objParticleList[i].AddComponent<ControlMesh>());
ControlMesh tmpControlMesh = new ControlMesh();
tmpControlMesh.Create(m_objParticleList[i]);
tmpControlMesh.Anchor = SpriteRoot.ANCHOR_METHOD.MIDDLE_CENTER;
tmpControlMesh.SetSize(_ImageSize, _ImageSize);
m_renParticleList.Add(tmpControlMesh);
}
}
internal static CSGBrush CreateBrush(Transform parent, string brushName, ControlMesh controlMesh, Shape shape)
{
var gameObject = OperationsUtility.CreateGameObject(parent, brushName, false);
if (!gameObject)
{
return(null);
}
var brush = gameObject.AddComponent <CSGBrush>();
if (!brush)
{
return(null);
}
brush.ControlMesh = controlMesh;
brush.Shape = shape;
if (brush.ControlMesh != null)
{
brush.ControlMesh.SetDirty();
}
if (brush.Shape != null)
{
ShapeUtility.EnsureInitialized(brush.Shape);
}
return(brush);
}
public static CSGPlane CalcPolygonPlane(ControlMesh controlMesh, short polygonIndex)
{
if (controlMesh == null ||
controlMesh.Polygons == null ||
polygonIndex >= controlMesh.Polygons.Length)
{
return(new CSGPlane(Vector3.up, 0));
}
var edgeIndices = controlMesh.Polygons[polygonIndex].EdgeIndices;
if (edgeIndices.Length == 3)
{
var v0 = controlMesh.GetVertex(edgeIndices[0]);
var v1 = controlMesh.GetVertex(edgeIndices[1]);
var v2 = controlMesh.GetVertex(edgeIndices[2]);
return(new CSGPlane(v0, v1, v2));
}
// newell's method to calculate a normal for a concave polygon
var normal = MathConstants.zeroVector3;
var prevIndex = edgeIndices.Length - 1;
if (prevIndex < 0)
{
return(new CSGPlane(MathConstants.upVector3, MathConstants.zeroVector3));
}
var prevVertex = controlMesh.GetVertex(edgeIndices[prevIndex]);
for (var e = 0; e < edgeIndices.Length; e++)
{
var currVertex = controlMesh.GetVertex(edgeIndices[e]);
normal.x = normal.x + ((prevVertex.y - currVertex.y) * (prevVertex.z + currVertex.z));
normal.y = normal.y + ((prevVertex.z - currVertex.z) * (prevVertex.x + currVertex.x));
normal.z = normal.z + ((prevVertex.x - currVertex.x) * (prevVertex.y + currVertex.y));
prevVertex = currVertex;
}
normal = normal.normalized;
var d = 0.0f;
var count = 0;
for (var e = 0; e < edgeIndices.Length; e++)
{
var currVertex = controlMesh.GetVertex(edgeIndices[e]);
d += Vector3.Dot(normal, currVertex);
count++;
}
d /= count;
return(new CSGPlane(normal, d));
}
public void SetKittyObject()
{
SetTmpEffectZero();
gameObject.layer = m_LayerMask;
// m_renBackground = gameObject.AddComponent<ControlMesh>();
m_renBackground = new ControlMesh();
m_renBackground.Create(gameObject);
m_renBackground.Anchor = SpriteRoot.ANCHOR_METHOD.MIDDLE_CENTER;
m_renBackground.SetSize(DefineBaseManager.inst.KittyGap + 0.5f, DefineBaseManager.inst.KittyGap + 0.5f);
}
public static GameObject CreateBrush(ControlMesh controlMesh, Shape shape, Transform parent, string name, bool worldPositionStays)
{
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.CheckForChanges();
return(gameObject);
}
public override void Reset()
{
settings.Reset();
base.Reset();
firstSnappedPlanes = null;
firstSnappedEdges = null;
firstSnappedBrush = null;
hadSphere = false;
prevSplits = -1;
prevIsHemisphere = IsHemiSphere;
splitControlMesh = null;
splitShape = null;
sphereSmoothingGroup = null;
}
public static GameObject CreateBrush(ControlMesh controlMesh, Shape shape, Transform parent, string name, bool worldPositionStays)
{
#if DEMO
if (CSGBindings.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);
}
public void SetEffectTurnBack(Object _BaseObj)
{
ReleaseTurnBack();
m_objTurnBack = (GameObject)Instantiate(_BaseObj);
m_objTurnBack.name = "EffectTurnBack";
m_objTurnBack.layer = m_LayerMask;
m_objTurnBack.transform.parent = this.transform;
m_objTurnBack.transform.localPosition = m_posTurnBack;
m_objTurnBack.transform.eulerAngles = Vector3.zero;
SetTmpEffectZero();
m_objTurnBack.transform.localScale = m_vecTmp;
// m_renTurnBack = m_objTurnBack.AddComponent<ControlMesh>();
m_renTurnBack = new ControlMesh();
m_renTurnBack.Create(m_objTurnBack);
m_renTurnBack.Anchor = SpriteRoot.ANCHOR_METHOD.MIDDLE_CENTER;
m_renTurnBack.SetSize(DefineBaseManager.inst.KittyGap, DefineBaseManager.inst.KittyGap);
}
internal static CSGBrush CreateBrushComponent(GameObject gameObject, ControlMesh controlMesh, Shape shape)
{
var brush = gameObject.AddComponent <CSGBrush>();
if (!brush)
{
return(null);
}
brush.ControlMesh = controlMesh;
brush.Shape = shape;
if (brush.ControlMesh != null)
{
brush.ControlMesh.SetDirty();
}
if (brush.Shape != null)
{
ShapeUtility.EnsureInitialized(brush.Shape);
}
return(brush);
}
private void LoadResource()
{
if (m_imgLoading == null)
{
string ObjectPath = string.Format("{0}/Model/Loading/Loading", ResourceLoad.CheckHeight);
GameObject tmpObject = ResourceLoad.GetGameObject("Loading", ObjectPath);
m_imgLoading = new ControlMesh();
m_imgLoading.Create(tmpObject);
m_imgLoading.transform.parent = Main.inst.GetResourceObject_EZGUITEXTURE().transform;
}
else if (m_imgLoading.gameObject == null)
{
string ObjectPath = string.Format("{0}/Model/Loading/Loading", ResourceLoad.CheckHeight);
GameObject tmpObject = ResourceLoad.GetGameObject("Loading", ObjectPath);
m_imgLoading.Create(tmpObject);
m_imgLoading.transform.parent = Main.inst.GetResourceObject_EZGUITEXTURE().transform;
}
SetResources();
}
public static void CreateCutter(Shape shape, ControlMesh mesh)
{
if (shape.Surfaces.Length == 0)
{
return;
}
// sort planes by putting the most different planes before more similar planes
var unsortedPlaneIndices = new int[shape.Surfaces.Length];
for (int i = 0; i < shape.Surfaces.Length; i++)
{
unsortedPlaneIndices[i] = i;
}
int first_plane = -1;
float largestAxis = 0;
for (int i = 0; i < unsortedPlaneIndices.Length; i++)
{
var normal = shape.Surfaces[i].Plane.normal;
var normalx = Mathf.Abs(normal.x);
var normaly = Mathf.Abs(normal.y);
var normalz = Mathf.Abs(normal.z);
if (normalx > largestAxis)
{
largestAxis = normalx;
first_plane = i;
}
if (normalz > largestAxis)
{
largestAxis = normalz;
first_plane = i;
}
if (normaly > largestAxis)
{
largestAxis = normaly;
first_plane = i;
}
}
if (first_plane == -1)
{
first_plane = 0;
}
var sortedPlaneIndices = new int[unsortedPlaneIndices.Length];
ArrayUtility.RemoveAt(ref unsortedPlaneIndices, first_plane);
sortedPlaneIndices[0] = first_plane;
var prevIndex = first_plane;
var sortedPlaneCount = 1;
while (unsortedPlaneIndices.Length > 0)
{
var self_normal = shape.Surfaces[prevIndex].Plane.normal;
int new_plane = -1;
float smallestDot = 2;
for (int i = 0; i < unsortedPlaneIndices.Length; i++)
{
var other_normal = shape.Surfaces[unsortedPlaneIndices[i]].Plane.normal;
var dot = Vector3.Dot(self_normal, other_normal);
if (dot < smallestDot)
{
smallestDot = dot;
new_plane = i;
}
}
prevIndex =
sortedPlaneIndices[sortedPlaneCount] = unsortedPlaneIndices[new_plane];
sortedPlaneCount++;
ArrayUtility.RemoveAt(ref unsortedPlaneIndices, new_plane);
}
// create the cutters
shape.CutNodes = new CutNode[shape.Surfaces.Length];
for (int i = 0; i < shape.Surfaces.Length; i++)
{
shape.CutNodes[i].planeIndex = sortedPlaneIndices[i];
shape.CutNodes[i].frontNodeIndex = CutNode.Outside;
shape.CutNodes[i].backNodeIndex = (Int16)(i + 1);
}
shape.CutNodes[shape.Surfaces.Length - 1].backNodeIndex = CutNode.Inside;
}
internal static void CreateCubeControlMesh(out ControlMesh controlMesh, out Shape shape, Vector3 size)
{
size *= 0.5f;
controlMesh = new ControlMesh();
controlMesh.Vertices = new Vector3[]
{
new Vector3(-size.x, -size.y, -size.z),
new Vector3(-size.x, size.y, -size.z),
new Vector3(size.x, size.y, -size.z),
new Vector3(size.x, -size.y, -size.z),
new Vector3(-size.x, -size.y, size.z),
new Vector3(-size.x, size.y, size.z),
new Vector3(size.x, size.y, size.z),
new Vector3(size.x, -size.y, size.z)
};
controlMesh.Edges = new HalfEdge[]
{
new HalfEdge(0, 21, 0, true), // 0
new HalfEdge(0, 9, 1, true), // 1
new HalfEdge(0, 13, 2, true), // 2
new HalfEdge(0, 17, 3, true), // 3
new HalfEdge(1, 23, 7, true), // 4
new HalfEdge(1, 19, 6, true), // 5
new HalfEdge(1, 15, 5, true), // 6
new HalfEdge(1, 11, 4, true), // 7
new HalfEdge(2, 14, 1, true), // 8
new HalfEdge(2, 1, 0, true), // 9
new HalfEdge(2, 20, 4, true), // 10
new HalfEdge(2, 7, 5, true), // 11
new HalfEdge(3, 18, 2, true), // 12
new HalfEdge(3, 2, 1, true), // 13
new HalfEdge(3, 8, 5, true), // 14
new HalfEdge(3, 6, 6, true), // 15
new HalfEdge(4, 22, 3, true), // 16
new HalfEdge(4, 3, 2, true), // 17
new HalfEdge(4, 12, 6, true), // 18
new HalfEdge(4, 5, 7, true), // 19
new HalfEdge(5, 10, 0, true), // 20
new HalfEdge(5, 0, 3, true), // 21
new HalfEdge(5, 16, 7, true), // 22
new HalfEdge(5, 4, 4, true) // 23
};
controlMesh.Polygons = new Polygon[]
{
// left/right
new Polygon(new int[] { 0, 1, 2, 3 }, 0), // 0
new Polygon(new int[] { 7, 4, 5, 6 }, 1), // 1
// front/back
new Polygon(new int[] { 9, 10, 11, 8 }, 2), // 2
new Polygon(new int[] { 13, 14, 15, 12 }, 3), // 3
// top/down
new Polygon(new int[] { 16, 17, 18, 19 }, 4), // 4
new Polygon(new int[] { 20, 21, 22, 23 }, 5) // 5
};
shape = new Shape();
shape.Surfaces = new Surface[6];
shape.Surfaces[0].TexGenIndex = 0;
shape.Surfaces[1].TexGenIndex = 1;
shape.Surfaces[2].TexGenIndex = 2;
shape.Surfaces[3].TexGenIndex = 3;
shape.Surfaces[4].TexGenIndex = 4;
shape.Surfaces[5].TexGenIndex = 5;
shape.Surfaces[0].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 0);
shape.Surfaces[1].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 1);
shape.Surfaces[2].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 2);
shape.Surfaces[3].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 3);
shape.Surfaces[4].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 4);
shape.Surfaces[5].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 5);
GeometryUtility.CalculateTangents(shape.Surfaces[0].Plane.normal, out shape.Surfaces[0].Tangent, out shape.Surfaces[0].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[1].Plane.normal, out shape.Surfaces[1].Tangent, out shape.Surfaces[1].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[2].Plane.normal, out shape.Surfaces[2].Tangent, out shape.Surfaces[2].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[3].Plane.normal, out shape.Surfaces[3].Tangent, out shape.Surfaces[3].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[4].Plane.normal, out shape.Surfaces[4].Tangent, out shape.Surfaces[4].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[5].Plane.normal, out shape.Surfaces[5].Tangent, out shape.Surfaces[5].BiNormal);
shape.TexGens = new TexGen[6];
shape.TexGens[0].Scale = MathConstants.oneVector3;
shape.TexGens[1].Scale = MathConstants.oneVector3;
shape.TexGens[2].Scale = MathConstants.oneVector3;
shape.TexGens[3].Scale = MathConstants.oneVector3;
shape.TexGens[4].Scale = MathConstants.oneVector3;
shape.TexGens[5].Scale = MathConstants.oneVector3;
shape.TexGens[0].Color = Color.white;
shape.TexGens[1].Color = Color.white;
shape.TexGens[2].Color = Color.white;
shape.TexGens[3].Color = Color.white;
shape.TexGens[4].Color = Color.white;
shape.TexGens[5].Color = Color.white;
shape.TexGenFlags = new TexGenFlags[6];
shape.TexGenFlags[0] = TexGenFlags.None;
shape.TexGenFlags[1] = TexGenFlags.None;
shape.TexGenFlags[2] = TexGenFlags.None;
shape.TexGenFlags[3] = TexGenFlags.None;
shape.TexGenFlags[4] = TexGenFlags.None;
shape.TexGenFlags[5] = TexGenFlags.None;
shape.Materials = new Material[6];
shape.Materials[0] = CSGSettings.DefaultMaterial;
shape.Materials[1] = CSGSettings.DefaultMaterial;
shape.Materials[2] = CSGSettings.DefaultMaterial;
shape.Materials[3] = CSGSettings.DefaultMaterial;
shape.Materials[4] = CSGSettings.DefaultMaterial;
shape.Materials[5] = CSGSettings.DefaultMaterial;
//controlMesh.Validate();
ShapeUtility.CreateCutter(shape, controlMesh);
ShapeUtility.EnsureInitialized(shape);
controlMesh.IsValid = ControlMeshUtility.Validate(controlMesh, shape);
}
internal static bool CreateCubeControlMesh(out ControlMesh controlMesh, out Shape shape, Vector3 min, Vector3 max)
{
if (min.x > max.x)
{
float x = min.x; min.x = max.x; max.x = x;
}
if (min.y > max.y)
{
float y = min.y; min.y = max.y; max.y = y;
}
if (min.z > max.z)
{
float z = min.z; min.z = max.z; max.z = z;
}
if (min.x == max.x || min.y == max.y || min.z == max.z)
{
shape = null;
controlMesh = null;
return(false);
}
controlMesh = new ControlMesh();
controlMesh.Vertices = new Vector3[]
{
new Vector3(min.x, min.y, min.z),
new Vector3(min.x, max.y, min.z),
new Vector3(max.x, max.y, min.z),
new Vector3(max.x, min.y, min.z),
new Vector3(min.x, min.y, max.z),
new Vector3(min.x, max.y, max.z),
new Vector3(max.x, max.y, max.z),
new Vector3(max.x, min.y, max.z)
};
controlMesh.Edges = new HalfEdge[]
{
new HalfEdge(0, 21, 0, true), // 0
new HalfEdge(0, 9, 1, true), // 1
new HalfEdge(0, 13, 2, true), // 2
new HalfEdge(0, 17, 3, true), // 3
new HalfEdge(1, 23, 7, true), // 4
new HalfEdge(1, 19, 6, true), // 5
new HalfEdge(1, 15, 5, true), // 6
new HalfEdge(1, 11, 4, true), // 7
new HalfEdge(2, 14, 1, true), // 8
new HalfEdge(2, 1, 0, true), // 9
new HalfEdge(2, 20, 4, true), // 10
new HalfEdge(2, 7, 5, true), // 11
new HalfEdge(3, 18, 2, true), // 12
new HalfEdge(3, 2, 1, true), // 13
new HalfEdge(3, 8, 5, true), // 14
new HalfEdge(3, 6, 6, true), // 15
new HalfEdge(4, 22, 3, true), // 16
new HalfEdge(4, 3, 2, true), // 17
new HalfEdge(4, 12, 6, true), // 18
new HalfEdge(4, 5, 7, true), // 19
new HalfEdge(5, 10, 0, true), // 20
new HalfEdge(5, 0, 3, true), // 21
new HalfEdge(5, 16, 7, true), // 22
new HalfEdge(5, 4, 4, true) // 23
};
controlMesh.Polygons = new Polygon[]
{
// left/right
new Polygon(new int[] { 0, 1, 2, 3 }, 0), // 0
new Polygon(new int[] { 7, 4, 5, 6 }, 1), // 1
// front/back
new Polygon(new int[] { 9, 10, 11, 8 }, 2), // 2
new Polygon(new int[] { 13, 14, 15, 12 }, 3), // 3
// top/down
new Polygon(new int[] { 16, 17, 18, 19 }, 4), // 4
new Polygon(new int[] { 20, 21, 22, 23 }, 5) // 5
};
shape = new Shape();
shape.Surfaces = new Surface[6];
shape.Surfaces[0].TexGenIndex = 0;
shape.Surfaces[1].TexGenIndex = 1;
shape.Surfaces[2].TexGenIndex = 2;
shape.Surfaces[3].TexGenIndex = 3;
shape.Surfaces[4].TexGenIndex = 4;
shape.Surfaces[5].TexGenIndex = 5;
shape.Surfaces[0].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 0);
shape.Surfaces[1].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 1);
shape.Surfaces[2].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 2);
shape.Surfaces[3].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 3);
shape.Surfaces[4].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 4);
shape.Surfaces[5].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, 5);
GeometryUtility.CalculateTangents(shape.Surfaces[0].Plane.normal, out shape.Surfaces[0].Tangent, out shape.Surfaces[0].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[1].Plane.normal, out shape.Surfaces[1].Tangent, out shape.Surfaces[1].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[2].Plane.normal, out shape.Surfaces[2].Tangent, out shape.Surfaces[2].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[3].Plane.normal, out shape.Surfaces[3].Tangent, out shape.Surfaces[3].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[4].Plane.normal, out shape.Surfaces[4].Tangent, out shape.Surfaces[4].BiNormal);
GeometryUtility.CalculateTangents(shape.Surfaces[5].Plane.normal, out shape.Surfaces[5].Tangent, out shape.Surfaces[5].BiNormal);
var defaultMaterial = CSGSettings.DefaultMaterial;
shape.TexGens = new TexGen[6];
shape.TexGens[0].RenderMaterial = defaultMaterial;
shape.TexGens[1].RenderMaterial = defaultMaterial;
shape.TexGens[2].RenderMaterial = defaultMaterial;
shape.TexGens[3].RenderMaterial = defaultMaterial;
shape.TexGens[4].RenderMaterial = defaultMaterial;
shape.TexGens[5].RenderMaterial = defaultMaterial;
shape.TexGens[0].Scale = MathConstants.oneVector3;
shape.TexGens[1].Scale = MathConstants.oneVector3;
shape.TexGens[2].Scale = MathConstants.oneVector3;
shape.TexGens[3].Scale = MathConstants.oneVector3;
shape.TexGens[4].Scale = MathConstants.oneVector3;
shape.TexGens[5].Scale = MathConstants.oneVector3;
shape.TexGens[0].Color = Color.white;
shape.TexGens[1].Color = Color.white;
shape.TexGens[2].Color = Color.white;
shape.TexGens[3].Color = Color.white;
shape.TexGens[4].Color = Color.white;
shape.TexGens[5].Color = Color.white;
shape.TexGenFlags = new TexGenFlags[6];
shape.TexGenFlags[0] = TexGenFlags.None;
shape.TexGenFlags[1] = TexGenFlags.None;
shape.TexGenFlags[2] = TexGenFlags.None;
shape.TexGenFlags[3] = TexGenFlags.None;
shape.TexGenFlags[4] = TexGenFlags.None;
shape.TexGenFlags[5] = TexGenFlags.None;
//controlMesh.Validate();
ShapeUtility.EnsureInitialized(shape);
controlMesh.IsValid = ControlMeshUtility.Validate(controlMesh, shape);
return(controlMesh.IsValid);
}
internal static bool CreateCubeControlMesh(out ControlMesh controlMesh, out Shape shape, Vector3 size)
{
Vector3 halfSize = size * 0.5f;
return(CreateCubeControlMesh(out controlMesh, out shape, halfSize, -halfSize));
}
private void SetAlpha(ControlMesh _ren, float _Alpha)
{
m_colorTmp = _ren.color;
m_colorTmp.a = _Alpha;
_ren.color = m_colorTmp;
}
internal abstract bool CreateControlMeshForBrushIndex(CSGModel parentModel, CSGBrush brush, ShapePolygon polygon, Matrix4x4 localToWorld, float height, out ControlMesh newControlMesh, out Shape newShape);
public void UpdateHandles(Camera camera, ControlMesh controlMesh)
{
if (controlMesh == null ||
controlMesh.Vertices == null ||
controlMesh.Edges == null ||
controlMesh.Polygons == null ||
PolygonPointIndices == null)
{
return;
}
var cameraState = GetCameraState(camera, true);
var cameraPosition = camera.transform.position;
var cameraOrtho = camera.orthographic;
GetHandleSizes(camera, ref cameraState.PolygonCenterPointSizes, PolygonCenterPoints);
GetHandleSizes(camera, ref cameraState.WorldPointSizes, WorldPoints);
if (cameraState.WorldPointBackfaced.Length != WorldPoints.Length)
{
cameraState.WorldPointBackfaced = new bool[WorldPoints.Length];
}
for (var p = 0; p < cameraState.WorldPointBackfaced.Length; p++)
{
cameraState.WorldPointBackfaced[p] = true;
}
for (int p = 0; p < PolygonCenterPoints.Length; p++)
{
var handleSize = cameraState.PolygonCenterPointSizes[p];
var delta1 = (PolygonCenterPoints[p] - BrushCenter).normalized;
var delta2 = (PolygonCenterPoints[p] - cameraPosition).normalized;
var dot = Vector3.Dot(delta1, delta2);
var polygonBackfaced = Mathf.Abs(dot) > 1 - MathConstants.AngleEpsilon;
if (cameraOrtho && polygonBackfaced)
{
handleSize = 0;
}
else
if (dot > 0)
{
handleSize *= GUIConstants.backHandleScale;
}
else
{
handleSize *= GUIConstants.handleScale;
if (PolygonPointIndices != null &&
p < PolygonPointIndices.Length)
{
var indices = PolygonPointIndices[p];
if (indices != null)
{
for (var i = 0; i < indices.Length; i++)
{
if (indices[i] >= cameraState.WorldPointBackfaced.Length)
{
PolygonPointIndices[p] = null;
break;
}
cameraState.WorldPointBackfaced[indices[i]] = false;
}
}
}
}
cameraState.PolygonCenterPointSizes[p] = handleSize;
}
for (var p = 0; p < cameraState.WorldPointSizes.Length; p++)
{
var handleSize = cameraState.WorldPointSizes[p];
if (cameraState.WorldPointBackfaced[p])
{
handleSize *= GUIConstants.backHandleScale;
}
else
{
handleSize *= GUIConstants.handleScale;
}
cameraState.WorldPointSizes[p] = handleSize;
}
}
public void UpdateMesh(ControlMesh controlMesh, Vector3[] vertices = null)
{
if (controlMesh == null ||
controlMesh.Vertices == null ||
controlMesh.Edges == null ||
controlMesh.Polygons == null ||
PolygonPointIndices == null)
{
return;
}
if (vertices == null)
{
vertices = controlMesh.Vertices;
}
if (!BrushTransform)
{
return;
}
var pointCount = vertices.Length;
if (WorldPoints.Length != pointCount)
{
AllocatePoints(pointCount);
}
var edgeCount = controlMesh.Edges.Length;
if (Edges.Length != edgeCount)
{
AllocateEdges(edgeCount);
}
var polygonCount = controlMesh.Polygons.Length;
if (PolygonControlId.Length != polygonCount)
{
AllocatePolygons(polygonCount);
}
var index = 0;
for (var e = 0; e < edgeCount; e++)
{
if (e >= controlMesh.Edges.Length ||
index >= Edges.Length)
{
continue;
}
var twin = controlMesh.Edges[e].TwinIndex;
if (twin < e || // if it's less than e then we've already handled our twin
twin >= controlMesh.Edges.Length)
{
continue;
}
var polygonIndex = controlMesh.Edges[e].PolygonIndex;
if (polygonIndex < 0 || polygonIndex >= controlMesh.Polygons.Length)
{
continue;
}
var twinPolygonIndex = controlMesh.Edges[twin].PolygonIndex;
if (twinPolygonIndex < 0 || twinPolygonIndex >= controlMesh.Polygons.Length)
{
continue;
}
var vertexIndex1 = controlMesh.Edges[e].VertexIndex;
var vertexIndex2 = controlMesh.Edges[twin].VertexIndex;
if (vertexIndex1 < 0 || vertexIndex1 >= Selection.Points.Length ||
vertexIndex2 < 0 || vertexIndex2 >= Selection.Points.Length)
{
continue;
}
Edges[index] = vertexIndex1;
Edges[index + 1] = vertexIndex2;
EdgeStateToHalfEdge[index / 2] = e;
HalfEdgeToEdgeStates[e] = index;
HalfEdgeToEdgeStates[twin] = index;
EdgeSurfaces[index] = polygonIndex;
EdgeSurfaces[index + 1] = twinPolygonIndex;
/*
* if ((Selection.Points[vertexIndex1] & SelectState.Selected) == SelectState.Selected &&
* (Selection.Points[vertexIndex2] & SelectState.Selected) == SelectState.Selected)
* Selection.Edges[index / 2] |= SelectState.Selected;
* else
* Selection.Edges[index / 2] &= ~SelectState.Selected;
*/
//edgeSelectState[index / 2] = SelectState.None;
index += 2;
}
var polygonCountModified = false;
while (polygonCount > PolygonPointIndices.Length)
{
ArrayUtility.Add(ref PolygonPointIndices, null);
polygonCountModified = true;
}
while (polygonCount < PolygonPointIndices.Length)
{
ArrayUtility.RemoveAt(ref PolygonPointIndices, PolygonPointIndices.Length - 1);
polygonCountModified = true;
}
if (polygonCountModified)
{
for (var i = 0; i < polygonCount; i++)
{
PolygonPointIndices[i] = null;
}
}
UpdatePoints(controlMesh, vertices);
}
public void UpdatePoints(ControlMesh controlMesh, Vector3[] vertices = null)
{
if (controlMesh == null ||
controlMesh.Vertices == null ||
controlMesh.Edges == null ||
controlMesh.Polygons == null ||
PolygonPointIndices == null)
{
return;
}
if (vertices == null)
{
vertices = controlMesh.Vertices;
}
if (!BrushTransform)
{
return;
}
var pointCount = vertices.Length;
if (WorldPoints.Length != pointCount)
{
AllocatePoints(pointCount);
}
var edgeCount = controlMesh.Edges.Length;
if (Edges.Length != edgeCount)
{
AllocateEdges(edgeCount);
}
var polygonCount = controlMesh.Polygons.Length;
if (PolygonControlId.Length != polygonCount)
{
AllocatePolygons(polygonCount);
}
var localToWorldMatrix = BrushTransform.localToWorldMatrix;
for (var p = 0; p < pointCount; p++)
{
var worldPoint = localToWorldMatrix.MultiplyPoint(vertices[p]);
WorldPoints[p] = worldPoint;
}
var brushTotalLength = 0.0f;
BrushCenter = MathConstants.zeroVector3;
for (var p = 0; p < polygonCount; p++)
{
var localCenterPoint = MathConstants.zeroVector3;
var totalLength = 0.0f;
var polygon = controlMesh.Polygons[p];
if (polygon == null)
{
continue;
}
var edgeIndices = polygon.EdgeIndices;
if (edgeIndices == null ||
edgeIndices.Length == 0)
{
continue;
}
var halfEdgeIndex0 = edgeIndices[edgeIndices.Length - 1];
if (halfEdgeIndex0 < 0 || halfEdgeIndex0 >= controlMesh.Edges.Length)
{
continue;
}
var vertexIndex0 = controlMesh.Edges[halfEdgeIndex0].VertexIndex;
if (vertexIndex0 < 0 || vertexIndex0 >= vertices.Length)
{
continue;
}
var vertex0 = vertices[vertexIndex0];
if (PolygonPointIndices[p] == null ||
PolygonPointIndices[p].Length != edgeIndices.Length)
{
PolygonPointIndices[p] = new int[edgeIndices.Length];
}
var newPointIndices = PolygonPointIndices[p];
for (var i = 0; i < edgeIndices.Length; i++)
{
var halfEdgeIndex1 = edgeIndices[i];
if (halfEdgeIndex1 < 0 ||
halfEdgeIndex1 >= controlMesh.Edges.Length)
{
continue;
}
var vertexIndex1 = controlMesh.Edges[halfEdgeIndex1].VertexIndex;
if (vertexIndex1 < 0 ||
vertexIndex1 >= vertices.Length)
{
continue;
}
var vertex1 = vertices[vertexIndex1];
newPointIndices[i] = vertexIndex1;
var length = (vertex1 - vertex0).sqrMagnitude;
localCenterPoint += (vertex1 + vertex0) * 0.5f * length;
totalLength += length;
brushTotalLength += length;
vertex0 = vertex1;
}
var worldCenterPoint = Mathf.Abs(totalLength) < MathConstants.EqualityEpsilon ?
localToWorldMatrix.MultiplyPoint(vertex0) :
localToWorldMatrix.MultiplyPoint(localCenterPoint / totalLength);
BrushCenter += localCenterPoint;
PolygonCenterPoints[p] = worldCenterPoint;
PolygonCenterPlanes[p] = GeometryUtility.CalcPolygonPlane(controlMesh, (short)p);
}
if (Mathf.Abs(brushTotalLength) >= MathConstants.EqualityEpsilon)
{
BrushCenter /= brushTotalLength;
}
BrushCenter = localToWorldMatrix.MultiplyPoint(BrushCenter);
}
public void InitControlMesh()
{
controlMesh = new ControlMesh(GetComponent <MeshFilter>().sharedMesh);
initControlMesh = true;
}
public bool UpdateColors(Camera camera, CSGBrush brush, ControlMesh controlMesh)
{
if (controlMesh == null)
{
return(false);
}
var cameraState = GetCameraState(camera, false);
if (cameraState == null)
{
return(false);
}
var valid = controlMesh.Valid;
var cameraPosition = camera.transform.position;
var cameraOrtho = camera.orthographic;
var polygonCount = PolygonCenterPoints.Length;
for (int j = 0, p = 0; p < polygonCount; p++, j += 2)
{
var state = (int)Selection.Polygons[p];
Color color1, color2;
if (valid)
{
color1 = ColorSettings.MeshEdgeOutline;
color2 = ColorSettings.PolygonInnerStateColor[state];
}
else
{
color1 = ColorSettings.outerInvalidColor;
color2 = ColorSettings.innerInvalidColor;
}
var delta1 = (PolygonCenterPoints[p] - BrushCenter).normalized;
var delta2 = (PolygonCenterPoints[p] - cameraPosition).normalized;
var dot = Vector3.Dot(delta1, delta2);
if (!cameraOrtho || Mathf.Abs(dot) <= 1 - MathConstants.AngleEpsilon)
{
color1.a *= GUIConstants.backfaceTransparency;
color2.a *= GUIConstants.backfaceTransparency;
}
if (state == (int)SelectState.None)
{
PolygonColors[p] = Color.clear;
}
else
{
var polygonColor = ColorSettings.PointInnerStateColor[state];
polygonColor.a *= 0.3f;
PolygonColors[p] = polygonColor;
}
PolygonCenterColors[j + 0] = color1;
PolygonCenterColors[j + 1] = color2;
}
var edgeCount = Edges.Length;
for (int j = 0, e = 0; j < edgeCount; e++, j += 2)
{
var state = (int)(Selection.Edges[e]
// | surfaceSelectState[edgeSurfaces[j ]]
// | surfaceSelectState[edgeSurfaces[j + 1]]
);
if (valid)
{
var color = ColorSettings.PointInnerStateColor[state];
EdgeColors[e] = color;
}
else
{
EdgeColors[e] = ColorSettings.InvalidInnerStateColor[state];
}
}
if (cameraState.WorldPointColors.Length != Selection.Points.Length * 2)
{
cameraState.WorldPointColors = new Color[Selection.Points.Length * 2];
}
for (int j = 0, p = 0; p < Selection.Points.Length; p++, j += 2)
{
var state = (int)Selection.Points[p];
var color1 = ColorSettings.VertexPoint;
var color2 = valid
? ColorSettings.PointInnerStateColor[state]
: ColorSettings.InvalidInnerStateColor[state];
if (cameraState.WorldPointBackfaced[p])
{
color1.a *= GUIConstants.backfaceTransparency;
color2.a *= GUIConstants.backfaceTransparency;
}
else
{
color2.a = 1.0f;
}
cameraState.WorldPointColors[j + 0] = color1;
cameraState.WorldPointColors[j + 1] = color2;
}
return(true);
}
public static bool GenerateControlMeshFromVertices(ShapePolygon shape2DPolygon,
Matrix4x4 localToWorld,
Vector3 direction,
float height,
Material capMaterial,
TexGen capTexgen,
bool?smooth,
bool singleSurfaceEnds, //Plane buildPlane,
out ControlMesh controlMesh,
out Shape shape)
{
if (shape2DPolygon == null)
{
controlMesh = null;
shape = null;
return(false);
}
var vertices = shape2DPolygon.Vertices;
if (vertices.Length < 3)
{
controlMesh = null;
shape = null;
return(false);
}
if (height == 0.0f)
{
controlMesh = null;
shape = null;
return(false);
}
Vector3 from;
Vector3 to;
if (height > 0)
{
@from = direction * height; // buildPlane.normal * height;
to = MathConstants.zeroVector3;
}
else
{
@from = MathConstants.zeroVector3;
to = direction * height; //buildPlane.normal * height;
}
var count = vertices.Length;
var doubleCount = (count * 2);
var extraPoints = 0;
var extraEdges = 0;
var endsPolygons = 2;
var startEdgeOffset = doubleCount;
if (!singleSurfaceEnds)
{
extraPoints = 2;
extraEdges = (4 * count);
endsPolygons = doubleCount;
startEdgeOffset += extraEdges;
}
var dstPoints = new Vector3 [doubleCount + extraPoints];
var dstEdges = new HalfEdge[(count * 6) + extraEdges];
var dstPolygons = new Polygon [count + endsPolygons];
var center1 = MathConstants.zeroVector3;
var center2 = MathConstants.zeroVector3;
for (int i = 0; i < count; i++)
{
var point1 = vertices[i];
var point2 = vertices[(count + i - 1) % count];
point1 += @from;
point2 += to;
// swap y/z to solve texgen issues
dstPoints[i].x = point1.x;
dstPoints[i].y = point1.y;
dstPoints[i].z = point1.z;
center1 += dstPoints[i];
dstEdges [i].VertexIndex = (short)i;
dstEdges [i].HardEdge = true;
// swap y/z to solve texgen issues
dstPoints[i + count].x = point2.x;
dstPoints[i + count].y = point2.y;
dstPoints[i + count].z = point2.z;
center2 += dstPoints[i + count];
dstEdges [i + count].VertexIndex = (short)(i + count);
dstEdges [i + count].HardEdge = true;
}
if (!singleSurfaceEnds)
{
dstPoints[doubleCount] = center1 / count;
dstPoints[doubleCount + 1] = center2 / count;
int edge_offset = doubleCount;
short polygon_index = (short)count;
// 'top'
for (int i = 0, j = count - 1; i < count; j = i, i++)
{
var jm = (j) % count;
var im = (i) % count;
var edgeOut0 = edge_offset + (jm * 2) + 1;
var edgeIn0 = edge_offset + (im * 2) + 0;
var edgeOut1 = edge_offset + (im * 2) + 1;
dstEdges[edgeIn0].VertexIndex = (short)(doubleCount);
dstEdges[edgeIn0].HardEdge = true;
dstEdges[edgeIn0].TwinIndex = edgeOut1;
dstEdges[edgeOut1].VertexIndex = (short)im;
dstEdges[edgeOut1].HardEdge = true;
dstEdges[edgeOut1].TwinIndex = edgeIn0;
dstEdges[im].PolygonIndex = polygon_index;
dstEdges[edgeIn0].PolygonIndex = polygon_index;
dstEdges[edgeOut0].PolygonIndex = polygon_index;
dstPolygons[polygon_index] = new Polygon(new int[] { im, edgeIn0, edgeOut0 }, polygon_index);
polygon_index++;
}
edge_offset = doubleCount * 2;
// 'bottom'
for (int i = 0, j = count - 1; j >= 0; i = j, j--)
{
var jm = (count + count - j) % count;
var im = (count + count - i) % count;
var edgeOut0 = edge_offset + (jm * 2) + 1;
var edgeIn0 = edge_offset + (im * 2) + 0;
var edgeOut1 = edge_offset + (im * 2) + 1;
dstEdges[edgeIn0].VertexIndex = (short)(doubleCount + 1);
dstEdges[edgeIn0].HardEdge = true;
dstEdges[edgeIn0].TwinIndex = edgeOut1;
dstEdges[edgeOut1].VertexIndex = (short)(im + count);
dstEdges[edgeOut1].HardEdge = true;
dstEdges[edgeOut1].TwinIndex = edgeIn0;
dstEdges[im + count].PolygonIndex = polygon_index;
dstEdges[edgeIn0].PolygonIndex = polygon_index;
dstEdges[edgeOut0].PolygonIndex = polygon_index;
dstPolygons[polygon_index] = new Polygon(new int[] { im + count, edgeIn0, edgeOut0 }, polygon_index);
polygon_index++;
}
}
else
{
var polygon0Edges = new int[count];
var polygon1Edges = new int[count];
for (var i = 0; i < count; i++)
{
dstEdges [i].PolygonIndex = (short)(count + 0);
dstEdges [i + count].PolygonIndex = (short)(count + 1);
polygon0Edges[i] = i;
polygon1Edges[count - (i + 1)] = i + count;
}
dstPolygons[count + 0] = new Polygon(polygon0Edges, count + 0);
dstPolygons[count + 1] = new Polygon(polygon1Edges, count + 1);
}
for (int v0 = count - 1, v1 = 0; v1 < count; v0 = v1, v1++)
{
var polygonIndex = (short)(v1);
var nextOffset = startEdgeOffset + (((v1 + 1) % count) * 4);
var currOffset = startEdgeOffset + (((v1)) * 4);
var prevOffset = startEdgeOffset + (((v1 + count - 1) % count) * 4);
var nextTwin = nextOffset + 1;
var prevTwin = prevOffset + 3;
dstEdges[v1].TwinIndex = currOffset + 0;
dstEdges[v1 + count].TwinIndex = currOffset + 2;
dstEdges[currOffset + 0].PolygonIndex = polygonIndex;
dstEdges[currOffset + 1].PolygonIndex = polygonIndex;
dstEdges[currOffset + 2].PolygonIndex = polygonIndex;
dstEdges[currOffset + 3].PolygonIndex = polygonIndex;
dstEdges[currOffset + 0].TwinIndex = (v1);
dstEdges[currOffset + 1].TwinIndex = prevTwin;
dstEdges[currOffset + 2].TwinIndex = (v1 + count);
dstEdges[currOffset + 3].TwinIndex = nextTwin;
dstEdges[currOffset + 0].VertexIndex = (short)(v0);
dstEdges[currOffset + 1].VertexIndex = (short)(v1 + count);
dstEdges[currOffset + 2].VertexIndex = (short)(((v1 + 1) % count) + count);
dstEdges[currOffset + 3].VertexIndex = (short)(v1);
dstEdges[currOffset + 0].HardEdge = true;
dstEdges[currOffset + 1].HardEdge = true;
dstEdges[currOffset + 2].HardEdge = true;
dstEdges[currOffset + 3].HardEdge = true;
dstPolygons[polygonIndex] = new Polygon(new [] { currOffset + 0,
currOffset + 1,
currOffset + 2,
currOffset + 3 }, polygonIndex);
}
for (int i = 0; i < dstPoints.Length; i++)
{
dstPoints[i] = localToWorld.MultiplyPoint(dstPoints[i]);
}
controlMesh = new ControlMesh
{
Vertices = dstPoints,
Edges = dstEdges,
Polygons = dstPolygons
};
controlMesh.SetDirty();
shape = new Shape
{
Materials = new Material[dstPolygons.Length],
Surfaces = new Surface[dstPolygons.Length],
TexGenFlags = new TexGenFlags[dstPolygons.Length],
TexGens = new TexGen[dstPolygons.Length]
};
var smoothinggroup = (smooth.HasValue && smooth.Value) ? SurfaceUtility.FindUnusedSmoothingGroupIndex() : 0;
var containedMaterialCount = 0;
if (shape2DPolygon.EdgeMaterials != null &&
shape2DPolygon.EdgeTexgens != null /* &&
* shape2DPolygon.edgeTexgenFlags != null*/)
{
containedMaterialCount = Mathf.Min(shape2DPolygon.EdgeMaterials.Length,
shape2DPolygon.EdgeTexgens.Length /*,
* shape2DPolygon.edgeTexgenFlags.Length*/);
}
if (!capMaterial)
{
capMaterial = CSGSettings.DefaultMaterial;
capTexgen = new TexGen(-1);
}
for (var i = 0; i < dstPolygons.Length; i++)
{
if (i < containedMaterialCount)
{
//shape.TexGenFlags[i] = shape2DPolygon.edgeTexgenFlags[i];
shape.Materials [i] = shape2DPolygon.EdgeMaterials[i];
shape.TexGens [i] = shape2DPolygon.EdgeTexgens[i];
shape.Surfaces [i].TexGenIndex = i;
shape.TexGens[i].MaterialIndex = -1;
}
else
{
shape.Materials[i] = capMaterial;
shape.TexGens[i] = capTexgen;
//shape.TexGenFlags[i] = TexGenFlags.None;
shape.Surfaces[i].TexGenIndex = i;
shape.TexGens[i].MaterialIndex = -1;
}
if (smooth.HasValue)
{
if (i < count)
{
shape.TexGens[i].SmoothingGroup = smoothinggroup;
}
else
{
shape.TexGens[i].SmoothingGroup = 0;
}
}
}
for (var s = 0; s < dstPolygons.Length; s++)
{
var normal = shape.Surfaces[s].Plane.normal;
shape.Surfaces[s].Plane = GeometryUtility.CalcPolygonPlane(controlMesh, (short)s);
Vector3 tangent, binormal;
GeometryUtility.CalculateTangents(normal, out tangent, out binormal);
//var tangent = Vector3.Cross(GeometryUtility.CalculateTangent(normal), normal).normalized;
//var binormal = Vector3.Cross(normal, tangent);
shape.Surfaces[s].Tangent = tangent;
shape.Surfaces[s].BiNormal = binormal;
shape.Surfaces[s].TexGenIndex = s;
}
controlMesh.IsValid = ControlMeshUtility.Validate(controlMesh, shape);
if (controlMesh.IsValid)
{
return(true);
}
controlMesh = null;
shape = null;
return(false);
}
internal override bool CreateControlMeshForBrushIndex(CSGModel parentModel, CSGBrush brush, ShapePolygon polygon, Matrix4x4 localToWorld, float height, out ControlMesh newControlMesh, out Shape newShape)
{
var direction = haveForcedDirection ? forcedDirection : buildPlane.normal;
if (!ShapePolygonUtility.GenerateControlMeshFromVertices(polygon,
localToWorld,
GeometryUtility.RotatePointIntoPlaneSpace(buildPlane, direction),
height,
new TexGen(),
false,
true,
out newControlMesh,
out newShape))
{
return false;
}
brush.Shape = newShape;
brush.ControlMesh = newControlMesh;
InternalCSGModelManager.ValidateBrush(brush, true);
ControlMeshUtility.RebuildShape(brush);
return true;
}
internal override bool CreateControlMeshForBrushIndex(CSGModel parentModel, CSGBrush brush, ShapePolygon polygon, Matrix4x4 localToWorld, float height, out ControlMesh newControlMesh, out Shape newShape)
{
bool smooth = settings.circleSmoothShading;
bool singleSurfaceEnds = settings.circleSingleSurfaceEnds;
var direction = haveForcedDirection ? forcedDirection : buildPlane.normal;
if (!ShapePolygonUtility.GenerateControlMeshFromVertices(polygon,
localToWorld,
GeometryUtility.RotatePointIntoPlaneSpace(buildPlane, direction),
height,
new TexGen(),
smooth,
singleSurfaceEnds,
out newControlMesh,
out newShape))
{
return(false);
}
brush.Shape = newShape;
brush.ControlMesh = newControlMesh;
InternalCSGModelManager.ValidateBrush(brush, true);
ControlMeshUtility.RebuildShape(brush);
var vertices = polygon.Vertices;
float circumference = 0.0f;
for (int j = vertices.Length - 1, i = 0; i < vertices.Length; j = i, i++)
{
circumference += (vertices[j] - vertices[i]).magnitude;
}
var shape = brush.Shape;
float desiredTextureLength = Mathf.Max(1.0f, Mathf.Round(circumference));
float scalar = desiredTextureLength / circumference;
shape.TexGens[0].Scale.x = scalar;
shape.TexGens[0].Scale.y = shape.TexGens[0].Scale.y;
shape.TexGens[0].Translation.x = 0;
var count = vertices.Length;
if (!singleSurfaceEnds)
{
GeometryUtility.ContinueTexGenFromSurfaceToSurface(brush, 0, count);
GeometryUtility.ContinueTexGenFromSurfaceToSurface(brush, 0, count + count);
for (int j = 0, i = 1; i < count; j = i, i++)
{
GeometryUtility.ContinueTexGenFromSurfaceToSurface(brush, j, i);
GeometryUtility.ContinueTexGenFromSurfaceToSurface(brush, i, i + count);
GeometryUtility.ContinueTexGenFromSurfaceToSurface(brush, i, i + count + count);
}
}
else
{
for (int j = 0, i = 1; i < count; j = i, i++)
{
GeometryUtility.ContinueTexGenFromSurfaceToSurface(brush, j, i);
}
}
return(true);
}
private bool GenerateSphere(float radius, int splits, CSGModel parentModel, CSGBrush brush, out ControlMesh controlMesh, out Shape shape)
{
if (prevSplits != splits || prevIsHemisphere != IsHemiSphere || splitControlMesh == null || splitShape == null)
{
splitControlMesh = null;
splitShape = null;
BrushFactory.CreateCubeControlMesh(out splitControlMesh, out splitShape, Vector3.one);
var axi = new Vector3[] { MathConstants.upVector3, MathConstants.leftVector3, MathConstants.forwardVector3 };
List<int> intersectedEdges = new List<int>();
float step = 1.0f / (float)(splits + 1);
float offset;
for (int i = 0; i < axi.Length; i++)
{
var normal = axi[i];
offset = 0.5f - step;
while (offset > 0.0f)
{
ControlMeshUtility.CutMesh(splitControlMesh, splitShape, new CSGPlane(-normal, -offset), ref intersectedEdges);
if (i != 0 || !IsHemiSphere)
{
ControlMeshUtility.CutMesh(splitControlMesh, splitShape, new CSGPlane(normal, -offset), ref intersectedEdges);
}
offset -= step;
}
if (i != 0 || !IsHemiSphere)
{
if ((splits & 1) == 1)
ControlMeshUtility.CutMesh(splitControlMesh, splitShape, new CSGPlane(normal, 0), ref intersectedEdges);
}
}
if (IsHemiSphere)
{
var cuttingPlane = new CSGPlane(MathConstants.upVector3, 0);
intersectedEdges.Clear();
if (ControlMeshUtility.CutMesh(splitControlMesh, splitShape, cuttingPlane, ref intersectedEdges))
{
var edge_loop = ControlMeshUtility.FindEdgeLoop(splitControlMesh, ref intersectedEdges);
if (edge_loop != null)
{
if (ControlMeshUtility.SplitEdgeLoop(splitControlMesh, splitShape, edge_loop))
{
Shape foundShape;
ControlMesh foundControlMesh;
ControlMeshUtility.FindAndDetachSeparatePiece(splitControlMesh, splitShape, cuttingPlane, out foundControlMesh, out foundShape);
}
}
}
}
// Spherize the cube
for (int i = 0; i < splitControlMesh.Vertices.Length; i++)
{
Vector3 v = splitControlMesh.Vertices[i] * 2.0f;
float x2 = v.x * v.x;
float y2 = v.y * v.y;
float z2 = v.z * v.z;
Vector3 s;
s.x = v.x * Mathf.Sqrt(1f - (y2 * 0.5f) - (z2 * 0.5f) + ((y2 * z2) / 3.0f));
s.y = v.y * Mathf.Sqrt(1f - (z2 * 0.5f) - (x2 * 0.5f) + ((z2 * x2) / 3.0f));
s.z = v.z * Mathf.Sqrt(1f - (x2 * 0.5f) - (y2 * 0.5f) + ((x2 * y2) / 3.0f));
splitControlMesh.Vertices[i] = s;//(splitControlMesh.Vertices[i] * 0.75f) + (splitControlMesh.Vertices[i].normalized * 0.25f);
}
if (!ControlMeshUtility.Triangulate(null, splitControlMesh, splitShape))
{
Debug.LogWarning("!ControlMeshUtility.IsConvex");
controlMesh = null;
shape = null;
return false;
}
ControlMeshUtility.FixTexGens(splitControlMesh, splitShape);
if (!ControlMeshUtility.IsConvex(splitControlMesh, splitShape))
{
Debug.LogWarning("!ControlMeshUtility.IsConvex");
controlMesh = null;
shape = null;
return false;
}
ControlMeshUtility.UpdateTangents(splitControlMesh, splitShape);
prevSplits = splits;
prevIsHemisphere = IsHemiSphere;
}
if (splitControlMesh == null || splitShape == null || !splitControlMesh.Valid)
{
Debug.LogWarning("splitControlMesh == null || splitShape == null || !splitControlMesh.IsValid");
controlMesh = null;
shape = null;
return false;
}
controlMesh = splitControlMesh.Clone();
shape = splitShape.Clone();
/*
float angle_offset = GeometryUtility.SignedAngle(gridTangent, delta / sphereRadius, buildPlane.normal);
angle_offset -= 90;
angle_offset += sphereOffset;
angle_offset *= Mathf.Deg2Rad;
Vector3 p1 = MathConstants.zeroVector3;
for (int i = 0; i < realSplits; i++)
{
var angle = ((i * Mathf.PI * 2.0f) / (float)realSplits) + angle_offset;
p1.x = (Mathf.Sin(angle) * sphereRadius);
p1.z = (Mathf.Cos(angle) * sphereRadius);
}
*/
for (int i = 0; i < controlMesh.Vertices.Length; i++)
{
var vertex = controlMesh.Vertices[i];
vertex *= radius;
controlMesh.Vertices[i] = vertex;
}
for (int i = 0; i < shape.Surfaces.Length; i++)
{
var plane = shape.Surfaces[i].Plane;
plane.d *= radius;
shape.Surfaces[i].Plane = plane;
}
bool smoothShading = SphereSmoothShading;
if (!sphereSmoothingGroup.HasValue && smoothShading)
{
sphereSmoothingGroup = SurfaceUtility.FindUnusedSmoothingGroupIndex();
}
for (int i = 0; i < shape.TexGenFlags.Length; i++)
{
shape.TexGens[i].SmoothingGroup = smoothShading ? sphereSmoothingGroup.Value : 0;
}
var defaultTexGen = new TexGen();
defaultTexGen.Scale = MathConstants.oneVector3;
//defaultTexGen.Color = Color.white;
var fakeSurface = new Surface();
fakeSurface.TexGenIndex = 0;
var defaultMaterial = CSGSettings.DefaultMaterial;
for (var s = 0; s < shape.Surfaces.Length; s++)
{
var texGenIndex = shape.Surfaces[s].TexGenIndex;
var axis = GeometryUtility.SnapToClosestAxis(shape.Surfaces[s].Plane.normal);
var rotation = Quaternion.FromToRotation(axis, MathConstants.backVector3);
var matrix = Matrix4x4.TRS(MathConstants.zeroVector3, rotation, MathConstants.oneVector3);
SurfaceUtility.AlignTextureSpaces(matrix, false, ref shape.TexGens[texGenIndex], ref shape.TexGenFlags[texGenIndex], ref shape.Surfaces[s]);
shape.TexGens[texGenIndex].RenderMaterial = defaultMaterial;
}
return true;
}
internal static bool CreateControlMeshFromPlanes(out ControlMesh controlMesh,
out Shape shape,
UnityEngine.Plane[] planes,
Vector3[] tangents = null,
Vector3[] binormals = null,
Material[] materials = null,
Matrix4x4[] textureMatrices = null,
TextureMatrixSpace textureMatrixSpace = TextureMatrixSpace.WorldSpace,
uint[] smoothingGroups = null,
TexGenFlags[] texGenFlags = null,
float distanceEpsilon = MathConstants.DistanceEpsilon,
Vector3?offset = null)
{
controlMesh = null;
shape = null;
if (planes == null)
{
Debug.LogError("The planes array is not allowed to be null");
return(false);
}
if (planes.Length < 4)
{
Debug.LogError("The planes array must have at least 4 planes");
return(false);
}
if (materials == null)
{
materials = new Material[planes.Length];
for (int i = 0; i < materials.Length; i++)
{
materials[i] = CSGSettings.DefaultMaterial;
}
}
if (planes.Length != materials.Length ||
(textureMatrices != null && planes.Length != textureMatrices.Length) ||
(tangents != null && tangents.Length != textureMatrices.Length) ||
(binormals != null && binormals.Length != textureMatrices.Length) ||
(smoothingGroups != null && smoothingGroups.Length != materials.Length))
{
Debug.LogError("All non null arrays need to be of equal length");
return(false);
}
shape = new Shape();
shape.TexGenFlags = new TexGenFlags[planes.Length];
shape.Surfaces = new Surface[planes.Length];
shape.TexGens = new TexGen[planes.Length];
for (int i = 0; i < planes.Length; i++)
{
shape.Surfaces[i].Plane = new CSGPlane(planes[i].normal, -planes[i].distance);
if (offset.HasValue)
{
shape.Surfaces[i].Plane.Translate(offset.Value);
}
Vector3 tangent, binormal;
if (tangents != null && binormals != null)
{
tangent = tangents[i];
binormal = binormals[i];
}
else
{
GeometryUtility.CalculateTangents(planes[i].normal, out tangent, out binormal);
}
shape.Surfaces[i].Tangent = -tangent;
shape.Surfaces[i].BiNormal = -binormal;
shape.Surfaces[i].TexGenIndex = i;
shape.TexGens[i] = new TexGen(materials[i]);
if (smoothingGroups != null)
{
shape.TexGens[i].SmoothingGroup = smoothingGroups[i];
}
if (texGenFlags != null)
{
shape.TexGenFlags[i] = texGenFlags[i];
}
}
controlMesh = ControlMeshUtility.CreateFromShape(shape, distanceEpsilon);
if (controlMesh == null)
{
return(false);
}
if (!ControlMeshUtility.Validate(controlMesh, shape))
{
//Debug.LogError("Generated mesh is not valid");
return(false);
}
if (textureMatrices != null)
{
int n = 0;
for (var i = 0; i < planes.Length; i++)
{
if (shape.Surfaces[n].TexGenIndex != i)
{
continue;
}
shape.Surfaces[n].TexGenIndex = n;
SurfaceUtility.AlignTextureSpaces(textureMatrices[i], textureMatrixSpace == TextureMatrixSpace.PlaneSpace, ref shape.TexGens[n], ref shape.TexGenFlags[n], ref shape.Surfaces[n]);
n++;
}
}
return(true);
}
