internal RobotCellUR(string name, RobotArm robot, IO io, Plane basePlane, Mesh environment) : base(name, Manufacturers.UR, io, basePlane, environment)
{
this.Robot = robot as RobotUR;
this.DisplayMesh = new Mesh();
DisplayMesh.Append(robot.DisplayMesh);
this.DisplayMesh.Transform(this.BasePlane.ToTransform());
}
void Start ()
{
//create vertices and uv array size
_vertices = new Vector3[24];
_uv = new Vector2[24];
//populate hex arrays
DrawTopAndBottom();
DrawSides();
SetTriangles();
//setup mesh
Mesh mesh = new Mesh { name = "Hex Mesh" };
mesh.vertices = _vertices;
mesh.uv = _uv;
mesh.triangles = _triangles;
mesh.normals = _normals;
GetComponent<MeshFilter>().mesh = mesh;
//setup collider
MeshCollider col = GetComponent<MeshCollider>();
col.sharedMesh = mesh;
//setup renderer
Renderer renderer = GetComponent<Renderer>();
renderer.material.shader = Shader.Find("Diffuse");
renderer.material.mainTexture = texture;
_originalColor = renderer.material.color;
_hoverColor = Color.green;
}
public void DrawAttkBox(SPoint[] v, string mat, int n, int endN, SPoint p, int pNum, int t, int poly)
{
//specialized manual function for attackboxes
subMesh [poly] = new Mesh ();
int vTot = endN - n + 1;
Vector3[] vertices = new Vector3[vTot];
Color32[] col = new Color32[vTot];
//std::stringstream hbName;
string hbName = "P#" + pNum + "HB-" + t + "-" + poly;
for (int i = n; i <= endN; i++) {
vertices [i-n] = new Vector3 (v [i].x + p.x, v [i].y + p.y, 0);
col [i-n] = new Color32 (0, 250, 20, 150);
}
int tTot = (vTot - 2) * 3;
int[] tri = new int[tTot];
for (int i = 0; i<(tTot/3);i++) {//triangle fan
tri[i*3]=0;
tri[(i*3)+1]=i+1;
tri[(i*3)+2]=i+2;
}
subMesh[poly].vertices=vertices;
subMesh[poly].triangles = tri;
subMesh[poly].colors32 = col;
}
public override void Prepare(Mesh mesh)
{
base.Prepare(mesh);
if (mesh.CustomData == null)
return;
this.nextFrameTextureMatrix.Set((Matrix) mesh.CustomData);
}
public void Initialize (Mesh mesh, Material[] materials, Color32 color, bool additive, float speed, int sortingLayerID, int sortingOrder) {
StopAllCoroutines();
gameObject.SetActive(true);
meshRenderer.sharedMaterials = materials;
meshRenderer.sortingLayerID = sortingLayerID;
meshRenderer.sortingOrder = sortingOrder;
meshFilter.sharedMesh = (Mesh)Instantiate(mesh);
colors = meshFilter.sharedMesh.colors32;
if ((color.a + color.r + color.g + color.b) > 0) {
for (int i = 0; i < colors.Length; i++) {
colors[i] = color;
}
}
fadeSpeed = speed;
if (additive)
StartCoroutine(FadeAdditive());
else
StartCoroutine(Fade());
}
private void Start()
{
mesh = new Mesh();
GetComponent<MeshFilter>().mesh = mesh;
CreateMesh();
}
public void getCenter(Mesh m)
{
double minX=9999, minY=9999, maxX=-9999, maxY=-9999;
foreach (Zone z in m.Zones)
{
foreach (Face f in z.Faces)
{
foreach (uint _edge in f.Edges)
{
Edge __edge = z.Edges[_edge];
if (z.Vertices[__edge.Start].Position.x < minX)
{
minX = z.Vertices[__edge.Start].Position.x;
}
if (z.Vertices[__edge.Start].Position.x > maxX)
{
maxX = z.Vertices[__edge.Start].Position.x;
}
if (z.Vertices[__edge.Start].Position.y < minY)
{
minY = z.Vertices[__edge.Start].Position.y;
}
if (z.Vertices[__edge.Start].Position.y > maxY)
{
maxY = z.Vertices[__edge.Start].Position.y;
}
}
}
}
centerX = (maxX + minX) / 2;
centerY = (maxY + minY) / 2;
}
public virtual void Reset()
{
if (meshFilter != null) meshFilter.sharedMesh = null;
if (mesh != null) DestroyImmediate(mesh);
if (renderer != null) renderer.sharedMaterial = null;
mesh = null;
mesh1 = null;
mesh2 = null;
lastVertexCount = 0;
vertices = null;
colors = null;
uvs = null;
sharedMaterials = new Material[0];
submeshMaterials.Clear();
submeshes.Clear();
valid = false;
if(skeleton==null)
{
return;
}
valid = true;
meshFilter = GetComponent<MeshFilter>();
mesh1 = newMesh();
mesh2 = newMesh();
vertices = new Vector3[0];
if (initialSkinName != null && initialSkinName.Length > 0 && initialSkinName != "default")
skeleton.SetSkin(initialSkinName);
}
public void ManualUpdate(Mesh mesh, Material outerMaterial, float outerScale)
{
if (Corona != null)
{
if (MeshFilter == null) MeshFilter = gameObject.AddComponent<MeshFilter>();
if (MeshRenderer == null) MeshRenderer = gameObject.AddComponent<MeshRenderer>();
if (MeshFilter.sharedMesh != mesh)
{
SgtHelper.BeginStealthSet(MeshFilter);
{
MeshFilter.sharedMesh = mesh;
}
SgtHelper.EndStealthSet();
}
if (MeshRenderer.sharedMaterial != outerMaterial)
{
SgtHelper.BeginStealthSet(MeshRenderer);
{
MeshRenderer.sharedMaterial = outerMaterial;
}
SgtHelper.EndStealthSet();
}
SgtHelper.SetLocalScale(transform, outerScale);
}
}
public void BakePatternDesign()
{
List<InstanceData> positions = GeneratePositions();
lastCount = positions.Count;
var lastBuiltMesh = BakeMesh(positions.ToArray());
#if UNITY_EDITOR
string assetPath;
if (generatedBakedMesh != null)
{
assetPath = UnityEditor.AssetDatabase.GetAssetPath(generatedBakedMesh);
}
else
{
assetPath = UnityEditor.AssetDatabase.GenerateUniqueAssetPath("Assets/AsteroidBelt.asset");
}
UnityEditor.AssetDatabase.CreateAsset(lastBuiltMesh, assetPath);
UnityEditor.AssetDatabase.Refresh(UnityEditor.ImportAssetOptions.Default);
UnityEditor.AssetDatabase.SaveAssets();
generatedBakedMesh = UnityEditor.AssetDatabase.LoadAssetAtPath<Mesh>(assetPath);
#endif
}
public override void Prepare(Mesh mesh)
{
base.Prepare(mesh);
this.material.Diffuse = mesh.Material.Diffuse;
this.material.Opacity = mesh.Material.Opacity;
this.texture.Set((Texture) mesh.Texture);
}
public void Setup(Mesh m)
{
for (int index = 0; index < m.SubMeshes.Count; index++)
{
addSubMeshFunc(m.SubMeshes[index]);
}
}
public void OnTriggerEnter(Collider c)
{
if (c.tag == "Player")
{
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
float playAreaDistance;
playArea.Raycast(ray, out playAreaDistance);
enterPoint = ray.GetPoint(playAreaDistance);
SkinnedMeshRenderer skinnedMeshRenderer = GetComponent<SkinnedMeshRenderer>();
if (skinnedMeshRenderer != null)
{
Mesh mesh = new Mesh();
skinnedMeshRenderer.BakeMesh(mesh);
Destroy(skinnedMeshRenderer);
Destroy(GetComponent<Animator>());
MeshRenderer renderer = gameObject.AddComponent<MeshRenderer>();
MeshFilter meshFilter = gameObject.AddComponent<MeshFilter>();
meshFilter.sharedMesh = mesh;
renderer.material = bloodMaterial;
transform.localScale = new Vector3(1, 1, 1);
}
}
}
/// <summary>
/// Gets the permutation vector for the Reverse Cuthill-McKee numbering.
/// </summary>
/// <param name="mesh">The mesh.</param>
/// <returns>Permutation vector.</returns>
public int[] Renumber(Mesh mesh)
{
// Algorithm needs linear numbering of the nodes.
mesh.Renumber(NodeNumbering.Linear);
return Renumber(new AdjacencyMatrix(mesh));
}
private Mesh Generate()
{
Debug.Assert(starCount < 65536, "Number of stars must less than 65536");
var random = new System.Random(seed);
var mesh = new Mesh();
var vertices = new Vector3[starCount];
var indices = new int[starCount];
var colors = new Color[starCount];
for (var i = 0; i < starCount; ++i)
{
vertices[i] = random.OnUnitSphere();
indices[i] = i;
colors[i] = starColors[random.Next(starColors.Length)];
colors[i].a = (0.2f + 0.8f * MathUtils.NextFloat(random)) * (1 - (Mathf.Abs(vertices[i].y)));
}
mesh.vertices = vertices;
mesh.colors = colors;
mesh.SetIndices(indices, MeshTopology.Points, 0);
return mesh;
}
public override void Prepare(Mesh mesh)
{
base.Prepare(mesh);
this.randomSeed.Set(new Vector3(RandomHelper.Unit(), RandomHelper.Unit(), RandomHelper.Unit()));
this.material.Diffuse = mesh.Material.Diffuse;
this.material.Opacity = mesh.Material.Opacity;
}
// Generate the mesh surface according to the correct dimensions
private void Generate()
{
GetComponent<MeshFilter>().mesh = waveMesh = new Mesh ();
waveMesh.name = "Ocean Surface";
vertices = new Vector3[(xSize + 1) * (zSize + 1)];
for (int i = 0, y = 0; i <= xSize; i++)
{
for (int j = 0; j <= zSize; j++, y++)
{
vertices [y] = new Vector3 (j, 0, i);
}
}
waveMesh.vertices = vertices;
int[] triangles = new int[xSize * zSize * 6];
for(int ti = 0, ve = 0, z = 0; z < zSize; z++, ve++){
for(int x = 0; x < xSize; x++, ti+=6, ve++){
triangles [ti] = ve;
triangles [ti+1] = triangles[ti+4] = ve+ xSize+1;
triangles [ti+2] = triangles[ti+3] = ve+ 1;
triangles [ti+5] = ve + xSize + 2;
waveMesh.triangles = triangles;
waveMesh.RecalculateNormals ();
}
}
} // end Generate
/// <summary>
/// Generate the Voronoi diagram from given triangle mesh..
/// </summary>
/// <param name="mesh"></param>
/// <param name="bounded"></param>
protected void Generate(Mesh mesh)
{
mesh.Renumber();
base.edges = new List<HalfEdge>();
this.rays = new List<HalfEdge>();
// Allocate space for Voronoi diagram.
var vertices = new Vertex[mesh.triangles.Count + mesh.hullsize];
var faces = new Face[mesh.vertices.Count];
if (factory == null)
{
factory = new DefaultVoronoiFactory();
}
factory.Initialize(vertices.Length, 2 * mesh.NumberOfEdges, faces.Length);
// Compute triangles circumcenters.
var map = ComputeVertices(mesh, vertices);
// Create all Voronoi faces.
foreach (var vertex in mesh.vertices.Values)
{
faces[vertex.id] = factory.CreateFace(vertex);
}
ComputeEdges(mesh, vertices, faces, map);
// At this point all edges are computed, but the (edge.next) pointers aren't set.
ConnectEdges(map);
base.vertices = new List<Vertex>(vertices);
base.faces = new List<Face>(faces);
}
public void DrawMesh(Mesh mesh, Matrix4x4 matrix, Material material)
{
MaterialPropertyBlock properties = null;
int shaderPass = -1;
int submeshIndex = 0;
CommandBuffer.INTERNAL_CALL_DrawMesh(this, mesh, ref matrix, material, submeshIndex, shaderPass, properties);
}
void Awake()
{
gradientLayer = Mathf.Clamp(gradientLayer, 0, 31);
if (!camera)
{
Debug.LogError("Must attach GradientBackground script to the camera");
return;
}
camera.clearFlags = CameraClearFlags.Depth;
camera.cullingMask = camera.cullingMask & ~(1 << gradientLayer);
Camera gradientCam = new GameObject("Gradient Cam", typeof(Camera)).camera;
gradientCam.depth = camera.depth - 1;
gradientCam.cullingMask = 1 << gradientLayer;
Mesh mesh = new Mesh();
mesh.vertices = new Vector3[4] { new Vector3(-100f, .577f, 1f), new Vector3(100f, .577f, 1f), new Vector3(-100f, -.577f, 1f), new Vector3(100f, -.577f, 1f) };
mesh.colors = new Color[4] { topColor, topColor, bottomColor, bottomColor };
mesh.triangles = new int[6] { 0, 1, 2, 1, 3, 2 };
Material mat = new Material("Shader \"Vertex Color Only\"{Subshader{BindChannels{Bind \"vertex\", vertex Bind \"color\", color}Pass{}}}");
GameObject gradientPlane = new GameObject("Gradient Plane", typeof(MeshFilter), typeof(MeshRenderer));
((MeshFilter)gradientPlane.GetComponent(typeof(MeshFilter))).mesh = mesh;
gradientPlane.renderer.material = mat;
gradientPlane.layer = gradientLayer;
}
private static void GenerateMesh(Mesh mesh)
{
int num = 1;
Vector3[] array = new Vector3[4 * num];
Vector2[] array2 = new Vector2[4 * num];
int[] array3 = new int[6 * num];
for (int i = 0; i < num; i++)
{
Vector3 zero = Vector3.zero;
int num2 = 4 * i;
array[num2] = zero;
array[num2 + 1] = zero;
array[num2 + 2] = zero;
array[num2 + 3] = zero;
array2[num2] = new Vector2(0f, 0f);
array2[num2 + 1] = new Vector2(0f, 1f);
array2[num2 + 2] = new Vector2(1f, 0f);
array2[num2 + 3] = new Vector2(1f, 1f);
int num3 = 6 * i;
array3[num3] = 0 + num2;
array3[num3 + 1] = 1 + num2;
array3[num3 + 2] = 2 + num2;
array3[num3 + 3] = 2 + num2;
array3[num3 + 4] = 1 + num2;
array3[num3 + 5] = 3 + num2;
}
mesh.vertices = array;
mesh.uv = array2;
mesh.triangles = array3;
mesh.RecalculateNormals();
mesh.bounds = new Bounds(Vector3.zero, Vector3.one);
mesh.Optimize();
}
public void Rebuild()
{
MeshFilter mf = GetComponent<MeshFilter>();
if ( mf != null )
{
Mesh mesh = mf.sharedMesh; //Utils.GetMesh(gameObject);
if ( mesh == null )
{
mesh = new Mesh();
mf.sharedMesh = mesh;
}
if ( mesh != null )
{
BuildMesh(mesh);
MegaModifyObject mo = GetComponent<MegaModifyObject>();
if ( mo != null )
{
mo.MeshUpdated();
}
}
}
}
void OnGUI()
{
if(obj) {
if(mesh) {
p.x = EditorGUILayout.Slider("X", p.x, -1.0f, 1.0f);
p.y = EditorGUILayout.Slider("Y", p.y, -1.0f, 1.0f);
p.z = EditorGUILayout.Slider("Z", p.z, -1.0f, 1.0f);
if(p != last_p) { //Detects user input on any of the three sliders
//Only create instance of mesh when user changes pivot
if(pivotUnchanged) mesh = meshFilter.mesh; pivotUnchanged = false;
UpdatePivot();
last_p = p;
}
if(GUILayout.Button("Center")) { //Set pivot to the center of the mesh bounds
//Only create instance of mesh when user changes pivot
if(pivotUnchanged) mesh = meshFilter.mesh; pivotUnchanged = false;
p = Vector3.zero;
UpdatePivot();
last_p = p;
}
GUILayout.Label("Bounds " + mesh.bounds.ToString());
} else {
GUILayout.Label("Selected object does not have a Mesh specified.");
}
} else {
GUILayout.Label("No object selected in Hierarchy.");
}
}
void Start()
{
// Create Vector2 vertices
Vector3[] vertices3D = new Vector3[] {
new Vector3(5, 10, 0),
new Vector3(10, -5, 0),
new Vector3(-7, -3, 0),
new Vector3(-2, -8, 0),
new Vector3(9, -10, 0),
};
// Use the triangulator to get indices for creating triangles
MidpointTriangulator tr = new MidpointTriangulator(vertices3D);
Vector3[] vertices = tr.Triangulate().ToArray();
int[] indices = new int[vertices.Length];
// Create the Vector3 vertices
for (int i = 0; i < vertices.Length; i++)
{
indices[i] = i;
}
// Create the mesh
Mesh msh = new Mesh();
msh.vertices = vertices;
msh.triangles = indices;
msh.RecalculateNormals();
msh.RecalculateBounds();
// Set up game object with mesh;
MeshFilter filter = gameObject.AddComponent(typeof(MeshFilter)) as MeshFilter;
filter.mesh = msh;
}
static void CreateQuad(Mesh mesh, float W, float H)
{
Vector3[] verts = new Vector3[4];
Vector2[] uvs = new Vector2[4];
verts[0] = new Vector3(-W/2, H/2, 0);
verts[1] = new Vector3(W/2, H/2, 0);
verts[2] = new Vector3(W/2, -H/2, 0);
verts[3] = new Vector3(-W/2, -H/2, 0);
uvs[0] = new Vector2(0, 1);
uvs[1] = new Vector2(1, 1);
uvs[2] = new Vector3(1, 0);
uvs[3] = new Vector3(0, 0);
int[] triangles = new int[6];
triangles[0] = 0;
triangles[1] = 1;
triangles[2] = 3;
triangles[3] = 3;
triangles[4] = 1;
triangles[5] = 2;
mesh.Clear();
mesh.vertices = verts;
mesh.uv = uvs;
mesh.triangles = triangles;
}
public virtual void encode(Mesh m, CtmOutputStream output)
{
int vc = m.getVertexCount();
output.writeLittleInt(MeshDecoder.INDX);
writeIndicies(m.indices, output);
output.writeLittleInt(MeshDecoder.VERT);
writeFloatArray(m.vertices, output, vc * 3, 1);
// Write normals
if (m.normals != null) {
output.writeLittleInt(MeshDecoder.NORM);
writeFloatArray(m.normals, output, vc, 3);
}
foreach (AttributeData ad in m.texcoordinates) {
output.writeLittleInt(MeshDecoder.TEXC);
output.writeString(ad.name);
output.writeString(ad.materialName);
writeFloatArray(ad.values, output, vc, 2);
}
foreach (AttributeData ad in m.attributs) {
output.writeLittleInt(MeshDecoder.ATTR);
output.writeString(ad.name);
writeFloatArray(ad.values, output, vc, 4);
}
}
public void createCylinder(float radius, float height, int slices, GameObject go, Matrix4x4 matrix)
{
Mesh cylinderMesh = new Mesh();
vertices = new Vector3[(slices+1) * 4];
Vector3[] cylPoints1 = createCylinderPoints(radius, height, slices, true);
Vector3[] cylPoints2 = createCylinderPoints(radius, height, slices, false);
for (int i = 0; i <cylPoints1.Length; i++) {
vertices[i] = cylPoints1[i];
}
for (int k = 0; k < cylPoints2.Length; k++) {
vertices[k + cylPoints1.Length] = cylPoints2[k];
}
createCylinderNormals(vertices, radius);
for (int j = 0; j < vertices.Length; j++) {
vertices[j] = matrix.MultiplyPoint(vertices[j]);
normals[j] = matrix.MultiplyPoint(normals[j]);
}
trianglesIndex = 0;
createCylinderTriangles(slices+1);
cylinderMesh.vertices = vertices;
cylinderMesh.triangles = triangles;
cylinderMesh.normals = normals;
cylinderMesh.uv = uvs;
MeshFilter filter = (MeshFilter)go.GetComponent("MeshFilter");
filter.mesh = cylinderMesh;
}
public void MakeCircle(int numOfPoints)
{
//Debug.Log(numOfPoints + " --- " + AudioToWave.currentValue);
float angleStep = 360.0f / (float)numOfPoints;
List<Vector3> vertexList = new List<Vector3>();
List<int> triangleList = new List<int>();
Quaternion quaternion = Quaternion.Euler(0.0f, 0.0f, angleStep);
// Make first triangle.
vertexList.Add(new Vector3(0.0f, 0.0f, 10f)); // 1. Circle center.
vertexList.Add(new Vector3(0.0f, 0.5f, 10f)); // 2. First vertex on circle outline (radius = 0.5f)
vertexList.Add(quaternion * vertexList[1]); // 3. First vertex on circle outline rotated by angle)
// Add triangle indices.
triangleList.Add(0);
triangleList.Add(1);
triangleList.Add(2);
for (int i = 0; i < numOfPoints - 1; i++)
{
triangleList.Add(0); // Index of circle center.
triangleList.Add(vertexList.Count - 1);
triangleList.Add(vertexList.Count);
vertexList.Add(quaternion * vertexList[vertexList.Count - 1]);
}
Mesh mesh = new Mesh();
mesh.vertices = vertexList.ToArray();
mesh.triangles = triangleList.ToArray();
mf.mesh = mesh;
}
// Use this for initialization
void Start()
{
theTarget = building1;
initialMesh = building1.GetComponent<MeshFilter>().mesh;
swapMesh = building1alt.GetComponent<MeshFilter>().mesh;
}
void Awake()
{
if (mesh == null)
mesh = new Mesh();
mf.sharedMesh = mesh;
mr.sharedMaterial = material;
var verts = new Vector3[4];
var tris = new int[] {0, 1, 2, 0, 2, 3};
var uvs = new Vector2[4];
verts[0] = targetPosition - size;
verts[1] = targetPosition + Vector3.up * size.y - Vector3.right * size.x;
verts[2] = targetPosition + size;
verts[3] = targetPosition - Vector3.up * size.y + Vector3.right * size.x;
uvs[0] = new Vector2(0, 0);
uvs[1] = new Vector2(0, size.y);
uvs[2] = new Vector2(size.x, size.y);
uvs[3] = new Vector2(size.x, 0);
mesh.vertices = verts;
mesh.triangles = tris;
mesh.uv = uvs;
if (!underGround) {
var bc = gameObject.GetComponent<BoxCollider2D>();
bc.size = size * 2f;
}
}
private void createFrustum(float width, float height, float distance)
{
MeshCollider collider = this.gameObject.AddComponent <MeshCollider>();
collider.convex = true;
collider.isTrigger = true;
Mesh colliderMesh;
colliderMesh = new Mesh();
colliderMesh.name = "Frustum Mesh";
Vector3[] frustumOriginPlane = new Vector3[4];
frustumOriginPlane[0] = new Vector3(-width * 0.1f, height * 0.1f, 0);
frustumOriginPlane[1] = new Vector3(width * 0.1f, height * 0.1f, 0);
frustumOriginPlane[2] = new Vector3(-width * 0.1f, -height * 0.1f, 0);
frustumOriginPlane[3] = new Vector3(width * 0.1f, -height * 0.1f, 0);
Vector3[] frustumDistantPlane = new Vector3[4];
frustumDistantPlane[0] = new Vector3(-width, height, distance);
frustumDistantPlane[1] = new Vector3(width, height, distance);
frustumDistantPlane[2] = new Vector3(-width, -height, distance);
frustumDistantPlane[3] = new Vector3(width, -height, distance);
colliderMesh.vertices = new Vector3[]
{
// bottom plane
frustumDistantPlane[2], frustumDistantPlane[3], frustumOriginPlane[3], frustumOriginPlane[2],
// left plane
frustumOriginPlane[0], frustumDistantPlane[0], frustumDistantPlane[2], frustumOriginPlane[2],
// front plane - Distant
frustumDistantPlane[0], frustumDistantPlane[1], frustumDistantPlane[3], frustumDistantPlane[2],
// back plane - Origin
frustumOriginPlane[1], frustumOriginPlane[0], frustumOriginPlane[2], frustumOriginPlane[3],
// right plane
frustumDistantPlane[1], frustumOriginPlane[1], frustumOriginPlane[3], frustumDistantPlane[3],
// top plane
frustumOriginPlane[0], frustumOriginPlane[1], frustumDistantPlane[1], frustumDistantPlane[0]
};
colliderMesh.triangles = new int[]
{
// Bottom
3, 1, 0,
3, 2, 1,
// Left
3 + 4 * 1, 1 + 4 * 1, 0 + 4 * 1,
3 + 4 * 1, 2 + 4 * 1, 1 + 4 * 1,
// Front
3 + 4 * 2, 1 + 4 * 2, 0 + 4 * 2,
3 + 4 * 2, 2 + 4 * 2, 1 + 4 * 2,
// Back
3 + 4 * 3, 1 + 4 * 3, 0 + 4 * 3,
3 + 4 * 3, 2 + 4 * 3, 1 + 4 * 3,
// Right
3 + 4 * 4, 1 + 4 * 4, 0 + 4 * 4,
3 + 4 * 4, 2 + 4 * 4, 1 + 4 * 4,
// Top
3 + 4 * 5, 1 + 4 * 5, 0 + 4 * 5,
3 + 4 * 5, 2 + 4 * 5, 1 + 4 * 5,
};
collider.sharedMesh = colliderMesh;
}
static Mesh GenIcosahedron(string name, VertexAttributeDescriptor[] attribs, bool multiSubmeshes, bool linesTopology)
{
var m = new Mesh();
m.name = "Ico" + name;
var t = (1f + Mathf.Sqrt(5f)) / 2f;
var verts = new[]
{
new Vector3(-1,+t,0),
new Vector3(+1,+t,0),
new Vector3(-1,-t,0),
new Vector3(+1,-t,0),
new Vector3(0,-1,+t),
new Vector3(0,+1,+t),
new Vector3(0,-1,-t),
new Vector3(0,+1,-t),
new Vector3(+t,0,-1),
new Vector3(+t,0,+1),
new Vector3(-t,0,-1),
new Vector3(-t,0,+1),
};
var indices = new[] {
0, 11, 5,
0, 5, 1,
0, 1, 7,
0, 7, 10,
0, 10, 11,
1, 5, 9,
5, 11, 4,
11, 10, 2,
10, 7, 6,
7, 1, 8,
3, 9, 4,
3, 4, 2,
3, 2, 6,
3, 6, 8,
3, 8, 9,
4, 9, 5,
2, 4, 11,
6, 2, 10,
8, 6, 7,
9, 8, 1,
};
m.vertices = verts;
m.triangles = indices;
if (multiSubmeshes)
{
m.subMeshCount = 4;
m.SetTriangles(indices.Skip(0).Take(15).ToArray(), 0);
m.SetTriangles(indices.Skip(15).Take(15).ToArray(), 1);
m.SetTriangles(indices.Skip(30).Take(15).ToArray(), 2);
m.SetTriangles(indices.Skip(45).Take(15).ToArray(), 3);
}
if (attribs.Any(e => e.attribute == VertexAttribute.TexCoord0))
m.uv = verts.Select(v => new Vector2(v.x*0.5f, v.y*0.5f)).ToArray();
if (attribs.Any(e => e.attribute == VertexAttribute.TexCoord1))
m.uv2 = verts.Select(v => new Vector2(v.x*0.3f, v.z*0.3f)).ToArray();
m.RecalculateNormals();
m.RecalculateTangents();
if (attribs.Any(e => e.attribute == VertexAttribute.Color))
m.colors = m.normals.Select(v => new Color(-v.x*0.5f+0.5f, Mathf.Cos(v.y*7f)*0.5f+0.5f, Mathf.Sin(v.z*5f)*0.5f+0.5f, 0.5f)).ToArray();
m.SetVertexBufferParams(m.vertexCount, attribs);
if (linesTopology)
{
var lines = new List<int>();
for (var i = 0; i < indices.Length; i += 3)
{
var i0 = indices[i + 0];
var i1 = indices[i + 1];
var i2 = indices[i + 2];
lines.AddRange(new[]{i0,i1, i1,i2, i2,i0});
}
m.SetIndices(lines, MeshTopology.Lines, 0);
}
return m;
}
protected override void SolveInstance(IGH_DataAccess DA)
{
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
System.Diagnostics.FileVersionInfo fvi = System.Diagnostics.FileVersionInfo.GetVersionInfo(assembly.Location);
string version = fvi.FileVersion;
Rhino.RhinoApp.WriteLine("Minimal surface component, version " + version);
Rhino.RhinoApp.WriteLine("GPLv3 licensed, source: https://github.com/Mathias-Fuchs/MinimalSurface");
Rhino.RhinoApp.WriteLine("Copyright Mathias Fuchs 2020 - 2021, https://mathiasfuchs.com");
Curve tc = null;
int nrBoundaryVertices = 0;
int degree = 0;
double angle = 0;
DA.GetData(0, ref tc);
DA.GetData(1, ref nrBoundaryVertices);
DA.GetData(2, ref degree);
DA.GetData(3, ref angle);
if (tc == null || !tc.IsValid || !tc.IsClosed)
{
this.AddRuntimeMessage(GH_RuntimeMessageLevel.Warning, "Input curve is either unvalid or not closed!"); return;
}
Curve _targetCurve = tc;
// number of control points, tells about the complexity of the curve
int nrCont = _targetCurve.ToNurbsCurve().Points.Count;
int crDeg = _targetCurve.Degree;
// if degree isn't specified, use this heuristic
// computationally, 25 is always doable, and more than 300 doesn't usually make sense
if (degree == 0)
{
degree = Math.Min(Math.Max(25, nrCont * crDeg), 300);
}
// number of boundary subdivisions for computation of the polynomials
int _n = 23 * degree;
double[] t = _targetCurve.DivideByCount(_n, true);
var _targetPoints = Enumerable.Range(0, _n).Select(i => _targetCurve.PointAt(t[(i + (int)(angle / Math.PI / 2.0 * _n)) % _n])).ToList();
// now, do the actual work and compute the three complex polynomials
// ok, let's get the coefficients
List <double> xs1 = _targetPoints.Select(o => o.X).ToList(); // 1 ms
LaplaceData kx = new LaplaceData(xs1, degree);
List <double> ys1 = _targetPoints.Select(o => o.Y).ToList(); // 1 ms
LaplaceData ky = new LaplaceData(ys1, degree);
List <double> zs1 = _targetPoints.Select(o => o.Z).ToList(); // 1 ms
LaplaceData kkz = new LaplaceData(zs1, degree);
var c = new Circle(1.0);
var kk = MeshingParameters.Default;
kk.MinimumEdgeLength = 2 * Math.PI / (double)nrBoundaryVertices;
kk.MaximumEdgeLength = 2 * Math.PI / (double)nrBoundaryVertices * 2;
var MM = Mesh.CreateFromPlanarBoundary(c.ToNurbsCurve(), kk, DocumentTolerance());
var MMM = new Mesh();
var mvl = MM.Vertices.Select(pp =>
{
var p = new Point2d(pp.X, pp.Y);
return(new Point3d(kx.eval(p), ky.eval(p), kkz.eval(p)));
}
);
// bottleneck
MMM.Vertices.Capacity = MM.Vertices.Count;
MMM.Vertices.AddVertices(mvl);
MMM.Faces.Capacity = MM.Faces.Count;
MMM.Faces.AddFaces(MM.Faces);
if (MMM.Faces.GetClashingFacePairs(1).Any())
{
this.AddRuntimeMessage(
GH_RuntimeMessageLevel.Warning,
"The resulting mesh has self-intersections. Modifying the rotation angle input parameter can solve this.");
}
DA.SetData(0, MMM);
}
public void UpdateModel()
{
this.fovLeft = Mathf.Clamp(this.fovLeft, 1f, 89f);
this.fovRight = Mathf.Clamp(this.fovRight, 1f, 89f);
this.fovTop = Mathf.Clamp(this.fovTop, 1f, 89f);
this.fovBottom = Mathf.Clamp(this.fovBottom, 1f, 89f);
this.farZ = Mathf.Max(this.farZ, this.nearZ + 0.01f);
this.nearZ = Mathf.Clamp(this.nearZ, 0.01f, this.farZ - 0.01f);
float num = Mathf.Sin(-this.fovLeft * 0.0174532924f);
float num2 = Mathf.Sin(this.fovRight * 0.0174532924f);
float num3 = Mathf.Sin(this.fovTop * 0.0174532924f);
float num4 = Mathf.Sin(-this.fovBottom * 0.0174532924f);
float num5 = Mathf.Cos(-this.fovLeft * 0.0174532924f);
float num6 = Mathf.Cos(this.fovRight * 0.0174532924f);
float num7 = Mathf.Cos(this.fovTop * 0.0174532924f);
float num8 = Mathf.Cos(-this.fovBottom * 0.0174532924f);
Vector3[] array = new Vector3[]
{
new Vector3(num * this.nearZ / num5, num3 * this.nearZ / num7, this.nearZ),
new Vector3(num2 * this.nearZ / num6, num3 * this.nearZ / num7, this.nearZ),
new Vector3(num2 * this.nearZ / num6, num4 * this.nearZ / num8, this.nearZ),
new Vector3(num * this.nearZ / num5, num4 * this.nearZ / num8, this.nearZ),
new Vector3(num * this.farZ / num5, num3 * this.farZ / num7, this.farZ),
new Vector3(num2 * this.farZ / num6, num3 * this.farZ / num7, this.farZ),
new Vector3(num2 * this.farZ / num6, num4 * this.farZ / num8, this.farZ),
new Vector3(num * this.farZ / num5, num4 * this.farZ / num8, this.farZ)
};
int[] array2 = new int[]
{
0,
4,
7,
0,
7,
3,
0,
7,
4,
0,
3,
7,
1,
5,
6,
1,
6,
2,
1,
6,
5,
1,
2,
6,
0,
4,
5,
0,
5,
1,
0,
5,
4,
0,
1,
5,
2,
3,
7,
2,
7,
6,
2,
7,
3,
2,
6,
7
};
int num9 = 0;
Vector3[] array3 = new Vector3[array2.Length];
Vector3[] array4 = new Vector3[array2.Length];
for (int i = 0; i < array2.Length / 3; i++)
{
Vector3 vector = array[array2[i * 3]];
Vector3 vector2 = array[array2[i * 3 + 1]];
Vector3 vector3 = array[array2[i * 3 + 2]];
Vector3 normalized = Vector3.Cross(vector2 - vector, vector3 - vector).normalized;
array4[i * 3] = normalized;
array4[i * 3 + 1] = normalized;
array4[i * 3 + 2] = normalized;
array3[i * 3] = vector;
array3[i * 3 + 1] = vector2;
array3[i * 3 + 2] = vector3;
array2[i * 3] = num9++;
array2[i * 3 + 1] = num9++;
array2[i * 3 + 2] = num9++;
}
Mesh mesh = new Mesh();
mesh.vertices = array3;
mesh.normals = array4;
mesh.triangles = array2;
base.GetComponent<MeshFilter>().mesh = mesh;
}
private void LateUpdate()
{
Mesh Vollider = gameObject.GetComponent <MeshCollider>().sharedMesh;
Vollider.vertices = vertices;
}
private void GenerateRoadParts(Vector2[] points)
{
if (points.Length < 2)
{
return;
}
if (_roadMesh == null || _roadMesh.vertices.Length != Path.EvenlySpacedPoints.Count * 2)
{
_roadMesh = new Mesh();
_roadsidesMesh = new Mesh();
_roadMesh.name = "Road_Mesh";
_roadsidesMesh.name = "Roadsides_Mesh";
Road.transform.localPosition = new Vector3(0, 0, 0);
Road.transform.localScale = new Vector3(1, 1, 1);
Roadsides.transform.localPosition = new Vector3(0, 0, 0);
Roadsides.transform.localScale = new Vector3(1, 1, 1);
Road.mesh = _roadMesh;
RoadCollision.sharedMesh = _roadMesh;
Roadsides.mesh = _roadsidesMesh;
Initialized = true;
}
Vector2 startForward = Vector2.up, endForward = Vector2.up;
Vector3[] verts = new Vector3[points.Length * 2];
Vector3[] vertsRoad = new Vector3[points.Length * 2];
Vector3[] vertsRoadsides = new Vector3[points.Length * 2];
Vector2[] uvs = new Vector2[verts.Length];
Vector3[] normals = new Vector3[verts.Length];
int[] tris = new int[2 * (points.Length - 1) * 3];
int vertIndex = 0;
int triIndex = 0;
for (int i = 0; i < points.Length; i++)
{
Vector2 forward = Vector2.zero;
if (i > 1)
{
if (i < points.Length - 1)
{
forward += points[i] - points[i - 1];
forward += points[i + 1] - points[i];
}
else
{
forward = endForward;
}
}
else
{
forward = startForward;
}
forward.Normalize();
Vector2 left = new Vector2(-forward.y, forward.x);
vertsRoad[vertIndex] = points[i] + left * RoadWidth;
vertsRoad[vertIndex + 1] = points[i] - left * RoadWidth;
vertsRoadsides[vertIndex] = points[i] + left * RoadsideWidth;
vertsRoadsides[vertIndex + 1] = points[i] - left * RoadsideWidth;
float completionPercent = i / (float)(points.Length - 1);
uvs[vertIndex] = new Vector2(0, completionPercent);
uvs[vertIndex + 1] = new Vector2(1, completionPercent);
normals[vertIndex] = Vector3.back;
normals[vertIndex + 1] = Vector3.back;
if (i < points.Length - 1)
{
tris[triIndex] = vertIndex;
tris[triIndex + 1] = vertIndex + 2;
tris[triIndex + 2] = vertIndex + 1;
tris[triIndex + 3] = vertIndex + 1;
tris[triIndex + 4] = vertIndex + 2;
tris[triIndex + 5] = vertIndex + 3;
}
vertIndex += 2;
triIndex += 6;
}
_roadMesh.vertices = vertsRoad;
_roadMesh.triangles = tris;
_roadMesh.uv = uvs;
_roadMesh.normals = normals;
//roadMesh.RecalculateBounds();
_roadsidesMesh.vertices = vertsRoadsides;
_roadsidesMesh.triangles = tris;
_roadsidesMesh.uv = uvs;
_roadsidesMesh.normals = normals;
//roadsidesMesh.RecalculateBounds();
Calculate = false;
Setted = true;
}
private Mesh CreateSmoothedMeshAsset(SelectedMesh originalMesh)
{
//Check if we are ok to overwrite
var overwrite = true;
var rootPath = mCustomDirectory ? Application.dataPath + "/" + mCustomDirectoryPath + "/" : TCP2_Utils.FindReadmePath() + OUTPUT_FOLDER;
if (!Directory.Exists(rootPath))
{
Directory.CreateDirectory(rootPath);
}
#if UNITY_EDITOR_WIN
rootPath = rootPath.Replace(mCustomDirectory ? Application.dataPath : TCP2_Utils.UnityToSystemPath(Application.dataPath), "").Replace(@"\", "/");
#else
rootPath = rootPath.Replace(Application.dataPath, "");
#endif
var originalMeshName = GetSafeFilename(originalMesh.name);
var assetPath = "Assets" + rootPath;
var newAssetName = originalMeshName + " " + MESH_SUFFIX + ".asset";
if (originalMeshName.Contains(MESH_SUFFIX))
{
newAssetName = originalMeshName + ".asset";
}
assetPath += newAssetName;
var existingAsset = AssetDatabase.LoadAssetAtPath(assetPath, typeof(Mesh)) as Mesh;
var assetExists = (existingAsset != null) && originalMesh.isAsset;
if (assetExists)
{
if (!mAlwaysOverwrite)
{
overwrite = EditorUtility.DisplayDialog("TCP2 : Smoothed Mesh", "The following smoothed mesh already exists:\n\n" + newAssetName + "\n\nOverwrite?", "Yes", "No");
}
if (!overwrite)
{
return(null);
}
originalMesh.mesh = existingAsset;
originalMesh.name = existingAsset.name;
}
Mesh newMesh = null;
if (originalMesh.isSkinned)
{
newMesh = TCP2_Utils.CreateSmoothedMesh(originalMesh.mesh, mFormat, false, true, false, !originalMesh.isAsset || (originalMesh.isAsset && assetExists));
}
else
{
newMesh = TCP2_Utils.CreateSmoothedMesh(originalMesh.mesh, mFormat, mVColors, mTangents, mUV2, !originalMesh.isAsset || (originalMesh.isAsset && assetExists));
}
if (newMesh == null)
{
ShowNotification(new GUIContent("Couldn't generate the mesh for:\n" + originalMesh.name));
}
else
{
if (originalMesh.associatedObjects != null)
{
Undo.RecordObjects(originalMesh.associatedObjects, "Assign TCP2 Smoothed Mesh to Selection");
foreach (var o in originalMesh.associatedObjects)
{
if (o is SkinnedMeshRenderer)
{
(o as SkinnedMeshRenderer).sharedMesh = newMesh;
}
else if (o is MeshFilter)
{
(o as MeshFilter).sharedMesh = newMesh;
}
else
{
Debug.LogWarning("[TCP2 Smoothed Normals Utility] Unrecognized AssociatedObject: " + o + "\nType: " + o.GetType());
}
EditorUtility.SetDirty(o);
}
}
if (originalMesh.isAsset)
{
if (overwrite && !assetExists)
{
AssetDatabase.CreateAsset(newMesh, assetPath);
}
}
else
{
return(null);
}
}
return(newMesh);
}
protected override void SolveInstance(IGH_DataAccess DA)
{
///input parameters
Mesh Rhino_mesh = new Mesh();
/// initialise parameters
double T_N = 0.0, T_C = 0.0, D = 0.0, M = 0.0, O = 0.0;
List <double> Rhino_indices = new List <double>();
///import data
if (!DA.GetData("Mesh", ref Rhino_mesh))
{
return;
}
if (!DA.GetData("ThresValN", ref T_N))
{
return;
}
if (!DA.GetData("ThresValC", ref T_C))
{
return;
}
if (!DA.GetData("MaxDist", ref D))
{
return;
}
if (!DA.GetData("Minsize", ref M))
{
return;
}
if (!DA.GetData("Offset", ref O))
{
return;
}
///get mesh data to Matlab
/// 1. decompose mesh into face centroids/normals (rhinocommon => .NET)
/// 1a. compute normals if not present
/// 2. create appropriete matlab arrays (.NET => Matlab)
/// 3. run matlab function (Matlab)
/// 4. convert function output (list with indices) to .Net array (Matlab => .Net)
/// 5. convert array to rhinocommon list. (.Net => Rhinocommon)
/// 6. output data
/// 1.
var Rhino_c = new Point3f();
var Rhino_n = new Vector3f();
var C_xyz = new float[Rhino_mesh.Faces.Count * 3];
var C_n = new float[Rhino_mesh.Faces.Count * 3];
///1a. check if normals are present
if (Rhino_mesh.FaceNormals.Count == 0)
{
Rhino_mesh.FaceNormals.ComputeFaceNormals();
}
/// 2.
for (int i = 0; i < Rhino_mesh.Faces.Count; i++)
{
Rhino_c = (Point3f)Rhino_mesh.Faces.GetFaceCenter(i);
C_xyz[i * 3] = Rhino_c.X;
C_xyz[i * 3 + 1] = Rhino_c.Y;
C_xyz[i * 3 + 2] = Rhino_c.Z;
Rhino_n = Rhino_mesh.FaceNormals[i];
C_n[i * 3] = Rhino_n.X;
C_n[i * 3 + 1] = Rhino_n.Y;
C_n[i * 3 + 2] = Rhino_n.Z;
}
var Matlab_xyz = new MWNumericArray(Rhino_mesh.Faces.Count, 3, C_xyz);
var Matlab_n = new MWNumericArray(Rhino_mesh.Faces.Count, 3, C_n);
/// 3.
Scan2BIM_Matlab.Segmentation segmentation = new Scan2BIM_Matlab.Segmentation();
MWArray cluster = new MWNumericArray();
cluster = segmentation.S2B_RegionGrowing_2(Matlab_xyz, Matlab_n, T_N, T_C, D, M, O);
/// 4.
MWNumericArray na = (MWNumericArray)cluster;
double[] dc = (double[])na.ToVector(0);
/// 5.
Rhino_indices = new List <double>(dc);
/// 6.
DA.SetDataList(0, Rhino_indices);
}
public static void RecalculateTangents(Mesh theMesh)
{
Int32 vertexCount = theMesh.vertexCount;
Vector3[] vertices = theMesh.vertices;
Vector3[] normals = theMesh.normals;
Vector2[] uv = theMesh.uv;
Int32[] triangles = theMesh.triangles;
Int32 triangleCount = triangles.Length / 3;
Vector4[] tangents = new Vector4[vertexCount];
Vector3[] tan1 = new Vector3[vertexCount];
Vector3[] tan2 = new Vector3[vertexCount];
Int32 tri = 0;
for (Int32 i = 0; i < triangleCount; i++)
{
Int32 i1 = triangles[tri];
Int32 i2 = triangles[tri + 1];
Int32 i3 = triangles[tri + 2];
Vector3 v1 = vertices[i1];
Vector3 v2 = vertices[i2];
Vector3 v3 = vertices[i3];
Vector2 w1 = uv[i1];
Vector2 w2 = uv[i2];
Vector2 w3 = uv[i3];
Single x1 = v2.x - v1.x;
Single x2 = v3.x - v1.x;
Single y1 = v2.y - v1.y;
Single y2 = v3.y - v1.y;
Single z1 = v2.z - v1.z;
Single z2 = v3.z - v1.z;
Single s1 = w2.x - w1.x;
Single s2 = w3.x - w1.x;
Single t1 = w2.y - w1.y;
Single t2 = w3.y - w1.y;
Single r = 1.0f / (s1 * t2 - s2 * t1);
Vector3 sdir = new Vector3((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r, (t2 * z1 - t1 * z2) * r);
Vector3 tdir = new Vector3((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r, (s1 * z2 - s2 * z1) * r);
tan1[i1] += sdir;
tan1[i2] += sdir;
tan1[i3] += sdir;
tan2[i1] += tdir;
tan2[i2] += tdir;
tan2[i3] += tdir;
tri += 3;
}
for (Int32 i = 0; i < vertexCount; i++)
{
Vector3 n = normals[i];
Vector3 t = tan1[i];
Vector3.OrthoNormalize(ref n, ref t);
tangents[i].x = t.x;
tangents[i].y = t.y;
tangents[i].z = t.z;
// Calculate handedness
tangents[i].w = Vector3.Dot(Vector3.Cross(n, t), tan2[i]) < 0.0f ? -1.0f : 1.0f;
}
theMesh.tangents = tangents;
}
/// <summary>
/// The Unity Awake() method.
/// </summary>
public void Awake()
{
m_Mesh = GetComponent <MeshFilter>().mesh;
m_MeshRenderer = GetComponent <UnityEngine.MeshRenderer>();
}
public void Start()
{
//TODO generate a random heightmap
Vertices = new Vector3[gridSize * gridSize];
UV = new Vector2[Vertices.Length];
colors = new Color[Vertices.Length];
triangles = new int[Vertices.Length * 9];
int seed = Random.Range(0, 100);
for (int y = 0; y < gridSize; y++)
{
for (int x = 0; x < gridSize; x++)
{
float newY = 0;
if (x == 0 || x == gridSize - 1 || y == 0 || y == gridSize - 1)
{
newY = 0;
}
else
{
newY = Noise(x + seed, y + seed, 10, 3, 2);
newY += Noise(x + seed, y + seed, 2, 1, 1);
newY += Random.Range(-0.5f, 0.5f);
if (x < gridSize / 2)
{
newY *= (float)x / (float)gridSize;
}
else
{
newY *= 1 - (float)x / (float)gridSize;
}
if (y < gridSize / 2)
{
newY *= (float)y / (float)gridSize;
}
else
{
newY *= 1 - (float)y / (float)gridSize;
}
newY *= height;
}
if (newY > snowLevel)
{
colors[y * gridSize + x] = snowColor;
}
else if (newY > rockLevel)
{
colors[y * gridSize + x] = rockColor;
}
else if (newY < sandLevel)
{
colors[y * gridSize + x] = sandColor;
}
else
{
colors[y * gridSize + x] = grassColor;
}
Vertices[y * gridSize + x] = new Vector3(x, newY, y);
UV[y * gridSize + x] = new Vector2((float)x / (float)(gridSize - 1), (float)y / (float)(gridSize - 1));
}
}
for (int y = 0; y < gridSize - 1; y++)
{
for (int x = 0; x < gridSize - 1; x++)
{
//create the triangles
triangles[6 * (y * gridSize + x)] = y * gridSize + x;
triangles[6 * (y * gridSize + x) + 1] = y * gridSize + x + gridSize;
triangles[6 * (y * gridSize + x) + 2] = y * gridSize + x + 1;
triangles[6 * (y * gridSize + x) + 3] = y * gridSize + x + 1 + gridSize;
triangles[6 * (y * gridSize + x) + 4] = y * gridSize + x + 1;
triangles[6 * (y * gridSize + x) + 5] = y * gridSize + x + gridSize;
}
}
gameObject.AddComponent <MeshFilter> ();
gameObject.AddComponent <MeshRenderer> ();
gameObject.renderer.material = partMaterial;
partMesh = new Mesh();
partMesh.vertices = Vertices;
partMesh.colors = colors;
partMesh.uv = UV;
partMesh.triangles = triangles;
partMesh = MeshHelper.FlatShading(partMesh, 1);
gameObject.transform.GetComponent <MeshFilter> ().mesh = partMesh;
MeshCollider collider = gameObject.AddComponent <MeshCollider> ();
transform.position = new Vector3(-gridSize / 2, 0, -gridSize / 2);
//Create water
GameObject Water = new GameObject("Water");
Water.transform.parent = transform;
water = Water.AddComponent <Water>();
water.partMaterial = waterMaterial;
Water.AddComponent <MeshFilter> ();
Water.AddComponent <MeshRenderer> ();
water.speed = 1;
water.waveHeight = 1;
water.Init(seaLevel, gridSize);
GameObject DeepWater = new GameObject("DeepWater");
DeepWater.transform.parent = transform;
water = DeepWater.AddComponent <Water>();
water.partMaterial = waterMaterial;
DeepWater.AddComponent <MeshFilter> ();
DeepWater.AddComponent <MeshRenderer> ();
water.speed = 1;
water.waveHeight = 1;
water.Init(seaLevel - 0.25f, gridSize);
}
public static Mesh DeserializeMesh(String path)
{
FileStream inputStream = new FileStream(path, FileMode.Open, FileAccess.Read);
BinaryReader reader = new BinaryReader(inputStream);
Mesh m;
// Check if the file is bin v1 or v2
Int32 first = reader.ReadInt32();
Boolean v2 = first == -2;
// Parse a v1 mesh
if (!v2)
{
// Get the vertices
Int32 count = first;
Vector3[] vertices = new Vector3[count];
for (Int32 i = 0; i < count; i++)
{
Vector3 vertex;
vertex.x = reader.ReadSingle();
vertex.y = reader.ReadSingle();
vertex.z = reader.ReadSingle();
vertices[i] = vertex;
}
// Get the uvs
Int32 uvCount = reader.ReadInt32();
Vector2[] uvs = new Vector2[uvCount];
for (Int32 i = 0; i < uvCount; i++)
{
Vector2 uv;
uv.x = reader.ReadSingle();
uv.y = reader.ReadSingle();
uvs[i] = uv;
}
// Get the triangles
Int32 trisCount = reader.ReadInt32();
Int32[] triangles = new Int32[trisCount];
for (Int32 i = 0; i < trisCount; i++)
{
triangles[i] = reader.ReadInt32();
}
// Create the mesh
m = new Mesh
{
vertices = vertices,
triangles = triangles,
uv = uvs
};
m.RecalculateNormals();
RecalculateTangents(m);
}
else
{
// Get the vertices
Int32 count = reader.ReadInt32();
Vector3[] vertices = new Vector3[count];
for (Int32 i = 0; i < count; i++)
{
Vector3 vertex;
vertex.x = reader.ReadSingle();
vertex.y = reader.ReadSingle();
vertex.z = reader.ReadSingle();
vertices[i] = vertex;
}
// Get the uvs
Int32 uvCount = reader.ReadInt32();
Vector2[] uvs = new Vector2[uvCount];
for (Int32 i = 0; i < uvCount; i++)
{
Vector2 uv;
uv.x = reader.ReadSingle();
uv.y = reader.ReadSingle();
uvs[i] = uv;
}
// Get the triangles
Int32 trisCount = reader.ReadInt32();
Int32[] triangles = new Int32[trisCount];
for (Int32 i = 0; i < trisCount; i++)
{
triangles[i] = reader.ReadInt32();
}
// Get the uv2s
Int32 uv2Count = reader.ReadInt32();
// ReSharper disable once InconsistentNaming
Vector2[] uv2s = new Vector2[uv2Count];
for (Int32 i = 0; i < uv2Count; i++)
{
Vector2 uv2;
uv2.x = reader.ReadSingle();
uv2.y = reader.ReadSingle();
uv2s[i] = uv2;
}
// Get the normals
Int32 normalCount = reader.ReadInt32();
Vector3[] normals = new Vector3[normalCount];
for (Int32 i = 0; i < normalCount; i++)
{
Vector3 normal;
normal.x = reader.ReadSingle();
normal.y = reader.ReadSingle();
normal.z = reader.ReadSingle();
normals[i] = normal;
}
// Get the tangents
Int32 tangentCount = reader.ReadInt32();
Vector4[] tangents = new Vector4[tangentCount];
for (Int32 i = 0; i < tangentCount; i++)
{
Vector4 tangent;
tangent.x = reader.ReadSingle();
tangent.y = reader.ReadSingle();
tangent.z = reader.ReadSingle();
tangent.w = reader.ReadSingle();
tangents[i] = tangent;
}
// Create the mesh
m = new Mesh
{
vertices = vertices,
triangles = triangles,
uv = uvs,
uv2 = uv2s,
normals = normals,
tangents = tangents
};
}
// Close
reader.Close();
inputStream.Close();
return(m);
}
/// <summary>
/// Initialize the small multiple from point field data
/// </summary>
/// <param name="parser">The VTK Parser</param>
/// <param name="mesh">The mesh to display</param>
/// <param name="uvID">The ID where to put the color data</param>
/// <param name="valueID">The ID of the VTKFieldPointValue</param>
/// <param name="offset">The offset along each axis to apply : pos = x*offset.x + y*offset.y + z*offset.z</param>
/// <param name="density">The density in use</param>
/// <param name="mask">The mask to apply along each point</param>
/// <returns></returns>
public unsafe bool InitFromPointField(VTKParser parser, Mesh mesh, Int32 uvID, Int32 valueID, Vector3Int offset, Vector3Int density, byte *mask)
{
m_material = new Material(ColorMaterial);
m_values = new float[density.x * density.y * density.z];
//Check the ID
if (uvID > 7)
{
Debug.Log("The uvID must be between 0 to 7. This is a limitation of Unity for working within a common mesh...");
return(false);
}
m_mesh = mesh;
VTKStructuredPoints descPts = parser.GetStructuredPointsDescriptor();
//Determine the maximum and minimum positions
Vector3 minModelPos = new Vector3((float)(-descPts.Size[0] / 2.0 * descPts.Spacing[0]),
(float)(-descPts.Size[1] / 2.0 * descPts.Spacing[1]),
(float)(-descPts.Size[2] / 2.0 * descPts.Spacing[2]));
Vector3 maxModelPos = -minModelPos;
//The value buffer
List <VTKFieldValue> fieldDesc = parser.GetPointFieldValueDescriptors();
if (fieldDesc.Count < valueID)
{
Debug.Log("No value to display");
return(false);
}
VTKValue val = parser.ParseAllFieldValues(fieldDesc[valueID]);
List <Vector4> colors = new List <Vector4>((int)(density.x * density.y * density.z));
//Determine the minimum and maximum value and their position
m_maxVal = float.MinValue;
m_minVal = float.MaxValue;
Vector3 minLoc = new Vector3();
Vector3 maxLoc = new Vector3();
for (UInt32 i = 0; i < val.NbValues; i++)
{
if (mask != null && mask[i] == 0)
{
continue;
}
float v = (float)val.ReadAsDouble(i * fieldDesc[valueID].NbValuesPerTuple);
if (m_maxVal < v)
{
m_maxVal = v;
maxLoc = new Vector3(i % descPts.Size[0], (i / descPts.Size[0]) % descPts.Size[1], i / (descPts.Size[0] * descPts.Size[1]));
}
if (m_minVal > v)
{
m_minVal = v;
minLoc = new Vector3(i % descPts.Size[0], (i / descPts.Size[0]) % descPts.Size[1], i / (descPts.Size[0] * descPts.Size[1]));
}
}
//Normalize the location (between 0.0 and 1.0 for the most "long" axis)
Vector3[] vec = new Vector3[2] {
maxLoc, minLoc
};
Vector3 modelDist = maxModelPos - minModelPos;
float maxModelDist = Math.Max(modelDist.x, Math.Max(modelDist.y, modelDist.z));
for (int i = 0; i < vec.Length; i++)
{
Vector3 l = vec[i];
l = (new Vector3((float)(l.x * descPts.Spacing[0]),
(float)(l.y * descPts.Spacing[1]),
(float)(l.z * descPts.Spacing[2])) + minModelPos) / maxModelDist;
vec[i] = l;
}
Debug.Log($"Min : {m_minVal} Max : {m_maxVal}");
//Fill the color array
maxLoc = vec[0];
minLoc = vec[1];
UInt64 colorValueOff = 0;
for (UInt32 k = 0; k < density.z; k++)
{
for (UInt32 j = 0; j < density.y; j++)
{
for (UInt32 i = 0; i < density.x; i++, colorValueOff++)
{
UInt64 fieldOff = (UInt64)(i * offset.x + j * offset.y + k * offset.z);
//Check the mask
if (mask != null && *(mask + fieldOff) == 0)
{
colors.Add(new Vector4(0.0f, 0.0f, 0.0f, 0.0f));
m_values[colorValueOff] = m_minVal;
continue;
}
float c = val.ReadAsFloat(fieldOff * fieldDesc[valueID].NbValuesPerTuple);
m_values[colorValueOff] = c;
c = (float)((c - m_minVal) / (m_maxVal - m_minVal));
//LAB color space (warm - cold)
Color?col = null;
if (c < 0.5)
{
col = LABColor.Lerp(coldColor, whiteColor, 2.0f * c).ToXYZ().ToRGB();
}
else
{
col = LABColor.Lerp(whiteColor, warmColor, 2.0f * (c - 0.5f)).ToXYZ().ToRGB();
}
colors.Add(new Vector4(col.Value.r, col.Value.g, col.Value.b, 1.0f));
}
}
}
//Update the mesh / material
m_mesh.SetUVs(uvID, colors);
m_mesh.UploadMeshData(false);
m_colorID = uvID;
for (int i = 0; i < 8; i++)
{
if (i != m_colorID)
{
m_material.DisableKeyword($"TEXCOORD{i}_ON");
}
}
m_material.EnableKeyword($"TEXCOORD{m_colorID}_ON");
PlaneEnabled = false;
SphereEnabled = false;
CreateGameObjects(vec);
return(true);
}
public static Mesh ComputeScaledSpaceMesh(CelestialBody body, PQS pqs)
{
// We need to get the body for Jool (to steal it's mesh)
const Double R_SCALED_JOOL = 1000.0f;
Double rMetersToScaledUnits = (Single)(R_SCALED_JOOL / body.Radius);
// Generate a duplicate of the Jool mesh
Mesh mesh = DuplicateMesh(Templates.ReferenceGeosphere);
Logger.Active.Log(body);
Logger.Active.Log(pqs);
Logger.Active.Log(body.pqsController);
// If this body has a PQS, we can create a more detailed object, otherwise just return the generic mesh
if (pqs == null)
{
return(mesh);
}
// first we enable all maps
OnDemandStorage.EnableBody(body.bodyName);
// In order to generate the scaled space we have to enable the mods. Since this is
// a prefab they don't get disabled as kill game performance. To resolve this we
// clone the PQS, use it, and then delete it when done. At runtime we can simply use
// the PQS that is active
GameObject pqsVersionGameObject =
Injector.IsInPrefab ? Instantiate(pqs.gameObject) : pqs.gameObject;
PQS pqsVersion = pqsVersionGameObject.GetComponent <PQS>();
// Deactivate blacklisted Mods
PQSMod[] mods = pqsVersion.GetComponentsInChildren <PQSMod>(true).OrderBy(m => m.order).ToArray();
for (Int32 i = 0; i < mods.Length; i++)
{
// Disable mods that don't belong to us
if (mods[i].transform.parent != pqsVersion.transform)
{
mods[i].modEnabled = false;
continue;
}
switch (mods[i])
{
// Disable the OnDemand notifier
case PQSMod_OnDemandHandler _:
mods[i].modEnabled = false;
continue;
case PQSMod_FlattenArea _:
typeof(PQSMod_FlattenArea).GetFields(BindingFlags.NonPublic | BindingFlags.Instance)
.First(f => f.FieldType == typeof(Boolean)).SetValue(mods[i], true);
break;
}
}
pqsVersion.StartUpSphere();
pqsVersion.isBuildingMaps = true;
// If we were able to find PQS mods
if (mods.Length > 0)
{
// Generate the PQS modifications
Vector3[] vertices = mesh.vertices;
for (Int32 i = 0; i < mesh.vertexCount; i++)
{
// Get the UV coordinate of this vertex
Vector2 uv = mesh.uv[i];
// Since this is a geosphere, normalizing the vertex gives the direction from center center
Vector3 direction = vertices[i];
direction.Normalize();
// Build the vertex data object for the PQS mods
PQS.VertexBuildData vertex = new PQS.VertexBuildData
{
directionFromCenter = direction,
vertHeight = body.Radius,
u = uv.x,
v = uv.y
};
// Build from the PQS
for (Int32 m = 0; m < mods.Length; m++)
{
// Don't build disabled mods
if (!mods[m].modEnabled)
{
continue;
}
// Don't build mods that don't belong to us
if (mods[m].transform.parent != pqsVersion.transform)
{
continue;
}
mods[m].OnVertexBuildHeight(vertex);
}
// Check for sea level
if (pqsVersion.mapOcean)
{
vertex.vertHeight = Math.Max(vertex.vertHeight, body.Radius);
}
// Adjust the displacement
vertices[i] = direction * (Single)(vertex.vertHeight * rMetersToScaledUnits);
}
mesh.vertices = vertices;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
RecalculateTangents(mesh);
}
// Cleanup
pqsVersion.isBuildingMaps = false;
pqsVersion.DeactivateSphere();
// If we are working with a copied PQS, clean it up
if (Injector.IsInPrefab)
{
UnityEngine.Object.Destroy(pqsVersionGameObject);
}
OnDemandStorage.DisableBody(body.bodyName);
// Return the generated scaled space mesh
return(mesh);
}
void Update()
{
if (source)
{
int fc = 0;
switch (source.datasource)
{
case MegaCacheData.Mesh: fc = source.meshes.Count - 1; break;
case MegaCacheData.File: fc = source.framecount - 1; break;
case MegaCacheData.Image:
if (source.cacheimage && source.cacheimage.frames != null)
{
fc = source.cacheimage.frames.Count - 1;
}
break;
}
if (fc > 0)
{
if (animate)
{
looptime = fc / fps;
if (Application.isPlaying)
{
time += Time.deltaTime * speed;
}
float at = time;
switch (loopmode)
{
case MegaCacheRepeatMode.Loop:
at = Mathf.Repeat(time, Mathf.Abs(looptime));
if (looptime < 0.0f)
{
at = looptime - at;
}
break;
case MegaCacheRepeatMode.PingPong: at = Mathf.PingPong(time, looptime); break;
case MegaCacheRepeatMode.Clamp: at = Mathf.Clamp(time, 0.0f, looptime); break;
}
frame = (int)((at / looptime) * fc);
}
frame = Mathf.Clamp(frame, 0, fc);
if (frame != currentframe)
{
currentframe = frame;
if (source.datasource == MegaCacheData.Image && source.cacheimage)
{
if (imagemesh == null)
{
imagemesh = new Mesh();
}
if (mf.sharedMesh != imagemesh)
{
mf.sharedMesh = imagemesh;
}
source.cacheimage.GetMeshRef(imagemesh, frame, source);
}
if (source.datasource == MegaCacheData.File)
{
if (imagemesh == null)
{
imagemesh = new Mesh();
}
if (mf.sharedMesh != imagemesh)
{
mf.sharedMesh = imagemesh;
}
source.GetFrameRef(frame, imagemesh);
}
if (source.datasource == MegaCacheData.Mesh)
{
if (mf && source.meshes.Count > 0)
{
if (mf.sharedMesh != source.meshes[frame])
{
mf.sharedMesh = source.meshes[frame];
}
}
}
if (updatecollider)
{
if (meshCol == null)
{
meshCol = GetComponent <MeshCollider>();
}
if (meshCol != null)
{
meshCol.sharedMesh = null;
meshCol.sharedMesh = mf.sharedMesh;
}
}
}
}
}
}
private void CombineMesh(Mesh[] pShape_r)
{
StructShapeCache[] _Cache_r;
if (pShape_r == null || pShape_r.Length <= 0)
{
// Default shape
_Cache_r = new StructShapeCache[] {
new StructShapeCache(null)
};
}
else
{
_Cache_r = new StructShapeCache[pShape_r.Length];
for (int i = 0; i < pShape_r.Length; i++)
{
_Cache_r[i] = new StructShapeCache(pShape_r[i]);
}
}
int _CountVertex = 0, _CountIndex = 0;
foreach (StructShapeCache _Cache in _Cache_r)
{
_CountVertex += _Cache.CountVertex;
}
if (_CountVertex <= 0)
{
return;
}
// コピー数を決定
_CountVertex = 0;
for (this.m_CountCopy = 0; this.m_CountCopy < this.m_CountCopyMax; this.m_CountCopy++)
{
StructShapeCache _Cache = _Cache_r[this.CountCopy % _Cache_r.Length];
if (65535 < _CountVertex + _Cache.CountVertex)
{
break;
}
_CountVertex += _Cache.CountVertex;
_CountIndex += _Cache.CountIndex;
}
// バーテックス配列生成
Vector3[] _Vertex_r = new Vector3[_CountVertex];
Vector3[] _Normal_r = new Vector3[_CountVertex];
Vector4[] _Tangent_r = new Vector4[_CountVertex];
Vector2[] _UV1_r = new Vector2[_CountVertex];
Vector2[] _UV2_r = new Vector2[_CountVertex];
int[] _Index_r = new int[_CountIndex];
for (int iVertex = 0, iIndex = 0, iElm = 0; iVertex < _CountVertex; iElm++)
{
StructShapeCache _Cache = _Cache_r[iElm % _Cache_r.Length];
_Cache.CopyVertexTo(_Vertex_r, iVertex);
_Cache.CopyNormalTo(_Normal_r, iVertex);
_Cache.CopyTangentTo(_Tangent_r, iVertex);
_Cache.CopyUVTo(_UV1_r, iVertex);
_Cache.CopyIndexTo(_Index_r, iIndex, iVertex);
Vector2 _Coord = new Vector2((float)iElm / this.CountCopy, 0.0f);
for (int i = 0; i < _Cache.CountVertex; i++)
{
_UV2_r[iVertex + i] = _Coord;
}
iVertex += _Cache.CountVertex;
iIndex += _Cache.CountIndex;
}
// メッシュオブジェクト生成
this.m_Mesh = new Mesh();
this.m_Mesh.vertices = _Vertex_r;
this.m_Mesh.normals = _Normal_r;
this.m_Mesh.tangents = _Tangent_r;
this.m_Mesh.uv = _UV1_r;
this.m_Mesh.uv2 = _UV2_r;
this.m_Mesh.SetIndices(_Index_r, MeshTopology.Triangles, 0);
this.m_Mesh.hideFlags = HideFlags.DontSave; // 一時使用のため保存しない
this.m_Mesh.bounds = new Bounds(Vector3.zero, Vector3.one * 1000); // 淘汰されないよう制御
}
private void CreateUVSphere()
{
#region Setup
MeshFilter filter = GetComponent<MeshFilter>();
Mesh mesh = filter.sharedMesh;
if (mesh == null)
{
mesh = filter.sharedMesh = new Mesh();
mesh.name = gameObject.name + "_Mesh";
}
mesh.Clear();
int latitudeCount = 10 * Detail;
int longitudeCount = 15 * Detail;
#endregion Setup
#region Vertices
Vector3[] vertices = new Vector3[(longitudeCount + 1) * latitudeCount + 2];
float _pi = Mathf.PI;
float _2pi = _pi * 2f;
vertices[0] = Vector3.up * Radius;
for (int lat = 0; lat < latitudeCount; lat++)
{
float a1 = _pi * (float)(lat + 1) / (latitudeCount + 1);
float sin1 = Mathf.Sin(a1);
float cos1 = Mathf.Cos(a1);
for (int lon = 0; lon <= longitudeCount; lon++)
{
float a2 = _2pi * (float)(lon == longitudeCount ? 0 : lon) / longitudeCount;
float sin2 = Mathf.Sin(a2);
float cos2 = Mathf.Cos(a2);
vertices[lon + lat * (longitudeCount + 1) + 1] = new Vector3(sin1 * cos2, cos1, sin1 * sin2) * Radius;
}
}
vertices[vertices.Length - 1] = Vector3.up * -Radius;
#endregion
#region Normales
Vector3[] normales = new Vector3[vertices.Length];
for (int n = 0; n < vertices.Length; n++)
normales[n] = vertices[n].normalized;
#endregion
#region UVs
Vector2[] uvs = new Vector2[vertices.Length];
uvs[0] = Vector2.up;
uvs[uvs.Length - 1] = Vector2.zero;
for (int lat = 0; lat < latitudeCount; lat++)
for (int lon = 0; lon <= longitudeCount; lon++)
uvs[lon + lat * (longitudeCount + 1) + 1] = new Vector2((float)lon / longitudeCount, 1f - (float)(lat + 1) / (latitudeCount + 1));
#endregion
#region Triangles
int nbFaces = vertices.Length;
int nbTriangles = nbFaces * 2;
int nbIndexes = nbTriangles * 3;
int[] triangles = new int[nbIndexes];
//Top Cap
int i = 0;
for (int lon = 0; lon < longitudeCount; lon++)
{
triangles[i++] = lon + 2;
triangles[i++] = lon + 1;
triangles[i++] = 0;
}
//Middle
for (int lat = 0; lat < latitudeCount - 1; lat++)
{
for (int lon = 0; lon < longitudeCount; lon++)
{
int current = lon + lat * (longitudeCount + 1) + 1;
int next = current + longitudeCount + 1;
triangles[i++] = current;
triangles[i++] = current + 1;
triangles[i++] = next + 1;
triangles[i++] = current;
triangles[i++] = next + 1;
triangles[i++] = next;
}
}
//Bottom Cap
for (int lon = 0; lon < longitudeCount; lon++)
{
triangles[i++] = vertices.Length - 1;
triangles[i++] = vertices.Length - (lon + 2) - 1;
triangles[i++] = vertices.Length - (lon + 1) - 1;
}
#endregion
#region Finish Up
mesh.vertices = vertices;
mesh.normals = normales;
mesh.uv = uvs;
mesh.triangles = triangles;
mesh.RecalculateBounds();
;
#endregion Finish Up
}
public void Set(BetterList <Vector3> verts, BetterList <Vector3> norms, BetterList <Vector4> tans, BetterList <Vector2> uvs, BetterList <Color32> cols)
{
int size = verts.size;
if (size > 0 && size == uvs.size && size == cols.size && size % 4 == 0)
{
if (mFilter == null)
{
mFilter = base.gameObject.GetComponent <MeshFilter>();
}
if (mFilter == null)
{
mFilter = base.gameObject.AddComponent <MeshFilter>();
}
if (mRen == null)
{
mRen = base.gameObject.GetComponent <MeshRenderer>();
}
if (mRen == null)
{
mRen = base.gameObject.AddComponent <MeshRenderer>();
UpdateMaterials();
}
else if (mClippedMat != null && mClippedMat.mainTexture != mSharedMat.mainTexture)
{
UpdateMaterials();
}
if (verts.size < 65000)
{
int num = (size >> 1) * 3;
bool rebuildIndices = mIndices == null || mIndices.Length != num;
if (rebuildIndices)
{
mIndices = new int[num];
int num2 = 0;
for (int i = 0; i < size; i += 4)
{
mIndices[num2++] = i;
mIndices[num2++] = i + 1;
mIndices[num2++] = i + 2;
mIndices[num2++] = i + 2;
mIndices[num2++] = i + 3;
mIndices[num2++] = i;
}
}
Mesh mesh = GetMesh(ref rebuildIndices, verts.size);
mesh.vertices = verts.ToArray();
if (norms != null)
{
mesh.normals = norms.ToArray();
}
if (tans != null)
{
mesh.tangents = tans.ToArray();
}
mesh.uv = uvs.ToArray();
mesh.colors32 = cols.ToArray();
if (rebuildIndices)
{
mesh.triangles = mIndices;
}
mesh.RecalculateBounds();
mFilter.mesh = mesh;
}
else
{
if (mFilter.mesh != null)
{
mFilter.mesh.Clear();
}
Debug.LogError("Too many vertices on one panel: " + verts.size);
}
}
else
{
if (mFilter.mesh != null)
{
mFilter.mesh.Clear();
}
Debug.LogError("UIWidgets must fill the buffer with 4 vertices per quad. Found " + size);
}
}
public static void DrawQuads(Vector3[] verts, float width)
{
//65000 limit divided by 4
if (verts.Length >= 16250)
{
Vector3[] verts2 = new Vector3[verts.Length - 16250];
for (int i = 16250; i < verts.Length; i++)
{
verts2[i - 16250] = verts[i];
}
Vector3[] verts3 = new Vector3[16250];
for (int i = 0; i < 16250; i++)
{
verts3[i] = verts[i];
}
DrawQuads(verts2, width);
verts = verts3;
}
width /= 2F;
Vector3[] vertices = new Vector3[verts.Length * 4];
int[] tris = new int[verts.Length * 6];
for (int i = 0; i < verts.Length; i++)
{
Vector3 p = verts[i];
int vIndex = i * 4;
vertices[vIndex] = p + new Vector3(-width, 0, -width);
vertices[vIndex + 1] = p + new Vector3(-width, 0, width);
vertices[vIndex + 2] = p + new Vector3(width, 0, width);
vertices[vIndex + 3] = p + new Vector3(width, 0, -width);
int tIndex = i * 6;
tris[tIndex] = vIndex;
tris[tIndex + 1] = vIndex + 1;
tris[tIndex + 2] = vIndex + 2;
tris[tIndex + 3] = vIndex;
tris[tIndex + 4] = vIndex + 2;
tris[tIndex + 5] = vIndex + 3;
}
Mesh mesh = new Mesh();
mesh.vertices = vertices;
mesh.triangles = tris;
mesh.RecalculateNormals();
mesh.RecalculateBounds();
GameObject go = new GameObject("DebugMesh");
MeshRenderer rend = go.AddComponent(typeof(MeshRenderer)) as MeshRenderer;
rend.material = active.defaultMaterial;
(go.AddComponent(typeof(MeshFilter)) as MeshFilter).mesh = mesh;
}
public void CreateIcoSphere()
{
MeshFilter filter = GetComponent<MeshFilter>();
Mesh mesh = filter.sharedMesh;
if (mesh == null)
{
mesh = filter.sharedMesh = new Mesh();
mesh.name = gameObject.name + "_Mesh";
}
mesh.Clear();
Dictionary<MiddlePointCacheKey, int> middlePointIndexCache = new Dictionary<MiddlePointCacheKey, int>();
List<Vector3> vertList = new List<Vector3>();
List<int> triList = new List<int>();
List<Vector3> normals = new List<Vector3>();
List<Vector2> uvs = new List<Vector2>();
// create 12 vertices of a icosahedron
float t = (1f + Mathf.Sqrt(5f)) / 2f;
vertList.Add(new Vector3(-1f, t, 0f).normalized * Radius);
vertList.Add(new Vector3(1f, t, 0f).normalized * Radius);
vertList.Add(new Vector3(-1f, -t, 0f).normalized * Radius);
vertList.Add(new Vector3(1f, -t, 0f).normalized * Radius);
vertList.Add(new Vector3(0f, -1f, t).normalized * Radius);
vertList.Add(new Vector3(0f, 1f, t).normalized * Radius);
vertList.Add(new Vector3(0f, -1f, -t).normalized * Radius);
vertList.Add(new Vector3(0f, 1f, -t).normalized * Radius);
vertList.Add(new Vector3(t, 0f, -1f).normalized * Radius);
vertList.Add(new Vector3(t, 0f, 1f).normalized * Radius);
vertList.Add(new Vector3(-t, 0f, -1f).normalized * Radius);
vertList.Add(new Vector3(-t, 0f, 1f).normalized * Radius);
// create 20 triangles of the icosahedron
List<TriangleIndices> faces = new List<TriangleIndices>();
// 5 faces around point 0
faces.Add(new TriangleIndices(0, 11, 5));
faces.Add(new TriangleIndices(0, 5, 1));
faces.Add(new TriangleIndices(0, 1, 7));
faces.Add(new TriangleIndices(0, 7, 10));
faces.Add(new TriangleIndices(0, 10, 11));
// 5 adjacent faces
faces.Add(new TriangleIndices(1, 5, 9));
faces.Add(new TriangleIndices(5, 11, 4));
faces.Add(new TriangleIndices(11, 10, 2));
faces.Add(new TriangleIndices(10, 7, 6));
faces.Add(new TriangleIndices(7, 1, 8));
// 5 faces around point 3
faces.Add(new TriangleIndices(3, 9, 4));
faces.Add(new TriangleIndices(3, 4, 2));
faces.Add(new TriangleIndices(3, 2, 6));
faces.Add(new TriangleIndices(3, 6, 8));
faces.Add(new TriangleIndices(3, 8, 9));
// 5 adjacent faces
faces.Add(new TriangleIndices(4, 9, 5));
faces.Add(new TriangleIndices(2, 4, 11));
faces.Add(new TriangleIndices(6, 2, 10));
faces.Add(new TriangleIndices(8, 6, 7));
faces.Add(new TriangleIndices(9, 8, 1));
// refine triangles
for (int i = 0; i < Detail; i++)
{
List<TriangleIndices> faces2 = new List<TriangleIndices>();
foreach (var tri in faces)
{
// replace triangle by 4 triangles
int a = GetMiddlePoint(tri.v1, tri.v2, vertList, middlePointIndexCache);
int b = GetMiddlePoint(tri.v2, tri.v3, vertList, middlePointIndexCache);
int c = GetMiddlePoint(tri.v3, tri.v1, vertList, middlePointIndexCache);
faces2.Add(new TriangleIndices(tri.v1, a, c));
faces2.Add(new TriangleIndices(tri.v2, b, a));
faces2.Add(new TriangleIndices(tri.v3, c, b));
faces2.Add(new TriangleIndices(a, b, c));
}
faces = faces2;
}
for (int i = 0; i < vertList.Count; i++)
{
Vector3 n = vertList[i].normalized;
normals.Add(n);
float u = 0.5f - (0.5f * Mathf.Atan2(n.x, n.z) / Mathf.PI);
float v = 1.0f - Mathf.Acos(n.y) / Mathf.PI;
uvs.Add(new Vector2(u, v));
}
for (int i = 0; i < faces.Count; i++)
{
triList.Add(faces[i].v1);
triList.Add(faces[i].v2);
triList.Add(faces[i].v3);
}
System.Action<int, Vector2> fixVertex = (int i, Vector2 uv) =>
{
int index = triList[i];
triList[i] = vertList.Count;
vertList.Add(vertList[index]);
normals.Add(normals[index]);
uvs.Add(uv);
};
// fix texture seams
for (int i = 0; i < triList.Count; i += 3)
{
Vector2 uv0 = uvs[triList[i]];
Vector2 uv1 = uvs[triList[i + 1]];
Vector2 uv2 = uvs[triList[i + 2]];
float d1 = uv1.x - uv0.x;
float d2 = uv2.x - uv0.x;
if (Mathf.Abs(d1) > 0.5f)
{
if (Mathf.Abs(d2) > 0.5f)
{
fixVertex(i, uv0 + new Vector2((d1 > 0.0f) ? 1.0f : -1.0f, 0.0f));
}
else
{
fixVertex(i + 1, uv1 + new Vector2((d1 < 0.0f) ? 1.0f : -1.0f, 0.0f));
}
}
else if (Mathf.Abs(d2) > 0.5f)
{
fixVertex(i + 2, uv2 + new Vector2((d2 < 0.0f) ? 1.0f : -1.0f, 0.0f));
}
}
mesh.SetVertices(vertList);
mesh.SetUVs(0, uvs);
mesh.SetNormals(normals);
mesh.SetTriangles(triList, 0);
mesh.RecalculateBounds();
;
middlePointIndexCache.Clear();
}
/**
* ProBuilderize in-place function. You must call ToMesh() and Refresh() after
* returning from this function, as this only creates the pb_Object and sets its
* fields. This allows you to record the mesh and gameObject for Undo operations.
*/
public static bool ResetPbObjectWithMeshFilter(pb_Object pb, bool preserveFaces)
{
MeshFilter mf = pb.gameObject.GetComponent <MeshFilter>();
if (mf == null || mf.sharedMesh == null)
{
Debug.Log(pb.name + " does not have a mesh or Mesh Filter component.");
return(false);
}
Mesh m = mf.sharedMesh;
int vertexCount = m.vertexCount;
Vector3[] m_vertices = m.vertices;
Color[] m_colors = m.colors != null && m.colors.Length == vertexCount ? m.colors : new Color[vertexCount];
Vector2[] m_uvs = m.uv;
List <Vector3> verts = preserveFaces ? new List <Vector3>(m.vertices) : new List <Vector3>();
List <Color> cols = preserveFaces ? new List <Color>(m.colors) : new List <Color>();
List <Vector2> uvs = preserveFaces ? new List <Vector2>(m.uv) : new List <Vector2>();
List <pb_Face> faces = new List <pb_Face>();
MeshRenderer mr = pb.gameObject.GetComponent <MeshRenderer>();
if (mr == null)
{
mr = pb.gameObject.AddComponent <MeshRenderer>();
}
Material[] sharedMaterials = mr.sharedMaterials;
int mat_length = sharedMaterials.Length;
for (int n = 0; n < m.subMeshCount; n++)
{
int[] tris = m.GetTriangles(n);
for (int i = 0; i < tris.Length; i += 3)
{
int index = -1;
if (preserveFaces)
{
for (int j = 0; j < faces.Count; j++)
{
if (faces[j].distinctIndices.Contains(tris[i + 0]) ||
faces[j].distinctIndices.Contains(tris[i + 1]) ||
faces[j].distinctIndices.Contains(tris[i + 2]))
{
index = j;
break;
}
}
}
if (index > -1 && preserveFaces)
{
int len = faces[index].indices.Length;
int[] arr = new int[len + 3];
System.Array.Copy(faces[index].indices, 0, arr, 0, len);
arr[len + 0] = tris[i + 0];
arr[len + 1] = tris[i + 1];
arr[len + 2] = tris[i + 2];
faces[index].SetIndices(arr);
faces[index].RebuildCaches();
}
else
{
int[] faceTris;
if (preserveFaces)
{
faceTris = new int[3]
{
tris[i + 0],
tris[i + 1],
tris[i + 2]
};
}
else
{
verts.Add(m_vertices[tris[i + 0]]);
verts.Add(m_vertices[tris[i + 1]]);
verts.Add(m_vertices[tris[i + 2]]);
cols.Add(m_colors != null && m_colors.Length == vertexCount ? m_colors[tris[i + 0]] : Color.white);
cols.Add(m_colors != null && m_colors.Length == vertexCount ? m_colors[tris[i + 1]] : Color.white);
cols.Add(m_colors != null && m_colors.Length == vertexCount ? m_colors[tris[i + 2]] : Color.white);
uvs.Add(m_uvs[tris[i + 0]]);
uvs.Add(m_uvs[tris[i + 1]]);
uvs.Add(m_uvs[tris[i + 2]]);
faceTris = new int[3] {
i + 0, i + 1, i + 2
};
}
faces.Add(
new pb_Face(
faceTris,
sharedMaterials[n >= mat_length ? mat_length - 1 : n],
new pb_UV(),
0, // smoothing group
-1, // texture group
-1, // element group
true // manualUV
));
}
}
}
pb.SetVertices(verts.ToArray());
pb.SetUV(uvs.ToArray());
pb.SetFaces(faces.ToArray());
pb.SetSharedIndices(pb_IntArrayUtility.ExtractSharedIndices(verts.ToArray()));
pb.SetColors(cols.ToArray());
return(true);
}
public static void DrawCubes(Vector3[] topVerts, Vector3[] bottomVerts, Color[] vertexColors, float width)
{
if (active == null)
{
active = GameObject.FindObjectOfType(typeof(DebugUtility)) as DebugUtility;
}
if (active == null)
{
throw new System.NullReferenceException();
}
if (topVerts.Length != bottomVerts.Length || topVerts.Length != vertexColors.Length)
{
Debug.LogError("Array Lengths are not the same");
return;
}
//65000 limit divided by 4*6 = 24
if (topVerts.Length > 2708)
{
Vector3[] topVerts2 = new Vector3[topVerts.Length - 2708];
Vector3[] bottomVerts2 = new Vector3[topVerts.Length - 2708];
Color[] vertexColors2 = new Color[topVerts.Length - 2708];
for (int i = 2708; i < topVerts.Length; i++)
{
topVerts2[i - 2708] = topVerts[i];
bottomVerts2[i - 2708] = bottomVerts[i];
vertexColors2[i - 2708] = vertexColors[i];
}
Vector3[] topVerts3 = new Vector3[2708];
Vector3[] bottomVerts3 = new Vector3[2708];
Color[] vertexColors3 = new Color[2708];
for (int i = 0; i < 2708; i++)
{
topVerts3[i] = topVerts[i];
bottomVerts3[i] = bottomVerts[i];
vertexColors3[i] = vertexColors[i];
}
DrawCubes(topVerts2, bottomVerts2, vertexColors2, width);
topVerts = topVerts3;
bottomVerts = bottomVerts3;
vertexColors = vertexColors3;
}
width /= 2F;
Vector3[] vertices = new Vector3[topVerts.Length * 4 * 6];
int[] tris = new int[topVerts.Length * 6 * 6];
Color[] colors = new Color[topVerts.Length * 4 * 6];
for (int i = 0; i < topVerts.Length; i++)
{
Vector3 top = topVerts[i] + new Vector3(0, active.offset, 0);
Vector3 bottom = bottomVerts[i] - new Vector3(0, active.offset, 0);;
Vector3 top1 = top + new Vector3(-width, 0, -width);
Vector3 top2 = top + new Vector3(width, 0, -width);
Vector3 top3 = top + new Vector3(width, 0, width);
Vector3 top4 = top + new Vector3(-width, 0, width);
Vector3 bottom1 = bottom + new Vector3(-width, 0, -width);
Vector3 bottom2 = bottom + new Vector3(width, 0, -width);
Vector3 bottom3 = bottom + new Vector3(width, 0, width);
Vector3 bottom4 = bottom + new Vector3(-width, 0, width);
int vIndex = i * 4 * 6;
Color col = vertexColors[i];
//Color.Lerp (Color.green,Color.red,topVerts[i].y*0.06F);
//
for (int c = vIndex; c < vIndex + 24; c++)
{
colors[c] = col;
}
//Top
vertices[vIndex] = top1;
vertices[vIndex + 1] = top4;
vertices[vIndex + 2] = top3;
vertices[vIndex + 3] = top2;
int tIndex = i * 6 * 6;
tris[tIndex] = vIndex;
tris[tIndex + 1] = vIndex + 1;
tris[tIndex + 2] = vIndex + 2;
tris[tIndex + 3] = vIndex;
tris[tIndex + 4] = vIndex + 2;
tris[tIndex + 5] = vIndex + 3;
//Bottom
vIndex += 4;
vertices[vIndex + 3] = bottom1;
vertices[vIndex + 2] = bottom4;
vertices[vIndex + 1] = bottom3;
vertices[vIndex] = bottom2;
tIndex += 6;
tris[tIndex] = vIndex;
tris[tIndex + 1] = vIndex + 1;
tris[tIndex + 2] = vIndex + 2;
tris[tIndex + 3] = vIndex;
tris[tIndex + 4] = vIndex + 2;
tris[tIndex + 5] = vIndex + 3;
//Right
vIndex += 4;
vertices[vIndex] = bottom2;
vertices[vIndex + 1] = top2;
vertices[vIndex + 2] = top3;
vertices[vIndex + 3] = bottom3;
tIndex += 6;
tris[tIndex] = vIndex;
tris[tIndex + 1] = vIndex + 1;
tris[tIndex + 2] = vIndex + 2;
tris[tIndex + 3] = vIndex;
tris[tIndex + 4] = vIndex + 2;
tris[tIndex + 5] = vIndex + 3;
//Left
vIndex += 4;
vertices[vIndex + 3] = bottom1;
vertices[vIndex + 2] = top1;
vertices[vIndex + 1] = top4;
vertices[vIndex] = bottom4;
tIndex += 6;
tris[tIndex] = vIndex;
tris[tIndex + 1] = vIndex + 1;
tris[tIndex + 2] = vIndex + 2;
tris[tIndex + 3] = vIndex;
tris[tIndex + 4] = vIndex + 2;
tris[tIndex + 5] = vIndex + 3;
//Forward
vIndex += 4;
vertices[vIndex + 3] = bottom3;
vertices[vIndex + 2] = bottom4;
vertices[vIndex + 1] = top4;
vertices[vIndex] = top3;
tIndex += 6;
tris[tIndex] = vIndex;
tris[tIndex + 1] = vIndex + 1;
tris[tIndex + 2] = vIndex + 2;
tris[tIndex + 3] = vIndex;
tris[tIndex + 4] = vIndex + 2;
tris[tIndex + 5] = vIndex + 3;
//Back
vIndex += 4;
vertices[vIndex] = bottom2;
vertices[vIndex + 1] = bottom1;
vertices[vIndex + 2] = top1;
vertices[vIndex + 3] = top2;
tIndex += 6;
tris[tIndex] = vIndex;
tris[tIndex + 1] = vIndex + 1;
tris[tIndex + 2] = vIndex + 2;
tris[tIndex + 3] = vIndex;
tris[tIndex + 4] = vIndex + 2;
tris[tIndex + 5] = vIndex + 3;
}
Mesh mesh = new Mesh();
mesh.vertices = vertices;
mesh.triangles = tris;
mesh.colors = colors;
mesh.name = "VoxelMesh";
mesh.RecalculateNormals();
mesh.RecalculateBounds();
if (active.optimizeMeshes)
{
mesh.Optimize();
}
GameObject go = new GameObject("DebugMesh");
MeshRenderer rend = go.AddComponent(typeof(MeshRenderer)) as MeshRenderer;
rend.material = active.defaultMaterial;
(go.AddComponent(typeof(MeshFilter)) as MeshFilter).mesh = mesh;
}
public static void GenerateSecondaryUVSet(Mesh src, UnwrapParam settings)
{
MeshUtility.SetPerTriangleUV2(src, Unwrapping.GeneratePerTriangleUV(src, settings));
}
/**
* "ProBuilder-ize function"
*/
public static pb_Object CreatePbObjectWithTransform(Transform t, bool preserveFaces)
{
Mesh m = t.GetComponent <MeshFilter>().sharedMesh;
Vector3[] m_vertices = m.vertices;
Color[] m_colors = m.colors ?? new Color[m_vertices.Length];
Vector2[] m_uvs = m.uv;
List <Vector3> verts = preserveFaces ? new List <Vector3>(m.vertices) : new List <Vector3>();
List <Color> cols = preserveFaces ? new List <Color>(m.colors) : new List <Color>();
List <Vector2> uvs = preserveFaces ? new List <Vector2>(m.uv) : new List <Vector2>();
List <pb_Face> faces = new List <pb_Face>();
for (int n = 0; n < m.subMeshCount; n++)
{
int[] tris = m.GetTriangles(n);
for (int i = 0; i < tris.Length; i += 3)
{
int index = -1;
if (preserveFaces)
{
for (int j = 0; j < faces.Count; j++)
{
if (faces[j].distinctIndices.Contains(tris[i + 0]) ||
faces[j].distinctIndices.Contains(tris[i + 1]) ||
faces[j].distinctIndices.Contains(tris[i + 2]))
{
index = j;
break;
}
}
}
if (index > -1 && preserveFaces)
{
int len = faces[index].indices.Length;
int[] arr = new int[len + 3];
System.Array.Copy(faces[index].indices, 0, arr, 0, len);
arr[len + 0] = tris[i + 0];
arr[len + 1] = tris[i + 1];
arr[len + 2] = tris[i + 2];
faces[index].SetIndices(arr);
faces[index].RebuildCaches();
}
else
{
int[] faceTris;
if (preserveFaces)
{
faceTris = new int[3]
{
tris[i + 0],
tris[i + 1],
tris[i + 2]
};
}
else
{
verts.Add(m_vertices[tris[i + 0]]);
verts.Add(m_vertices[tris[i + 1]]);
verts.Add(m_vertices[tris[i + 2]]);
cols.Add(m_colors != null ? m_colors[tris[i + 0]] : Color.white);
cols.Add(m_colors != null ? m_colors[tris[i + 1]] : Color.white);
cols.Add(m_colors != null ? m_colors[tris[i + 2]] : Color.white);
uvs.Add(m_uvs[tris[i + 0]]);
uvs.Add(m_uvs[tris[i + 1]]);
uvs.Add(m_uvs[tris[i + 2]]);
faceTris = new int[3] {
i + 0, i + 1, i + 2
};
}
faces.Add(
new pb_Face(
faceTris,
t.GetComponent <MeshRenderer>().sharedMaterials[n],
new pb_UV(),
0, // smoothing group
-1, // texture group
-1, // element group
true // manualUV
));
}
}
}
GameObject go = (GameObject)GameObject.Instantiate(t.gameObject);
go.GetComponent <MeshFilter>().sharedMesh = null;
pb_Object pb = go.AddComponent <pb_Object>();
pb.GeometryWithVerticesFaces(verts.ToArray(), faces.ToArray());
pb.SetColors(cols.ToArray());
pb.SetUV(uvs.ToArray());
pb.SetName(t.name);
go.transform.position = t.position;
go.transform.localRotation = t.localRotation;
go.transform.localScale = t.localScale;
pb.CenterPivot(null);
return(pb);
}
internal static Vector2[] GeneratePerTriangleUVImpl(Mesh src, UnwrapParam settings)
{
return(Unwrapping.INTERNAL_CALL_GeneratePerTriangleUVImpl(src, ref settings));
}
/// <summary>
/// Set the draw call's geometry.
/// </summary>
public void Set(BetterList <Vector3> verts, BetterList <Vector3> norms, BetterList <Vector4> tans, BetterList <Vector2> uvs, BetterList <Color32> cols)
{
int count = verts.size;
// Safety check to ensure we get valid values
if (count > 0 && (count == uvs.size && count == cols.size) && (count % 4) == 0)
{
// Cache all components
if (mFilter == null)
{
mFilter = gameObject.GetComponent <MeshFilter>();
}
if (mFilter == null)
{
mFilter = gameObject.AddComponent <MeshFilter>();
}
if (verts.size < 65000)
{
// Populate the index buffer
int indexCount = (count >> 1) * 3;
bool setIndices = (mIndices == null || mIndices.Length != indexCount);
// Create the mesh
if (mMesh == null)
{
mMesh = new Mesh();
mMesh.hideFlags = HideFlags.DontSave;
mMesh.name = (mMaterial != null) ? mMaterial.name : "Mesh";
#if !UNITY_3_5
mMesh.MarkDynamic();
#endif
setIndices = true;
}
#if !UNITY_FLASH
// If the buffer length doesn't match, we need to trim all buffers
bool trim = (uvs.buffer.Length != verts.buffer.Length) ||
(cols.buffer.Length != verts.buffer.Length) ||
(norms != null && norms.buffer.Length != verts.buffer.Length) ||
(tans != null && tans.buffer.Length != verts.buffer.Length);
mTriangles = (verts.size >> 1);
if (trim || verts.buffer.Length > 65000)
{
if (trim || mMesh.vertexCount != verts.size)
{
mMesh.Clear();
setIndices = true;
}
mMesh.vertices = verts.ToArray();
mMesh.uv = uvs.ToArray();
mMesh.colors32 = cols.ToArray();
if (norms != null)
{
mMesh.normals = norms.ToArray();
}
if (tans != null)
{
mMesh.tangents = tans.ToArray();
}
}
else
{
if (mMesh.vertexCount != verts.buffer.Length)
{
mMesh.Clear();
setIndices = true;
}
mMesh.vertices = verts.buffer;
mMesh.uv = uvs.buffer;
mMesh.colors32 = cols.buffer;
if (norms != null)
{
mMesh.normals = norms.buffer;
}
if (tans != null)
{
mMesh.tangents = tans.buffer;
}
}
#else
mTriangles = (verts.size >> 1);
if (mMesh.vertexCount != verts.size)
{
mMesh.Clear();
setIndices = true;
}
mMesh.vertices = verts.ToArray();
mMesh.uv = uvs.ToArray();
mMesh.colors32 = cols.ToArray();
if (norms != null)
{
mMesh.normals = norms.ToArray();
}
if (tans != null)
{
mMesh.tangents = tans.ToArray();
}
#endif
if (setIndices)
{
mIndices = GenerateCachedIndexBuffer(count, indexCount);
mMesh.triangles = mIndices;
}
if (!alwaysOnScreen)
{
mMesh.RecalculateBounds();
}
mFilter.mesh = mMesh;
}
else
{
mTriangles = 0;
if (mFilter.mesh != null)
{
mFilter.mesh.Clear();
}
Debug.LogError("Too many vertices on one panel: " + verts.size);
}
if (mRenderer == null)
{
mRenderer = gameObject.GetComponent <MeshRenderer>();
}
if (mRenderer == null)
{
mRenderer = gameObject.AddComponent <MeshRenderer>();
#if UNITY_EDITOR
mRenderer.enabled = isActive;
#endif
}
UpdateMaterials();
}
else
{
if (mFilter.mesh != null)
{
mFilter.mesh.Clear();
}
Debug.LogError("UIWidgets must fill the buffer with 4 vertices per quad. Found " + count);
}
}
public Job_BuildCollisionMesh(VoxelChunk Chunk, Mesh Target) : base(Chunk)
{
mTarget = Target;
}
private static extern Vector2[] INTERNAL_CALL_GeneratePerTriangleUVImpl(Mesh src, ref UnwrapParam settings);
void OnWizardCreate()
{
GameObject newCone = new GameObject("Cone");
if (openingAngle > 0 && openingAngle < 180)
{
radiusTop = 0;
radiusBottom = length * Mathf.Tan(openingAngle * Mathf.Deg2Rad / 2);
}
string meshName = newCone.name + numVertices + "v" + radiusTop + "t" + radiusBottom + "b" + length + "l" + length + (outside?"o":"") + (inside?"i":"");
string meshPrefabPath = "Assets/Editor/" + meshName + ".asset";
Mesh mesh = (Mesh)AssetDatabase.LoadAssetAtPath(meshPrefabPath, typeof(Mesh));
if (mesh == null)
{
mesh = new Mesh();
mesh.name = meshName;
// can't access Camera.current
//newCone.transform.position = Camera.current.transform.position + Camera.current.transform.forward * 5.0f;
int multiplier = (outside?1:0) + (inside?1:0);
int offset = (outside && inside?2 * numVertices:0);
Vector3[] vertices = new Vector3[2 * multiplier * numVertices]; // 0..n-1: top, n..2n-1: bottom
Vector3[] normals = new Vector3[2 * multiplier * numVertices];
Vector2[] uvs = new Vector2[2 * multiplier * numVertices];
int[] tris;
float slope = Mathf.Atan((radiusBottom - radiusTop) / length); // (rad difference)/height
float slopeSin = Mathf.Sin(slope);
float slopeCos = Mathf.Cos(slope);
int i;
for (i = 0; i < numVertices; i++)
{
float angle = 2 * Mathf.PI * i / numVertices;
float angleSin = Mathf.Sin(angle);
float angleCos = Mathf.Cos(angle);
float angleHalf = 2 * Mathf.PI * (i + 0.5f) / numVertices; // for degenerated normals at cone tips
float angleHalfSin = Mathf.Sin(angleHalf);
float angleHalfCos = Mathf.Cos(angleHalf);
vertices[i] = new Vector3(radiusTop * angleCos, radiusTop * angleSin, 0);
vertices[i + numVertices] = new Vector3(radiusBottom * angleCos, radiusBottom * angleSin, length);
if (radiusTop == 0)
{
normals[i] = new Vector3(angleHalfCos * slopeCos, angleHalfSin * slopeCos, -slopeSin);
}
else
{
normals[i] = new Vector3(angleCos * slopeCos, angleSin * slopeCos, -slopeSin);
}
if (radiusBottom == 0)
{
normals[i + numVertices] = new Vector3(angleHalfCos * slopeCos, angleHalfSin * slopeCos, -slopeSin);
}
else
{
normals[i + numVertices] = new Vector3(angleCos * slopeCos, angleSin * slopeCos, -slopeSin);
}
uvs[i] = new Vector2(1.0f * i / numVertices, 1);
uvs[i + numVertices] = new Vector2(1.0f * i / numVertices, 0);
if (outside && inside)
{
// vertices and uvs are identical on inside and outside, so just copy
vertices[i + 2 * numVertices] = vertices[i];
vertices[i + 3 * numVertices] = vertices[i + numVertices];
uvs[i + 2 * numVertices] = uvs[i];
uvs[i + 3 * numVertices] = uvs[i + numVertices];
}
if (inside)
{
// invert normals
normals[i + offset] = -normals[i];
normals[i + numVertices + offset] = -normals[i + numVertices];
}
}
mesh.vertices = vertices;
mesh.normals = normals;
mesh.uv = uvs;
// create triangles
// here we need to take care of point order, depending on inside and outside
int cnt = 0;
if (radiusTop == 0)
{
// top cone
tris = new int[numVertices * 3 * multiplier];
if (outside)
{
for (i = 0; i < numVertices; i++)
{
tris[cnt++] = i + numVertices;
tris[cnt++] = i;
if (i == numVertices - 1)
{
tris[cnt++] = numVertices;
}
else
{
tris[cnt++] = i + 1 + numVertices;
}
}
}
if (inside)
{
for (i = offset; i < numVertices + offset; i++)
{
tris[cnt++] = i;
tris[cnt++] = i + numVertices;
if (i == numVertices - 1 + offset)
{
tris[cnt++] = numVertices + offset;
}
else
{
tris[cnt++] = i + 1 + numVertices;
}
}
}
}
else if (radiusBottom == 0)
{
// bottom cone
tris = new int[numVertices * 3 * multiplier];
if (outside)
{
for (i = 0; i < numVertices; i++)
{
tris[cnt++] = i;
if (i == numVertices - 1)
{
tris[cnt++] = 0;
}
else
{
tris[cnt++] = i + 1;
}
tris[cnt++] = i + numVertices;
}
}
if (inside)
{
for (i = offset; i < numVertices + offset; i++)
{
if (i == numVertices - 1 + offset)
{
tris[cnt++] = offset;
}
else
{
tris[cnt++] = i + 1;
}
tris[cnt++] = i;
tris[cnt++] = i + numVertices;
}
}
}
else
{
// truncated cone
tris = new int[numVertices * 6 * multiplier];
if (outside)
{
for (i = 0; i < numVertices; i++)
{
int ip1 = i + 1;
if (ip1 == numVertices)
{
ip1 = 0;
}
tris[cnt++] = i;
tris[cnt++] = ip1;
tris[cnt++] = i + numVertices;
tris[cnt++] = ip1 + numVertices;
tris[cnt++] = i + numVertices;
tris[cnt++] = ip1;
}
}
if (inside)
{
for (i = offset; i < numVertices + offset; i++)
{
int ip1 = i + 1;
if (ip1 == numVertices + offset)
{
ip1 = offset;
}
tris[cnt++] = ip1;
tris[cnt++] = i;
tris[cnt++] = i + numVertices;
tris[cnt++] = i + numVertices;
tris[cnt++] = ip1 + numVertices;
tris[cnt++] = ip1;
}
}
}
mesh.triangles = tris;
AssetDatabase.CreateAsset(mesh, meshPrefabPath);
AssetDatabase.SaveAssets();
}
MeshFilter mf = newCone.AddComponent <MeshFilter>();
mf.mesh = mesh;
newCone.AddComponent <MeshRenderer>();
if (addCollider)
{
MeshCollider mc = newCone.AddComponent <MeshCollider>();
mc.sharedMesh = mf.sharedMesh;
}
Selection.activeObject = newCone;
}
public static Vector2[] GeneratePerTriangleUV(Mesh src, UnwrapParam settings)
{
return(Unwrapping.GeneratePerTriangleUVImpl(src, settings));
}