1644 lines
56 KiB
C#
1644 lines
56 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
|
|
namespace FIMSpace.Generating
|
|
{
|
|
public partial class TileMeshSetup
|
|
{
|
|
public bool _tryWeldVertices = false;
|
|
public bool _tryWeldVerticesV2 = false;
|
|
public Vector3 _randomizeVerticesOffset = Vector3.zero;
|
|
public Vector2 _randomizeVerticesNoiseScale = Vector2.one;
|
|
|
|
public bool _customMeshOverwriteVertexColor = false;
|
|
public Color _customMeshOverwriteVertexColorValues = Color.white;
|
|
|
|
public List<Vector3> _CablePoints = new List<Vector3>() { new Vector3(0f, 0f, -0.5f), new Vector3(0f, 0f, 0.5f) };
|
|
public float _CableRadius = 0.02f;
|
|
public float _CableLoose = 1.5f;
|
|
public float _CableHanging = 0f;
|
|
public TileCableGenerator.CableMeshSettings _CableMeshSettings;
|
|
public TileCableGenerator.CableTexturingSettings _CableTexturingSettings;
|
|
public TileCableGenerator.CableClonerSettings _CableClonerSettings;
|
|
public TileCableGenerator.CableRandomizationSettings _CableRandomizationSettings;
|
|
public StackedTileGenerator.StackSetup _StackerSetup;
|
|
|
|
public enum ECableView { Mesh, Texturing, Cloner, Randomization, CablePoints }
|
|
public ECableView _CableView = ECableView.Mesh;
|
|
|
|
|
|
public Mesh LatestGeneratedMesh { get; internal set; }
|
|
|
|
public Mesh FullGenerateMesh()
|
|
{
|
|
if (GenTechnique == EMeshGenerator.Advanced)
|
|
{
|
|
if (ExtraMesh == EExtraMesh.CustomMesh)
|
|
{
|
|
if (CustomMesh == null) return null;
|
|
}
|
|
|
|
LatestGeneratedMesh = GenerateCustomMesh();
|
|
return LatestGeneratedMesh;
|
|
}
|
|
|
|
CheckInstances();
|
|
PrepareCurves();
|
|
QuickUpdate();
|
|
GenerateMesh();
|
|
|
|
return LatestGeneratedMesh;
|
|
}
|
|
|
|
|
|
private Mesh GenerateMesh()
|
|
{
|
|
if (GenTechnique == EMeshGenerator.Lathe)
|
|
LatestGeneratedMesh = GenerateLathe(previewShape, new Vector2(width, height), Mathf.RoundToInt(_lathe_xSubdivCount), _lathe_fillAngle, HardNormals, UVMul, UVFit, NormalsMode);
|
|
else if (GenTechnique == EMeshGenerator.Loft)
|
|
LatestGeneratedMesh = GenerateLoft(previewShape, previewShape2, new Vector3(width, height, _loft_forceDepth ? depth : ((width + height) * _loftDepthCurveWidener)), HardNormals, UVMul, UVFit, NormalsMode, _loft_depthDim, _loft_height);
|
|
else if (GenTechnique == EMeshGenerator.Extrude)
|
|
LatestGeneratedMesh = GenerateExtrude(previewShape, new Vector3(width, height, depth), _extrudeFrontCap, _extrudeBackCap, HardNormals, UVMul, UVFit, NormalsMode, _extrudeMirror);
|
|
else if (GenTechnique == EMeshGenerator.Advanced)
|
|
LatestGeneratedMesh = GenerateCustomMesh();
|
|
else if (GenTechnique == EMeshGenerator.Primitive)
|
|
LatestGeneratedMesh = GeneratePrimitiveMesh();
|
|
else if (GenTechnique == EMeshGenerator.Sweep)
|
|
LatestGeneratedMesh = GenerateSweep(previewShape, previewShape2, new Vector3(width, height, (width + height)), HardNormals, UVMul, UVFit, NormalsMode, _sweep_radiusMul, _sweep_radius, _sweep_Close);
|
|
|
|
return LatestGeneratedMesh;
|
|
}
|
|
|
|
|
|
#region Generate with Loft
|
|
|
|
//Vector3 CollapseNormal(Vector3 norm, float collapseAmount)
|
|
//{
|
|
// norm.x = CollapseVal(norm.x, collapseAmount);
|
|
// norm.y = CollapseVal(norm.y, collapseAmount);
|
|
// norm.z = CollapseVal(norm.z, collapseAmount);
|
|
// return norm;
|
|
//}
|
|
|
|
//float CollapseVal(float val, float collapseAmount)
|
|
//{
|
|
// if (val == -0.7071068f) val = Mathf.LerpUnclamped(val, -1f, collapseAmount);
|
|
// else if (val == 0.7071068f) val = Mathf.LerpUnclamped(val, 1f, collapseAmount);
|
|
// return val;
|
|
//}
|
|
|
|
|
|
|
|
|
|
public Mesh GenerateLoft(List<MeshShapePoint> shape, List<MeshShapePoint> shapeDistrib, Vector3 dimensions, float hardNormals, Vector2 uvMul, EUVFit uvFit, ENormalsMode normalsCompute, float distribDepth, List<CurvePoint> shapeHeight)
|
|
{
|
|
if (uvMul.x == 0f) uvMul.x = 1f;
|
|
if (uvMul.y == 0f) uvMul.y = 1f;
|
|
|
|
List<MeshVertPoint> shapeZY = new List<MeshVertPoint>();
|
|
float zyLength = 0f;
|
|
#region Shape ZY
|
|
|
|
// Reference 2D shape for distributed mesh creation
|
|
float lowestY = float.MaxValue, highestY = float.MinValue;
|
|
float zWay = 0f;
|
|
for (int s = 0; s < shape.Count; s++)
|
|
{
|
|
MeshShapePoint sh = shape[s];
|
|
MeshVertPoint m = new MeshVertPoint();
|
|
|
|
m.pos = Vector3.zero;
|
|
m.pos.y = (1f - sh.p.y) * dimensions.y;
|
|
m.pos.z = (1f - sh.p.x - 1f) * dimensions.z * -0.5f;
|
|
|
|
m.vCol = sh.c;
|
|
m.norm = new Vector3(0, m.norm.y, -m.norm.x);
|
|
|
|
if (m.pos.y < lowestY) lowestY = m.pos.y;
|
|
if (m.pos.y > highestY) highestY = m.pos.y;
|
|
|
|
shapeZY.Add(m);
|
|
if (s > 0)
|
|
{
|
|
zyLength += Vector3.Distance(m.pos, shapeZY[s - 1].pos);
|
|
if (_loft_forceDepth)
|
|
zWay += Mathf.Abs(shapeZY[s - 1].pos.z - m.pos.z);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
float distrLength = 0f;
|
|
List<MeshVertPoint> distr = new List<MeshVertPoint>();
|
|
#region Distrib
|
|
|
|
float lowestX = float.MaxValue, mostX = float.MinValue;
|
|
|
|
for (int s = 0; s < shapeDistrib.Count; s++)
|
|
{
|
|
MeshShapePoint sh = shapeDistrib[s];
|
|
MeshVertPoint m = new MeshVertPoint();
|
|
|
|
m.pos = sh.p;
|
|
m.pos.x = (sh.p.x - 0.5f) * dimensions.x;
|
|
m.pos.y = 0f;
|
|
m.pos.z = (-sh.p.y + 0.5f) * distribDepth;
|
|
|
|
m.vCol = sh.c;
|
|
m.norm = new Vector3(sh.normal.x, 0f, -sh.normal.y);
|
|
|
|
if (m.pos.x < lowestX) lowestX = m.pos.x;
|
|
if (m.pos.x > mostX) mostX = m.pos.x;
|
|
|
|
distr.Add(m);
|
|
if (s > 0) distrLength += Vector3.Distance(m.pos, distr[s - 1].pos);
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
List<Vector3> verts = new List<Vector3>();
|
|
List<Vector3> normals = new List<Vector3>();
|
|
List<Vector2> uvs = new List<Vector2>();
|
|
List<int> tris = new List<int>();
|
|
List<Color> vCol = new List<Color>();
|
|
|
|
int subDivsMul = shapeZY.Count;
|
|
|
|
if (distrLength == 0f) distrLength = 1f;
|
|
if (zyLength == 0f) zyLength = 1f;
|
|
|
|
float ratio = 1f / Mathf.Abs(highestY - lowestY);
|
|
float xElapsed = 0f, yElapsed = 0f;
|
|
|
|
|
|
#region Prepare height
|
|
|
|
bool useHeight = false;
|
|
float heightSplineLength = 0f;
|
|
|
|
if (shapeHeight != null)
|
|
if (shapeHeight.Count > 1)
|
|
{
|
|
bool allZero = false;
|
|
|
|
for (int d = 0; d < shapeHeight.Count; d++)
|
|
{
|
|
if (d < shapeHeight.Count - 1)
|
|
{
|
|
heightSplineLength += Vector2.Distance(shapeHeight[d].localPos, shapeHeight[d + 1].localPos);
|
|
}
|
|
|
|
if (allZero == false) if (shapeHeight[d].localPos.y > 0.0001f) { allZero = false; }
|
|
}
|
|
|
|
if (!allZero) useHeight = true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
float collapsRev = 1f - _loft_Collapse;
|
|
|
|
// Setup vertices
|
|
for (int x = 0; x < distr.Count; x += 1)
|
|
{
|
|
var xStep = distr[x];
|
|
float distrProgr = (float)((float)x / (float)(distr.Count - 1));
|
|
|
|
for (int y = 0; y < shapeZY.Count; y += 1)
|
|
{
|
|
var yStep = shapeZY[y];
|
|
|
|
if (_loft_Collapse > 0.001f)
|
|
{
|
|
//xStep.norm = CollapseNormal(xStep.norm, _loft_Collapse);
|
|
}
|
|
|
|
Vector3 dir = new Vector3(xStep.norm.x, 0f, xStep.norm.z);
|
|
Quaternion populateDir = Quaternion.identity;
|
|
if (dir.sqrMagnitude > Mathf.Epsilon) { populateDir = Quaternion.LookRotation(dir); }
|
|
|
|
float heightMul = 1f;
|
|
bool shiftDown = false;
|
|
|
|
if (useHeight)
|
|
{
|
|
heightMul = 1f - CurvePoint.GetPosAt(shapeHeight, distrProgr, heightSplineLength).y;
|
|
var hP = CurvePoint.GetPointAt(shapeHeight, distrProgr, heightSplineLength);
|
|
shiftDown = hP._Loft_Height_ShiftWhole;
|
|
}
|
|
|
|
// Collapse feature
|
|
if (_loft_Collapse > 0.001f)
|
|
{
|
|
xStep.pos.x *= collapsRev;
|
|
xStep.pos.z *= collapsRev;
|
|
}
|
|
|
|
// Vertex pos
|
|
Vector3 vPos = xStep.pos;
|
|
|
|
if (!shiftDown)
|
|
vPos.y = yStep.pos.y * heightMul;
|
|
else
|
|
vPos.y = yStep.pos.y - highestY * (1f - heightMul);
|
|
|
|
vPos += (populateDir * new Vector3(0f, 0f, yStep.pos.z * xStep.norm.magnitude));
|
|
verts.Add(vPos);
|
|
vCol.Add(yStep.vCol);
|
|
|
|
Vector3 normal = (xStep.norm + yStep.norm).normalized;
|
|
normals.Add(normal);
|
|
|
|
|
|
#region Prepare UV
|
|
|
|
Vector2 uv = new Vector2();
|
|
|
|
// Fit X
|
|
if (uvFit == EUVFit.FitX)
|
|
{
|
|
uv.x = (1f - (xElapsed / distrLength)) * uvMul.x;
|
|
uv.y = (1f - (yElapsed / zyLength)) * heightMul * uvMul.y / ratio;
|
|
}
|
|
else if (uvFit == EUVFit.FitY)
|
|
{
|
|
uv.x = (1f - (xElapsed / distrLength)) * uvMul.x * ratio;
|
|
uv.y = (1f - (yElapsed / zyLength)) * heightMul * uvMul.y;
|
|
}
|
|
else if (uvFit == EUVFit.FitXY)
|
|
{
|
|
uv.x = (1f - (xElapsed / distrLength)) * uvMul.x;
|
|
uv.y = (1f - (yElapsed / zyLength)) * heightMul * uvMul.y;
|
|
}
|
|
|
|
uvs.Add(uv);
|
|
|
|
#endregion
|
|
|
|
|
|
#region Prepare tris
|
|
|
|
if (y < shapeZY.Count - 1 && x < distr.Count - 1)
|
|
{
|
|
int ls = x * (subDivsMul);
|
|
int uls = (x + 1) * (subDivsMul);
|
|
|
|
tris.Add(ls + y); // ld
|
|
tris.Add(ls + y + 1); // rd
|
|
tris.Add(uls + y); // lup
|
|
|
|
tris.Add(ls + y + 1); // rd
|
|
tris.Add(uls + y + 1); // rup
|
|
tris.Add(uls + y); // lup
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
if (y < shapeZY.Count - 1) yElapsed += Vector3.Distance(shapeZY[y].pos, shapeZY[y + 1].pos);
|
|
|
|
}
|
|
|
|
yElapsed = 0f;
|
|
if (x < distr.Count - 1) xElapsed += Vector3.Distance(distr[x].pos, distr[x + 1].pos);
|
|
}
|
|
|
|
Mesh mesh = new Mesh();
|
|
FMeshUtils.RotateVertices(RotateResult, verts);
|
|
mesh.SetVertices(verts);
|
|
mesh.SetColors(vCol);
|
|
mesh.SetTriangles(tris, 0);
|
|
mesh.SetUVs(0, uvs);
|
|
|
|
if (normalsCompute == ENormalsMode.NormalsAsSubdivView)
|
|
{
|
|
mesh.SetNormals(normals);
|
|
}
|
|
else
|
|
{
|
|
if (hardNormals <= 0f)
|
|
{
|
|
mesh.RecalculateNormals();
|
|
mesh.RecalculateTangents();
|
|
}
|
|
else
|
|
{
|
|
FMeshUtils.SmoothMeshNormals(mesh, hardNormals);
|
|
}
|
|
}
|
|
|
|
mesh = FMeshUtils.AdjustOrigin(mesh, Origin);
|
|
|
|
//mesh.Optimize();
|
|
mesh.RecalculateBounds();
|
|
|
|
return mesh;
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Generate with Lathe
|
|
|
|
|
|
public Mesh GenerateLathe(List<MeshShapePoint> shape, Vector2 dimensions, int subdivs, int fillTo, float hardNormals, Vector2 uvMul, EUVFit uvFit, ENormalsMode normalsCompute)
|
|
{
|
|
subdivs += 1;
|
|
int subDivsMul = subdivs + 1;
|
|
dimensions.x *= 0.5f;
|
|
|
|
if (uvMul.x == 0f) uvMul.x = 1f;
|
|
if (uvMul.y == 0f) uvMul.y = 1f;
|
|
|
|
// Reference 2D shape for rounded mesh creation
|
|
List<MeshVertPoint> latheShape = new List<MeshVertPoint>();
|
|
float lowestY = float.MaxValue, highestY = float.MinValue, farthestOff = float.MinValue;
|
|
|
|
for (int s = 0; s < shape.Count; s++)
|
|
{
|
|
MeshShapePoint sh = shape[s];
|
|
MeshVertPoint m = new MeshVertPoint();
|
|
|
|
Vector3 refPos = sh.p;
|
|
refPos.x = 1f - refPos.x;
|
|
refPos.y = -refPos.y + 1f;
|
|
|
|
Vector3 newPos = Vector2.Scale(refPos, dimensions);
|
|
m.pos = newPos;
|
|
m.vCol = sh.c;
|
|
m.norm = new Vector3(sh.normal.x, sh.normal.y, 0);
|
|
|
|
if (newPos.y < lowestY) lowestY = newPos.y;
|
|
if (newPos.y > highestY) highestY = newPos.y;
|
|
if (newPos.x > farthestOff) farthestOff = newPos.x;
|
|
|
|
latheShape.Add(m);
|
|
}
|
|
|
|
List<Vector3> verts = new List<Vector3>();
|
|
List<Vector3> normals = new List<Vector3>();
|
|
//List<Vector4> tangents = new List<Vector4>();
|
|
List<Vector2> uvs = new List<Vector2>();
|
|
List<Color> vCol = new List<Color>();
|
|
List<int> tris = new List<int>();
|
|
|
|
float stepAngle = (float)fillTo / (float)(subdivs - 1f); // 360 or less fill step
|
|
stepAngle *= Mathf.Deg2Rad; // when quat then comment this line
|
|
|
|
float ratio = 1f / Mathf.Abs(highestY - lowestY);
|
|
float xStep = 1f / (float)(subdivs);
|
|
|
|
|
|
for (int y = 0; y < latheShape.Count; y += 1)
|
|
{
|
|
var lth = latheShape[y];
|
|
|
|
for (int x = 0; x <= subdivs; x += 1)
|
|
{
|
|
float xOff = Mathf.Sin(x * stepAngle);
|
|
float zOff = Mathf.Cos(x * stepAngle);
|
|
|
|
float yPos = lth.pos.y;
|
|
|
|
|
|
Vector3 angleOff = new Vector3(xOff * lth.pos.x, 0f, zOff * lth.pos.x);
|
|
|
|
// Vertex pos
|
|
Vector3 vPos = new Vector3(0, yPos, 0) + angleOff;
|
|
verts.Add(vPos);
|
|
|
|
|
|
#region Prepare normals and tangents
|
|
|
|
Vector3 norm = ((angleOff.normalized) + new Vector3(0f, lth.norm.y, 0f)).normalized;
|
|
normals.Add(norm);
|
|
|
|
//Vector3 tanHelp = Vector3.Cross(Vector3.forward, norm);
|
|
//Vector4 tan = tanHelp; tan.w = 1f;
|
|
//tangents.Add(tan);
|
|
|
|
#endregion
|
|
|
|
|
|
#region Prepare UV
|
|
|
|
Vector2 uv = new Vector2();
|
|
|
|
// Fit X
|
|
if (uvFit == EUVFit.FitX)
|
|
{
|
|
uv.x = (1f - (x * xStep)) * uvMul.x;
|
|
uv.y = Mathf.InverseLerp(lowestY, highestY, yPos) * uvMul.y / ratio;
|
|
}
|
|
else if (uvFit == EUVFit.FitY)
|
|
{
|
|
uv.x = (1f - (x * xStep)) * uvMul.x * ratio;
|
|
uv.y = Mathf.InverseLerp(lowestY, highestY, yPos) * uvMul.y;
|
|
}
|
|
else if (uvFit == EUVFit.FitXY)
|
|
{
|
|
uv.x = (1f - (x * xStep)) * uvMul.x;
|
|
uv.y = Mathf.InverseLerp(lowestY, highestY, yPos) * uvMul.y;
|
|
}
|
|
|
|
uvs.Add(uv);
|
|
|
|
#endregion
|
|
|
|
|
|
#region Prepare tris
|
|
|
|
if (x < subdivs - 1 && y < latheShape.Count - 1)
|
|
{
|
|
int ls = y * (subDivsMul);
|
|
int uls = (y + 1) * (subDivsMul);
|
|
|
|
int xn = x + 1;
|
|
if (fillTo >= 360f) if (x == subdivs - 2) xn = 0;
|
|
|
|
tris.Add(ls + x); // ld
|
|
tris.Add(ls + xn); // rd
|
|
tris.Add(uls + x); // lup
|
|
|
|
tris.Add(ls + xn); // rd
|
|
tris.Add(uls + xn); // rup
|
|
tris.Add(uls + x); // lup
|
|
}
|
|
|
|
#endregion
|
|
|
|
vCol.Add(lth.vCol);
|
|
}
|
|
}
|
|
|
|
|
|
verts.Reverse();
|
|
tris.Reverse();
|
|
normals.Reverse();
|
|
//tangents.Reverse();
|
|
uvs.Reverse();
|
|
vCol.Reverse();
|
|
|
|
Mesh mesh = new Mesh();
|
|
FMeshUtils.RotateVertices(RotateResult, verts);
|
|
mesh.SetVertices(verts);
|
|
mesh.SetColors(vCol);
|
|
mesh.SetTriangles(tris, 0);
|
|
|
|
if (normalsCompute == ENormalsMode.NormalsAsSubdivView)
|
|
{
|
|
mesh.SetNormals(normals);
|
|
}
|
|
else
|
|
{
|
|
if (hardNormals <= 0f)
|
|
{
|
|
//mesh.SetNormals(normals);
|
|
//mesh.SetTangents(tangents);
|
|
|
|
mesh.RecalculateNormals();
|
|
mesh.RecalculateTangents();
|
|
}
|
|
else
|
|
{
|
|
FMeshUtils.SmoothMeshNormals(mesh, hardNormals);
|
|
}
|
|
}
|
|
|
|
mesh.SetUVs(0, uvs);
|
|
|
|
mesh = FMeshUtils.AdjustOrigin(mesh, Origin);
|
|
|
|
mesh.RecalculateBounds();
|
|
|
|
return mesh;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
#region Generate with Sweep
|
|
|
|
public Mesh GenerateSweep(List<MeshShapePoint> splineShape, List<MeshShapePoint> shapeCirc, Vector3 dimensions, float hardNormals, Vector2 uvMul, EUVFit uvFit, ENormalsMode normalsCompute, float radius, List<CurvePoint> sweepRadius, bool close)
|
|
{
|
|
if (uvMul.x == 0f) uvMul.x = 1f;
|
|
if (uvMul.y == 0f) uvMul.y = 1f;
|
|
|
|
if (radius < 0.01f) radius = 0.01f;
|
|
|
|
List<MeshVertPoint> splineShapeXY = new List<MeshVertPoint>();
|
|
float zyLength = 0f;
|
|
|
|
#region Shape XY
|
|
|
|
float lowestY = float.MaxValue, highestY = float.MinValue;
|
|
|
|
for (int s = 0; s < splineShape.Count; s++)
|
|
{
|
|
MeshShapePoint sh = splineShape[s];
|
|
MeshVertPoint m = new MeshVertPoint();
|
|
|
|
m.pos = Vector3.zero;
|
|
m.pos.y = (1f - sh.p.y) * dimensions.y;
|
|
m.pos.x = (sh.p.x - 0.5f) * dimensions.x;
|
|
m.pos.z = sh.p.z;
|
|
|
|
m.vCol = sh.c;
|
|
m.norm = sh.normal;
|
|
|
|
if (m.pos.y < lowestY) lowestY = m.pos.y;
|
|
if (m.pos.y > highestY) highestY = m.pos.y;
|
|
|
|
splineShapeXY.Add(m);
|
|
if (s > 0) zyLength += Vector3.Distance(m.pos, splineShapeXY[s - 1].pos);
|
|
}
|
|
|
|
#endregion
|
|
|
|
float distrLength = 0f;
|
|
List<MeshVertPoint> sweepCircShape = new List<MeshVertPoint>();
|
|
#region Distrib
|
|
|
|
float lowestX = float.MaxValue, mostX = float.MinValue;
|
|
|
|
for (int s = 0; s < shapeCirc.Count; s++)
|
|
{
|
|
MeshShapePoint sh = shapeCirc[s];
|
|
MeshVertPoint m = new MeshVertPoint();
|
|
|
|
m.pos = sh.p;
|
|
m.pos.x = (sh.p.x - 0.5f) * 2f;
|
|
m.pos.z = (-sh.p.y + 0.5f) * 2f;
|
|
m.pos.y = 0f;
|
|
|
|
m.vCol = sh.c;
|
|
|
|
//m.norm = new Vector3(sh.normal.x, 0f, -sh.normal.y);
|
|
m.norm = sh.normal;
|
|
|
|
if (m.pos.x < lowestX) lowestX = m.pos.x;
|
|
if (m.pos.x > mostX) mostX = m.pos.x;
|
|
|
|
sweepCircShape.Add(m);
|
|
if (s > 0) distrLength += Vector3.Distance(m.pos, sweepCircShape[s - 1].pos);
|
|
}
|
|
|
|
if (close) sweepCircShape.Add(sweepCircShape[0]);
|
|
|
|
#endregion
|
|
|
|
List<Vector3> verts = new List<Vector3>();
|
|
List<Vector3> normals = new List<Vector3>();
|
|
List<Vector2> uvs = new List<Vector2>();
|
|
List<int> tris = new List<int>();
|
|
List<Color> vCol = new List<Color>();
|
|
|
|
int subDivsMul = splineShapeXY.Count;
|
|
|
|
if (distrLength == 0f) distrLength = 1f;
|
|
if (zyLength == 0f) zyLength = 1f;
|
|
|
|
float ratio = 1f / Mathf.Abs(highestY - lowestY);
|
|
float xElapsed = 0f, yElapsed = 0f;
|
|
|
|
|
|
#region Prepare height
|
|
|
|
bool useRadius = false;
|
|
float heightSplineLength = 0f;
|
|
|
|
if (sweepRadius != null)
|
|
if (sweepRadius.Count > 1)
|
|
{
|
|
bool allZero = false;
|
|
|
|
for (int d = 0; d < sweepRadius.Count; d++)
|
|
{
|
|
if (d < sweepRadius.Count - 1)
|
|
{
|
|
heightSplineLength += Vector2.Distance(sweepRadius[d].localPos, sweepRadius[d + 1].localPos);
|
|
}
|
|
|
|
if (allZero == false) if (sweepRadius[d].localPos.y > 0.0001f) { allZero = false; }
|
|
}
|
|
|
|
if (!allZero) useRadius = true;
|
|
}
|
|
|
|
#endregion
|
|
|
|
// Setup vertices
|
|
for (int c = 0; c < sweepCircShape.Count; c += 1) // circle shape step
|
|
{
|
|
var circStepXZ = sweepCircShape[c];
|
|
|
|
for (int s = 0; s < splineShapeXY.Count; s += 1) // move along path length
|
|
{
|
|
|
|
#region Radius over path length calcs
|
|
|
|
float radiusMul = 1f;
|
|
if (useRadius)
|
|
{
|
|
float distrProgr = 1f - ((float)((float)s / (float)(splineShapeXY.Count - 1)));
|
|
radiusMul *= CurvePoint.GetPosAt(sweepRadius, distrProgr, heightSplineLength).x;
|
|
}
|
|
|
|
#endregion
|
|
|
|
// vert vPos Calcs
|
|
var yStep = splineShapeXY[s];
|
|
Vector3 vPos = yStep.pos; // origin position on path - ref for circle shape
|
|
|
|
#region Commented but can be helpful later
|
|
|
|
////Quaternion populateDir = Quaternion.identity;
|
|
|
|
//float yAngle = Mathf.Atan2(circStepXZ.pos.x, -circStepXZ.pos.z) * Mathf.Rad2Deg;
|
|
//float xAngle = 40f;
|
|
|
|
//Quaternion shapeRot = Quaternion.Euler(xAngle, yAngle,0f);
|
|
|
|
//if (s == splineShapeXY.Count - 1)
|
|
//{
|
|
// xAngle = Mathf.Atan2(yStep.norm.x, -yStep.norm.y) * Mathf.Rad2Deg;
|
|
//}
|
|
//else if (s == 0 )
|
|
//{
|
|
// xAngle = Mathf.Atan2(yStep.norm.y, -yStep.norm.x) * Mathf.Rad2Deg;
|
|
//}
|
|
//else
|
|
//{
|
|
// //populateDir = Quaternion.LookRotation(dir);
|
|
// //if ( y == 0 ) UnityEngine.Debug.Log(yStep.norm.x +", " + yStep.norm.y + " angle = " + (Mathf.Atan2(-yStep.norm.x, yStep.norm.y) * Mathf.Rad2Deg));
|
|
// //angl = Mathf.Atan2(-yStep.norm.x, yStep.norm.y) * Mathf.Rad2Deg;
|
|
//}
|
|
|
|
//// Vertex pos
|
|
//Vector3 vPos = yStep.pos;
|
|
|
|
////shapeRot = shapeRot * Quaternion.Euler(angl, 0f, 0);
|
|
//vPos += (shapeRot) * (Vector3.forward) * (radiusMul * radius);
|
|
|
|
////float step = (float)x / ((float)sweepCircShape.Count);
|
|
////vPos.y += step * 0.5f;
|
|
|
|
#endregion
|
|
|
|
float zAngle = Mathf.Atan2(yStep.norm.x, yStep.norm.y) * Mathf.Rad2Deg - 90;
|
|
float xAngle = 0f; // Z axis offset to implement
|
|
Quaternion pathRot = Quaternion.Euler(xAngle, 0f, zAngle);
|
|
Vector3 off = pathRot * circStepXZ.pos;
|
|
vPos += off * radius * radiusMul;
|
|
|
|
|
|
verts.Add(vPos);
|
|
vCol.Add(yStep.vCol);
|
|
|
|
Vector3 normal = (off.normalized).normalized;
|
|
normals.Add(normal);
|
|
|
|
|
|
#region Prepare UV
|
|
|
|
Vector2 uv = new Vector2();
|
|
|
|
// Fit X
|
|
if (uvFit == EUVFit.FitX)
|
|
{
|
|
uv.x = (1f - (xElapsed / distrLength)) * uvMul.x;
|
|
uv.y = (1f - (yElapsed / zyLength)) * uvMul.y / ratio;
|
|
}
|
|
else if (uvFit == EUVFit.FitY)
|
|
{
|
|
uv.x = (1f - (xElapsed / distrLength)) * uvMul.x * ratio;
|
|
uv.y = (1f - (yElapsed / zyLength)) * uvMul.y;
|
|
}
|
|
else if (uvFit == EUVFit.FitXY)
|
|
{
|
|
uv.x = (1f - (xElapsed / distrLength)) * uvMul.x;
|
|
uv.y = (1f - (yElapsed / zyLength)) * uvMul.y;
|
|
}
|
|
|
|
uvs.Add(uv);
|
|
|
|
#endregion
|
|
|
|
|
|
#region Prepare tris
|
|
|
|
if (s < splineShapeXY.Count - 1 && c < sweepCircShape.Count - 1)
|
|
{
|
|
int ls = c * (subDivsMul);
|
|
int uls = (c + 1) * (subDivsMul);
|
|
|
|
tris.Add(ls + s); // ld
|
|
tris.Add(ls + s + 1); // rd
|
|
tris.Add(uls + s); // lup
|
|
|
|
tris.Add(ls + s + 1); // rd
|
|
tris.Add(uls + s + 1); // rup
|
|
tris.Add(uls + s); // lup
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
if (s < splineShapeXY.Count - 1) yElapsed += Vector3.Distance(splineShapeXY[s].pos, splineShapeXY[s + 1].pos);
|
|
|
|
}
|
|
|
|
yElapsed = 0f;
|
|
if (c < sweepCircShape.Count - 1) xElapsed += Vector3.Distance(sweepCircShape[c].pos, sweepCircShape[c + 1].pos);
|
|
}
|
|
|
|
Mesh mesh = new Mesh();
|
|
FMeshUtils.RotateVertices(RotateResult, verts);
|
|
mesh.SetVertices(verts);
|
|
mesh.SetColors(vCol);
|
|
mesh.SetTriangles(tris, 0);
|
|
mesh.SetUVs(0, uvs);
|
|
|
|
if (normalsCompute == ENormalsMode.NormalsAsSubdivView)
|
|
{
|
|
mesh.SetNormals(normals);
|
|
}
|
|
else
|
|
{
|
|
if (hardNormals <= 0f)
|
|
{
|
|
mesh.RecalculateNormals();
|
|
mesh.RecalculateTangents();
|
|
}
|
|
else
|
|
{
|
|
FMeshUtils.SmoothMeshNormals(mesh, hardNormals);
|
|
}
|
|
}
|
|
|
|
mesh = FMeshUtils.AdjustOrigin(mesh, Origin);
|
|
|
|
//mesh.Optimize();
|
|
mesh.RecalculateBounds();
|
|
|
|
return mesh;
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
#region Generate with Extrude
|
|
|
|
|
|
|
|
public Mesh GenerateExtrude(List<MeshShapePoint> shape, Vector3 dimensions, bool extrudeFrontCap, bool extrudeBackCap, float hardNormals, Vector2 uvMul, EUVFit uvFit, ENormalsMode normalsCompute, bool extrudeMirror)
|
|
{
|
|
if (uvMul.x == 0f) uvMul.x = 1f;
|
|
if (uvMul.y == 0f) uvMul.y = 1f;
|
|
|
|
float lowestY = float.MaxValue, highestY = float.MinValue;
|
|
float mostLeft = float.MaxValue, mostRight = float.MinValue;
|
|
|
|
|
|
List<Vector3> verts = new List<Vector3>();
|
|
List<Vector2> uvs = new List<Vector2>();
|
|
List<int> tris = new List<int>();
|
|
List<Color> vCol = new List<Color>();
|
|
|
|
if (extrudeMirror)
|
|
{
|
|
|
|
List<MeshVertPoint> fullSymmShape = new List<MeshVertPoint>();
|
|
float shpLength = 0f;
|
|
|
|
#region Shape
|
|
|
|
// Reference 2D shape for distributed mesh creation
|
|
for (int s = 1; s < shape.Count - 1; s++) // Remove extra symmetry points
|
|
{
|
|
MeshShapePoint sh = shape[s];
|
|
MeshVertPoint m = new MeshVertPoint();
|
|
|
|
m.pos = sh.p;
|
|
m.pos.y = 1f - m.pos.y;
|
|
m.pos.x = (1f - m.pos.x);
|
|
m.vCol = sh.c;
|
|
|
|
m.norm = sh.normal;
|
|
|
|
fullSymmShape.Add(m);
|
|
if (s > 0) shpLength += Vector3.Distance(m.pos, fullSymmShape[s - 1].pos);
|
|
|
|
float yRev = 1f - m.pos.y;
|
|
float xRev = (m.pos.x) * -1f;
|
|
if (yRev < lowestY) lowestY = yRev;
|
|
if (yRev > highestY) highestY = yRev;
|
|
if (xRev < mostLeft) mostLeft = xRev;
|
|
}
|
|
|
|
//UnityEngine.Debug.Log(" b " + lowestY + " u " + highestY + " l " + mostLeft);
|
|
|
|
int symOff = shape.Count - 2;
|
|
|
|
// Prepare symmetry points
|
|
for (int s = 1; s < shape.Count - 1; s++)
|
|
{
|
|
MeshShapePoint sh = shape[s];
|
|
MeshVertPoint m = new MeshVertPoint();
|
|
|
|
m.pos = sh.p;
|
|
m.pos.y = 1f - m.pos.y;
|
|
m.pos.x = (1f - m.pos.x) * -1f;
|
|
m.vCol = sh.c;
|
|
m.norm = sh.normal;
|
|
|
|
fullSymmShape.Add(m);
|
|
}
|
|
|
|
|
|
//string repoty = "";
|
|
//for (int i = 0; i < fullSymmShape.Count; i++)
|
|
//{
|
|
// repoty += "[" + i + "] " + fullSymmShape[i].pos + " ";
|
|
//}
|
|
//UnityEngine.Debug.Log(repoty);
|
|
|
|
#endregion
|
|
|
|
|
|
|
|
// First cap shape
|
|
for (int v = 0; v < fullSymmShape.Count; v += 1)
|
|
{
|
|
var yStep = fullSymmShape[v];
|
|
|
|
// Vertex pos
|
|
Vector3 vPos = yStep.pos;
|
|
vPos.x *= width * 0.5f; // Symmetry mul
|
|
vPos.y *= height;
|
|
vCol.Add(yStep.vCol);
|
|
verts.Add(vPos);
|
|
}
|
|
|
|
|
|
// Flat cap in z depth
|
|
for (int v = 0; v < fullSymmShape.Count; v += 1)
|
|
{
|
|
var yStep = fullSymmShape[v];
|
|
|
|
// Vertex pos
|
|
Vector3 vPos = yStep.pos;
|
|
vPos.x *= width * 0.5f; // Symmetry mul
|
|
vPos.y *= height;
|
|
vPos.z = -dimensions.z;
|
|
vCol.Add(yStep.vCol);
|
|
verts.Add(vPos);
|
|
}
|
|
|
|
|
|
if (extrudeFrontCap)
|
|
{
|
|
// Front cap
|
|
for (int v = 0; v < symOff - 1; v += 1)
|
|
{
|
|
tris.Add(symOff + v);
|
|
tris.Add(v);
|
|
tris.Add(v + 1);
|
|
|
|
tris.Add(v + 1);
|
|
tris.Add(symOff + v + 1);
|
|
tris.Add(symOff + v);
|
|
}
|
|
}
|
|
|
|
if (extrudeBackCap)
|
|
{
|
|
int start = symOff * 2;
|
|
// Back cap
|
|
for (int v = start; v < start + symOff - 1; v += 1)
|
|
{
|
|
tris.Add(v + 1);
|
|
tris.Add(v);
|
|
tris.Add(symOff + v);
|
|
|
|
tris.Add(symOff + v);
|
|
tris.Add(symOff + v + 1);
|
|
tris.Add(v + 1);
|
|
}
|
|
}
|
|
|
|
|
|
#region Compute UVs
|
|
|
|
|
|
//if (false)
|
|
{
|
|
|
|
// From down to up points of one cap
|
|
for (int v = 0; v < fullSymmShape.Count; v += 1)
|
|
{
|
|
var p = fullSymmShape[v];
|
|
|
|
#region Prepare UV
|
|
|
|
Vector2 uv = new Vector2();
|
|
|
|
float xPos = p.pos.x;
|
|
float yPos = 1f - p.pos.y;
|
|
|
|
float yUv = FLogicMethods.InverseLerpUnclamped(lowestY, highestY, yPos);
|
|
float xUv = FLogicMethods.InverseLerpUnclamped(mostLeft, -mostLeft, xPos);
|
|
|
|
//if (v == fullSymmShape.Count - 1)
|
|
//{
|
|
// yUv = FLogicMethods.InverseLerpUnclamped(lowestY, highestY, yPos + dimensions.z);
|
|
// xUv = FLogicMethods.InverseLerpUnclamped(mostLeft, -mostLeft, xPos);
|
|
//}
|
|
|
|
uv.x = ((1f - xUv)) * uvMul.x;
|
|
uv.y = (1f - (yUv)) * uvMul.y;
|
|
|
|
uvs.Add(uv);
|
|
|
|
#endregion
|
|
}
|
|
|
|
|
|
// From down to up points with extrude depth cap
|
|
for (int v = symOff; v < fullSymmShape.Count + symOff; v += 1)
|
|
{
|
|
var p = fullSymmShape[v - symOff];
|
|
|
|
#region Prepare UV
|
|
|
|
Vector2 uv = new Vector2();
|
|
|
|
float xPos = p.pos.x;
|
|
float yPos = 1f - p.pos.y;
|
|
|
|
float yUv = FLogicMethods.InverseLerpUnclamped(lowestY, highestY, yPos);
|
|
float xUv = FLogicMethods.InverseLerpUnclamped(mostLeft, -mostLeft, xPos);
|
|
|
|
//if ( v == symOff || v == fullSymmShape.Count + symOff-1 )
|
|
//if ( v < fullSymmShape.Count + symOff - 2)
|
|
//{
|
|
// yUv = FLogicMethods.InverseLerpUnclamped(lowestY, highestY, yPos + dimensions.z);
|
|
//}
|
|
|
|
uv.x = ((xUv)) * uvMul.x;
|
|
uv.y = (1f - (yUv)) * uvMul.y;
|
|
|
|
uvs.Add(uv);
|
|
|
|
#endregion
|
|
}
|
|
|
|
//FGenerators.SwapElements(uvs, 0, uvs.Count/2);
|
|
}
|
|
|
|
|
|
// From down to up points of one cap
|
|
//for (int v = 0; v < fullSymmShape.Count; v += 1)
|
|
//{
|
|
// var p = fullSymmShape[v];
|
|
|
|
// #region Prepare UV
|
|
|
|
// Vector2 uv = new Vector2();
|
|
|
|
// float xPos = p.pos.x;
|
|
// float yPos = 1f - p.pos.y;
|
|
|
|
// float yUv = Mathf.InverseLerp(lowestY, highestY, yPos);
|
|
// float xUv = Mathf.InverseLerp(mostLeft, -mostLeft, xPos);
|
|
|
|
// uv.x = ((1f - xUv));
|
|
// uv.y = (1f - (yUv));
|
|
|
|
// uv = Vector2.Scale(UVMul, uv);
|
|
// uvs.Add(uv);
|
|
|
|
// #endregion
|
|
//}
|
|
|
|
//// From down to up points of one cap
|
|
//for (int v = 0; v < fullSymmShape.Count; v += 1)
|
|
//{
|
|
// var p = fullSymmShape[v];
|
|
|
|
// #region Prepare UV
|
|
|
|
// Vector2 uv = new Vector2();
|
|
|
|
// float xPos = p.pos.x;
|
|
// float yPos = 1f - p.pos.y;
|
|
|
|
// float yUv = Mathf.InverseLerp(lowestY, highestY, yPos);
|
|
// float xUv = Mathf.InverseLerp(mostLeft, -mostLeft, xPos);
|
|
|
|
// uv.x = ((1f - xUv));
|
|
// uv.y = (1f - (yUv));
|
|
|
|
// uv.x = 1f - uv.x;
|
|
// uv.y = 1f - uv.y;
|
|
|
|
// uv = Vector2.Scale(UVMul, uv);
|
|
// uvs.Add(uv);
|
|
|
|
// #endregion
|
|
//}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Sides Extrude
|
|
|
|
if (dimensions.z > -0.000001f && dimensions.z < 0.000001f)
|
|
{
|
|
|
|
}
|
|
else
|
|
{
|
|
|
|
// Left Side
|
|
for (int v = symOff; v < symOff + symOff - 1; v += 1)
|
|
{
|
|
tris.Add(symOff * 2 + v);
|
|
tris.Add(v);
|
|
tris.Add(v + 1);
|
|
|
|
tris.Add(v + 1);
|
|
tris.Add(symOff * 2 + v + 1);
|
|
tris.Add(symOff * 2 + v);
|
|
}
|
|
|
|
// Right Side
|
|
for (int v = 0; v < symOff - 1; v += 1)
|
|
{
|
|
tris.Add(v + 1);
|
|
tris.Add(v);
|
|
tris.Add(symOff * 2 + v);
|
|
|
|
tris.Add(symOff * 2 + v);
|
|
tris.Add(symOff * 2 + v + 1);
|
|
tris.Add(v + 1);
|
|
}
|
|
|
|
|
|
// Fill top and bottom joining
|
|
|
|
// Bottom
|
|
tris.Add(0);
|
|
tris.Add(symOff);
|
|
tris.Add(symOff * 2);
|
|
|
|
tris.Add(symOff * 3);
|
|
tris.Add(symOff * 2);
|
|
tris.Add(symOff);
|
|
|
|
// Top
|
|
tris.Add(symOff * 3 - 1);
|
|
tris.Add(symOff * 2 - 1);
|
|
tris.Add(symOff - 1);
|
|
|
|
tris.Add(symOff * 3 - 1);
|
|
tris.Add(symOff * 4 - 1);
|
|
tris.Add(symOff * 2 - 1);
|
|
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
}
|
|
else // Extrude not symmetrical
|
|
{
|
|
|
|
List<FMeshUtils.PolyShapeHelpPoint> vGenPoints = new List<FMeshUtils.PolyShapeHelpPoint>();
|
|
|
|
#region Triangulating poly shape preparation
|
|
|
|
for (int s = 0; s < shape.Count; s++)
|
|
{
|
|
var vGen = new FMeshUtils.PolyShapeHelpPoint(shape[s].p);
|
|
vGen.vxPos.z = 1f - vGen.vxPos.y;
|
|
vGen.vxPos.y = 0f;
|
|
vGen.vxPos.x *= dimensions.x;
|
|
vGen.vxPos.z *= dimensions.y;
|
|
|
|
vGen.helpIndex = s;
|
|
|
|
vGenPoints.Add(vGen);
|
|
|
|
if (vGen.vxPos.x < mostLeft) mostLeft = vGen.vxPos.x;
|
|
if (vGen.vxPos.x > mostRight) mostRight = vGen.vxPos.x;
|
|
|
|
if (vGen.vxPos.z < lowestY) lowestY = vGen.vxPos.z;
|
|
if (vGen.vxPos.z > highestY) highestY = vGen.vxPos.z;
|
|
}
|
|
|
|
#endregion
|
|
|
|
if (!_extrudeFlip) vGenPoints.Reverse();
|
|
|
|
for (int p = 0; p < vGenPoints.Count; p++)
|
|
{
|
|
var vPoint = vGenPoints[p];
|
|
vPoint.index = p;
|
|
verts.Add(new Vector3(vPoint.vxPos.x, vPoint.vxPos.z, 0f));
|
|
}
|
|
|
|
bool twoCaps = false;
|
|
if (dimensions.z != 0f || (extrudeFrontCap || extrudeBackCap))
|
|
{
|
|
twoCaps = true;
|
|
for (int p = 0; p < vGenPoints.Count; p++)
|
|
{
|
|
var vPoint = vGenPoints[p];
|
|
verts.Add(new Vector3(vPoint.vxPos.x, vPoint.vxPos.z, -dimensions.z));
|
|
}
|
|
}
|
|
|
|
|
|
List<int> frontCapTris = null;
|
|
|
|
if (extrudeFrontCap)
|
|
{
|
|
frontCapTris = FMeshUtils.TriangulateConcavePolygon(vGenPoints);
|
|
|
|
#region Applying triangulated cap
|
|
|
|
if (extrudeFrontCap)
|
|
{
|
|
for (int i = frontCapTris.Count - 1; i >= 0; i--) tris.Add(frontCapTris[i]);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
|
|
#region Applying sides poly
|
|
|
|
if (dimensions.z != 0f)
|
|
{
|
|
int depthOff = vGenPoints.Count;
|
|
|
|
if (!_extrudeFlip)
|
|
{
|
|
for (int i = 0; i < vGenPoints.Count - 1; i += 1)
|
|
{
|
|
// generating triangle bridge
|
|
// u -> uf uf -> d d -> df
|
|
tris.Add(vGenPoints[i].index);
|
|
tris.Add(vGenPoints[i].index + depthOff + 1);
|
|
tris.Add(vGenPoints[i].index + 1);
|
|
|
|
tris.Add(vGenPoints[i].index + depthOff + 1);
|
|
tris.Add(vGenPoints[i].index);
|
|
tris.Add(vGenPoints[i].index + depthOff);
|
|
}
|
|
|
|
// Loop last poly
|
|
tris.Add(vGenPoints[vGenPoints.Count - 1].index);
|
|
tris.Add(depthOff);
|
|
tris.Add(0);
|
|
|
|
tris.Add(depthOff);
|
|
tris.Add(vGenPoints[vGenPoints.Count - 1].index);
|
|
tris.Add(vGenPoints[vGenPoints.Count - 1].index + depthOff);
|
|
}
|
|
else
|
|
{
|
|
for (int i = 0; i < vGenPoints.Count - 1; i += 1)
|
|
{
|
|
tris.Add(vGenPoints[i].index + depthOff);
|
|
tris.Add(vGenPoints[i].index);
|
|
tris.Add(vGenPoints[i].index + depthOff + 1);
|
|
|
|
tris.Add(vGenPoints[i].index + 1);
|
|
tris.Add(vGenPoints[i].index + depthOff + 1);
|
|
tris.Add(vGenPoints[i].index);
|
|
}
|
|
|
|
tris.Add(vGenPoints[vGenPoints.Count - 1].index + depthOff);
|
|
tris.Add(vGenPoints[vGenPoints.Count - 1].index);
|
|
tris.Add(depthOff);
|
|
tris.Add(0);
|
|
tris.Add(depthOff);
|
|
tris.Add(vGenPoints[vGenPoints.Count - 1].index);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
if (extrudeBackCap)
|
|
{
|
|
if (frontCapTris == null) frontCapTris = FMeshUtils.TriangulateConcavePolygon(vGenPoints);
|
|
|
|
#region Applying triangulated cap
|
|
|
|
for (int i = 0; i < frontCapTris.Count; i++)
|
|
//for (int i = frontCapTris.Count - 1; i >= 0; i--)
|
|
{
|
|
tris.Add(frontCapTris[i] + vGenPoints.Count);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
|
|
#region Prepare UV for Caps
|
|
|
|
for (int v = 0; v < vGenPoints.Count; v++)
|
|
{
|
|
vCol.Add(shape[vGenPoints[v].helpIndex].c);
|
|
Vector2 uvVal = new Vector2();
|
|
uvVal.x = FLogicMethods.InverseLerpUnclamped(mostLeft, mostRight, shape[vGenPoints[v].helpIndex].p.x);
|
|
uvVal.y = FLogicMethods.InverseLerpUnclamped(lowestY, highestY, shape[vGenPoints[v].helpIndex].p.y);
|
|
uvs.Add(uvVal);
|
|
}
|
|
|
|
if (twoCaps)
|
|
{
|
|
float uvDepth = dimensions.z;
|
|
for (int v = 0; v < vGenPoints.Count; v++)
|
|
{
|
|
vCol.Add(shape[vGenPoints[v].helpIndex].c);
|
|
Vector2 uvVal = new Vector2();
|
|
uvVal.x = FLogicMethods.InverseLerpUnclamped(mostLeft, mostRight, shape[vGenPoints[v].helpIndex].p.x);
|
|
uvVal.y = FLogicMethods.InverseLerpUnclamped((lowestY + uvDepth), (highestY + uvDepth), shape[vGenPoints[v].helpIndex].p.y);
|
|
uvs.Add(uvVal);
|
|
}
|
|
}
|
|
|
|
for (int u = 0; u < uvs.Count; u++)
|
|
{
|
|
uvs[u] = Vector2.Scale(uvs[u], UVMul);
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
|
|
FMeshUtils.RotateVertices(RotateResult, verts);
|
|
|
|
Mesh mesh = new Mesh();
|
|
mesh.SetVertices(verts);
|
|
|
|
mesh.SetTriangles(tris, 0);
|
|
mesh.SetUVs(0, uvs);
|
|
mesh.SetColors(vCol);
|
|
|
|
if (hardNormals <= 0f)
|
|
{
|
|
mesh.RecalculateNormals();
|
|
mesh.RecalculateTangents();
|
|
}
|
|
else
|
|
{
|
|
FMeshUtils.SmoothMeshNormals(mesh, hardNormals);
|
|
}
|
|
|
|
mesh = FMeshUtils.AdjustOrigin(mesh, Origin);
|
|
|
|
mesh.RecalculateBounds();
|
|
|
|
return mesh;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
|
|
#region Generate Custom Mesh
|
|
|
|
Mesh GenerateCustomMesh()
|
|
{
|
|
|
|
if (ExtraMesh == EExtraMesh.CustomMesh)
|
|
{
|
|
if (CustomMesh == null) return null;
|
|
|
|
Mesh m = GameObject.Instantiate(CustomMesh);
|
|
|
|
if (_customMeshOverwriteVertexColor)
|
|
{
|
|
List<Color> cols = new List<Color>();
|
|
for (int c = 0; c < m.vertexCount; c++) cols.Add(_customMeshOverwriteVertexColorValues);
|
|
FMeshUtils.SetColorsUnity2018(m, cols);
|
|
}
|
|
|
|
if (Origin != EOrigin.Unchanged) FMeshUtils.AdjustOrigin(m, Origin);
|
|
|
|
return m;
|
|
}
|
|
else if (ExtraMesh == EExtraMesh.CableGenerator)
|
|
{
|
|
Mesh m = TileCableGenerator.GenerateFullCablesMesh(_CablePoints, _CableLoose, _CableHanging, _CableRadius, _CableMeshSettings, _CableTexturingSettings, _CableClonerSettings, _CableRandomizationSettings, null);
|
|
if (Origin != EOrigin.Unchanged) FMeshUtils.AdjustOrigin(m, Origin);
|
|
|
|
return m;
|
|
}
|
|
else if (ExtraMesh == EExtraMesh.Stacker)
|
|
{
|
|
Mesh m = StackedTileGenerator.GenerateStack(_StackerSetup);
|
|
if (Origin != EOrigin.Unchanged) FMeshUtils.AdjustOrigin(m, Origin);
|
|
return m;
|
|
}
|
|
|
|
|
|
return null;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Generate Primitive Mesh
|
|
|
|
Mesh GeneratePrimitiveMesh()
|
|
{
|
|
List<Vector3> verts = new List<Vector3>();
|
|
List<Vector3> normals = new List<Vector3>();
|
|
List<Vector2> uvs = new List<Vector2>();
|
|
List<int> tris = new List<int>();
|
|
|
|
if (_primitive_Type == EPrimitiveType.Cube)
|
|
{
|
|
_Primitive_Cube_ClampParams();
|
|
|
|
CubeGenerator cube = new CubeGenerator();
|
|
|
|
#region Adjust Generator
|
|
|
|
cube.Scale = _primitive_scale;
|
|
cube.Subdivisions = _primitive_plane_subdivs;
|
|
cube.BevelSize = _primitive_cube_bevel;
|
|
cube.BevelSubdivs = _primitive_cube_bevelSubdivs;
|
|
|
|
cube.FaceTop = _primitive_cube_topFace;
|
|
cube.FaceBottom = _primitive_cube_bottomFace;
|
|
cube.FaceLeft = _primitive_cube_leftFace;
|
|
cube.FaceRight = _primitive_cube_rightFace;
|
|
cube.FaceFront = _primitive_cube_frontFace;
|
|
cube.FaceBack = _primitive_cube_backFace;
|
|
cube.RotateResult = RotateResult;
|
|
|
|
#endregion
|
|
|
|
Mesh cubeMesh = cube.GenerateMesh();
|
|
cubeMesh.GetVertices(verts);
|
|
cubeMesh.GetNormals(normals);
|
|
cubeMesh.GetUVs(0, uvs);
|
|
cubeMesh.GetTriangles(tris, 0);
|
|
}
|
|
else if (_primitive_Type == EPrimitiveType.Plane)
|
|
{
|
|
_Primitive_Plane_ClampParams();
|
|
|
|
Mesh plane = _GeneratePlane(_primitive_plane_subdivs.x, _primitive_plane_subdivs.y, Vector2.one);
|
|
plane.GetVertices(verts);
|
|
plane.GetNormals(normals);
|
|
plane.GetUVs(0, uvs);
|
|
plane.GetTriangles(tris, 0);
|
|
}
|
|
else if (_primitive_Type == EPrimitiveType.Sphere)
|
|
{
|
|
GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Sphere);
|
|
Mesh sphere = GameObject.Instantiate(obj.GetComponent<MeshFilter>().sharedMesh);
|
|
sphere.GetVertices(verts);
|
|
sphere.GetNormals(normals);
|
|
sphere.GetUVs(0, uvs);
|
|
sphere.GetTriangles(tris, 0);
|
|
FGenerators.DestroyObject(obj);
|
|
}
|
|
else if (_primitive_Type == EPrimitiveType.Cylinder)
|
|
{
|
|
GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Cylinder);
|
|
Mesh cylinder = GameObject.Instantiate(obj.GetComponent<MeshFilter>().sharedMesh);
|
|
cylinder.GetVertices(verts);
|
|
cylinder.GetNormals(normals);
|
|
cylinder.GetUVs(0, uvs);
|
|
cylinder.GetTriangles(tris, 0);
|
|
FGenerators.DestroyObject(obj);
|
|
}
|
|
|
|
Mesh mesh = new Mesh();
|
|
|
|
if (_primitive_Type != EPrimitiveType.Cube)
|
|
if (_primitive_scale != Vector3.one)
|
|
for (int v = 0; v < verts.Count; v++)
|
|
{
|
|
verts[v] = Vector3.Scale(verts[v], _primitive_scale);
|
|
}
|
|
|
|
FMeshUtils.RotateVertices(RotateResult, verts);
|
|
mesh.SetVertices(verts);
|
|
mesh.SetTriangles(tris, 0);
|
|
mesh.SetUVs(0, uvs);
|
|
|
|
if (NormalsMode == ENormalsMode.NormalsAsSubdivView)
|
|
{
|
|
mesh.SetNormals(normals);
|
|
}
|
|
else
|
|
{
|
|
if (HardNormals <= 0f)
|
|
{
|
|
mesh.RecalculateNormals();
|
|
mesh.RecalculateTangents();
|
|
}
|
|
else
|
|
{
|
|
FMeshUtils.SmoothMeshNormals(mesh, HardNormals);
|
|
}
|
|
}
|
|
|
|
|
|
if (_customMeshOverwriteVertexColor)
|
|
{
|
|
List<Color> cols = new List<Color>();
|
|
for (int c = 0; c < mesh.vertexCount; c++) cols.Add(_customMeshOverwriteVertexColorValues);
|
|
FMeshUtils.SetColorsUnity2018(mesh, cols);
|
|
}
|
|
|
|
|
|
if (_tryWeldVertices) // Adjustable subdivs cube
|
|
{
|
|
if (_tryWeldVerticesV2)
|
|
mesh = FMeshUtils.Weld2(mesh, mesh.bounds.max.magnitude * 0.01f);
|
|
else
|
|
mesh = FMeshUtils.Weld(mesh, mesh.bounds.max.magnitude * 0.01f);
|
|
|
|
mesh.Optimize();
|
|
}
|
|
|
|
mesh.GetVertices(verts);
|
|
|
|
if (_randomizeVerticesOffset != Vector3.zero)
|
|
{
|
|
Vector2 rand = new Vector2(FGenerators.GetRandom(0f, 1000f), FGenerators.GetRandom(0f, 1000f));
|
|
Vector2 rand2 = new Vector2(FGenerators.GetRandom(0f, 1000f), FGenerators.GetRandom(0f, 1000f));
|
|
Vector2 rand3 = new Vector2(FGenerators.GetRandom(0f, 1000f), FGenerators.GetRandom(0f, 1000f));
|
|
|
|
for (int v = 0; v < verts.Count; v++)
|
|
verts[v] += new Vector3
|
|
(
|
|
Mathf.PerlinNoise((rand.x + v) * _randomizeVerticesNoiseScale.x,
|
|
(rand.y + v) * _randomizeVerticesNoiseScale.y) * _randomizeVerticesOffset.x,
|
|
|
|
Mathf.PerlinNoise((rand2.x + v) * _randomizeVerticesNoiseScale.y,
|
|
(rand2.y + v) * _randomizeVerticesNoiseScale.y) * _randomizeVerticesOffset.y,
|
|
|
|
Mathf.PerlinNoise((rand3.x + v) * _randomizeVerticesNoiseScale.x,
|
|
(rand3.y + v) * _randomizeVerticesNoiseScale.y) * _randomizeVerticesOffset.z
|
|
);
|
|
}
|
|
|
|
FMeshUtils.RotateVertices(RotateResult, verts);
|
|
mesh.SetVertices(verts);
|
|
|
|
if (NormalsMode != ENormalsMode.NormalsAsSubdivView)
|
|
{
|
|
if (HardNormals <= 0f)
|
|
{
|
|
mesh.RecalculateNormals();
|
|
mesh.RecalculateTangents();
|
|
}
|
|
else
|
|
{
|
|
FMeshUtils.SmoothMeshNormals(mesh, HardNormals);
|
|
}
|
|
}
|
|
|
|
mesh = FMeshUtils.AdjustOrigin(mesh, Origin);
|
|
mesh.RecalculateBounds();
|
|
//mesh.Optimize();
|
|
|
|
return mesh;
|
|
}
|
|
|
|
|
|
internal static Mesh _GeneratePlane(int xSub, int ySub, Vector2 size)
|
|
{
|
|
if (xSub <= 0) xSub = 1;
|
|
if (ySub <= 0) ySub = 1;
|
|
|
|
List<Vector3> vertices = new List<Vector3>();
|
|
List<Vector3> normals = new List<Vector3>();
|
|
List<Vector2> uvs = new List<Vector2>();
|
|
|
|
ySub += 1;
|
|
xSub += 1;
|
|
|
|
for (int y = 0; y < ySub; y++)
|
|
for (int x = 0; x < xSub; x++)
|
|
{
|
|
float tx = (float)x / (float)(xSub - 1);
|
|
float ty = (float)y / (float)(ySub - 1);
|
|
|
|
float pX = (-0.5f + tx) * size.x;
|
|
float pZ = (-0.5f + ty) * size.y;
|
|
|
|
vertices.Add(new Vector3(pX, 0, pZ));
|
|
normals.Add(Vector3.up);
|
|
uvs.Add(new Vector2(tx, ty));
|
|
}
|
|
|
|
List<int> tris = new List<int>();
|
|
|
|
for (int y = 0; y < (ySub - 1); y++)
|
|
for (int x = 0; x < (xSub - 1); x++)
|
|
{
|
|
int quad = y * xSub + x;
|
|
|
|
tris.Add(quad);
|
|
tris.Add(quad + xSub);
|
|
tris.Add(quad + xSub + 1);
|
|
|
|
tris.Add(quad);
|
|
tris.Add(quad + xSub + 1);
|
|
tris.Add(quad + 1);
|
|
}
|
|
|
|
|
|
var mesh = new Mesh();
|
|
mesh.vertices = vertices.ToArray();
|
|
mesh.triangles = tris.ToArray();
|
|
mesh.uv = uvs.ToArray();
|
|
mesh.normals = normals.ToArray();
|
|
mesh.RecalculateBounds();
|
|
|
|
return mesh;
|
|
}
|
|
|
|
|
|
internal void _Primitive_Plane_ClampParams()
|
|
{
|
|
if (_primitive_plane_subdivs.x < 0) _primitive_plane_subdivs.x = 1;
|
|
if (_primitive_plane_subdivs.x > 250) _primitive_plane_subdivs.x = 250;
|
|
if (_primitive_plane_subdivs.y < 0) _primitive_plane_subdivs.y = 1;
|
|
if (_primitive_plane_subdivs.y > 250) _primitive_plane_subdivs.y = 250;
|
|
|
|
if (_primitive_cube_backFace == false && _primitive_cube_frontFace == false && _primitive_cube_leftFace == false && _primitive_cube_rightFace == false && _primitive_cube_topFace == false && _primitive_cube_bottomFace == false)
|
|
{
|
|
_primitive_scale = Vector3.one;
|
|
_primitive_cube_topFace = true;
|
|
_primitive_cube_bottomFace = true;
|
|
_primitive_cube_leftFace = true;
|
|
_primitive_cube_rightFace = true;
|
|
_primitive_cube_frontFace = true;
|
|
_primitive_cube_backFace = true;
|
|
_primitive_cube_bevel = 0f;
|
|
_primitive_cube_bevelSubdivs = 1;
|
|
_primitive_plane_subdivs = new Vector3Int(1, 1, 1);
|
|
}
|
|
}
|
|
|
|
internal void _Primitive_Cube_ClampParams()
|
|
{
|
|
_Primitive_Plane_ClampParams();
|
|
if (_primitive_plane_subdivs.z < 0) _primitive_plane_subdivs.z = 1;
|
|
if (_primitive_plane_subdivs.z > 250) _primitive_plane_subdivs.z = 250;
|
|
if (_primitive_cube_bevel < 0) _primitive_cube_bevel = 0f;
|
|
if (_primitive_cube_bevelSubdivs < 1) _primitive_cube_bevelSubdivs = 1;
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region Helpers
|
|
|
|
struct MeshVertPoint
|
|
{
|
|
public Vector3 pos;
|
|
public Color vCol;
|
|
public Vector3 norm;
|
|
public Vector2 UV;
|
|
|
|
public MeshVertPoint(Vector3 pos)
|
|
{
|
|
this.pos = pos;
|
|
vCol = Color.white;
|
|
norm = Vector3.zero;
|
|
UV = Vector3.zero;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
}
|
|
} |