Create Mesh that encapsulates two different sized spheres (perhaps a distorted cylinder?)

AdamBebko · April 7, 2016, 9:08pm

Hello, I’m relatively new to unity. I’m trying to create a new game object procedurally from a script .
I’m building objects from two separate spheres of differing size. I can Instantiate the spheres with no issues, but I don’t know how i can create a mesh that surrounds both. And I also don’t know how to combine the meshes into one.

Perhaps a diagram of what i’m trying to accomplish is warranted:

The above is the two spheres, and the below is the combined mesh I am looking for.

I’ve thought about using a cylinder that draws between each sphere’s centre, but then one end of the cylinder needs to be somehow made larger than the other to make the smooth connection. I’ve also thought about using a capsule and making one end larger than the other, but I don’t know how to do that either.

EDIT: I’m also eventually going to need to put a (capsule??) collider around the new mesh, so ideas on that would be great as well

Any ideas would be appreciated!
Adam

AdamBebko · April 8, 2016, 10:27pm

Well since no one answered I spent hours trying to come up with a solution myself and succeeded ! I still need to figure out how to get the meshes joined together and fix the collider, but the basic functionally is working now. Will update when I solve collider problem. I based my solution on the cone from http://wiki.unity3d.com/index.php/ProceduralPrimitives.

Hopefully this will help out someone else!

[67630-screen-shot-2016-04-08-at-60901-pm.png*_|67630]

[67631-screen-shot-2016-04-08-at-60911-pm.png*_|67631]

using UnityEngine;
using System.Collections;

public class DistrotedCylinder : MonoBehaviour {


	float height;
	float bottomRadius = 1;
	float topRadius = 1;
	public int nbSides = 18;

	public GameObject sphere1;
	public GameObject sphere2;


	void Awake () {
		CreateMesh ();
	}

	public void CreateMesh () {
		MeshFilter filter = GetComponent<MeshFilter>();
		Mesh mesh = filter.mesh;
		mesh.Clear();

		float scaleBottom = sphere1.transform.localScale.x;
		bottomRadius *= scaleBottom/2f;
		Debug.Log (bottomRadius.ToString ());

		float scaleTop = sphere2.transform.localScale.x;
		topRadius *= scaleTop/2f;
		Debug.Log (topRadius.ToString ());

		height = Vector3.Distance(sphere1.transform.localPosition, sphere2.transform.localPosition);
		Debug.Log (height.ToString ());


		float bottomPos = -height / 2;
		float topPos = height/2;

		Vector3 vectorBetweenSpheres = sphere2.transform.localPosition - sphere1.transform.localPosition;
		transform.localPosition = sphere1.transform.localPosition + (vectorBetweenSpheres) / 2;

		transform.rotation = Quaternion.FromToRotation(transform.up, vectorBetweenSpheres);
		Debug.Log(transform.rotation.eulerAngles.ToString());

		int nbVerticesCap = nbSides + 1;
		#region Vertices

		// bottom + top + sides
		Vector3[] vertices = new Vector3[nbVerticesCap + nbVerticesCap + nbSides * 2 + 2];
		int vert = 0;
		float _2pi = Mathf.PI * 2f;

		// Bottom cap
		vertices[vert++] = new Vector3(0f, bottomPos, 0f);
		while( vert <= nbSides )
		{
			float rad = (float)vert / nbSides * _2pi;
			vertices[vert] = new Vector3(Mathf.Cos(rad) * bottomRadius, bottomPos, Mathf.Sin(rad) * bottomRadius);
			vert++;
		}

		// Top cap
		vertices[vert++] = new Vector3(0f, topPos, 0f);
		while (vert <= nbSides * 2 + 1)
		{
			float rad = (float)(vert - nbSides - 1)  / nbSides * _2pi;
			vertices[vert] = new Vector3(Mathf.Cos(rad) * topRadius, topPos, Mathf.Sin(rad) * topRadius);
			vert++;
		}

		// Sides
		int v = 0;
		while (vert <= vertices.Length - 4 )
		{
			float rad = (float)v / nbSides * _2pi;
			vertices[vert] = new Vector3(Mathf.Cos(rad) * topRadius, topPos, Mathf.Sin(rad) * topRadius);
			vertices[vert + 1] = new Vector3(Mathf.Cos(rad) * bottomRadius, bottomPos, Mathf.Sin(rad) * bottomRadius);
			vert+=2;
			v++;
		}
		vertices[vert] = vertices[ nbSides * 2 + 2 ];
		vertices[vert + 1] = vertices[nbSides * 2 + 3 ];
		#endregion

		#region Normales

		// bottom + top + sides
		Vector3[] normales = new Vector3[vertices.Length];
		vert = 0;

		// Bottom cap
		while( vert  <= nbSides )
		{
			normales[vert++] = Vector3.down;
		}

		// Top cap
		while( vert <= nbSides * 2 + 1 )
		{
			normales[vert++] = Vector3.up;
		}

		// Sides
		v = 0;
		while (vert <= vertices.Length - 4 )
		{			
			float rad = (float)v / nbSides * _2pi;
			float cos = Mathf.Cos(rad);
			float sin = Mathf.Sin(rad);

			normales[vert] = new Vector3(cos, 0f, sin);
			normales[vert+1] = normales[vert];

			vert+=2;
			v++;
		}
		normales[vert] = normales[ nbSides * 2 + 2 ];
		normales[vert + 1] = normales[nbSides * 2 + 3 ];
		#endregion

		#region UVs
		Vector2[] uvs = new Vector2[vertices.Length];

		// Bottom cap
		int u = 0;
		uvs[u++] = new Vector2(0.5f, 0.5f);
		while (u <= nbSides)
		{
			float rad = (float)u / nbSides * _2pi;
			uvs = new Vector2(Mathf.Cos(rad) * .5f + .5f, Mathf.Sin(rad) * .5f + .5f);
		u++;
	}

	// Top cap
	uvs[u++] = new Vector2(0.5f, 0.5f);
	while (u <= nbSides * 2 + 1)
	{
		float rad = (float)u / nbSides * _2pi;
		uvs = new Vector2(Mathf.Cos(rad) * .5f + .5f, Mathf.Sin(rad) * .5f + .5f);
		u++;
	}

	// Sides
	int u_sides = 0;
	while (u <= uvs.Length - 4 )
	{
		float t = (float)u_sides / nbSides;
		uvs = new Vector3(t, 1f);
		uvs[u + 1] = new Vector3(t, 0f);
		u += 2;
		u_sides++;
	}
	uvs = new Vector2(1f, 1f);
	uvs[u + 1] = new Vector2(1f, 0f);
	#endregion 

	#region Triangles
	int nbTriangles = nbSides + nbSides + nbSides*2;
	int[] triangles = new int[nbTriangles * 3 + 3];

	// Bottom cap
	int tri = 0;
	int i = 0;
	while (tri < nbSides - 1)
	{
		triangles[ i ] = 0;
		triangles[ i+1 ] = tri + 1;
		triangles[ i+2 ] = tri + 2;
		tri++;
		i += 3;
	}
	triangles *= 0;*

```
 triangles[i + 1] = tri + 1;*
```
```
 triangles[i + 2] = 1;*
```
```
 tri++;*
```
```
 i += 3;*
```
```
 // Top cap*
```
```
 //tri++;*
```

_ while (tri < nbSides*2)_

```
 {*
```
```
 	triangles[ i ] = tri + 2;*
```
```
 	triangles[i + 1] = tri + 1;*
```
```
 	triangles[i + 2] = nbVerticesCap;*
```
```
 	tri++;*
```
```
 	i += 3;*
```
```
 }*
```

_ triangles = nbVerticesCap + 1;_
* triangles[i + 1] = tri + 1;*
* triangles[i + 2] = nbVerticesCap; *
* tri++;*
* i += 3;*
* tri++;*

* // Sides*
* while( tri <= nbTriangles )*
* {*
* triangles[ i ] = tri + 2;*
* triangles[ i+1 ] = tri + 1;*
* triangles[ i+2 ] = tri + 0;*
* tri++;*
* i += 3;*

* triangles[ i ] = tri + 1;*
* triangles[ i+1 ] = tri + 2;*
* triangles[ i+2 ] = tri + 0;*
* tri++;*
* i += 3;*
* }*
* #endregion*

* mesh.vertices = vertices;*
* mesh.normals = normales;*
* mesh.uv = uvs;*
* mesh.triangles = triangles;*

* mesh.RecalculateBounds();*
* mesh.Optimize();*
* }*
}

_*
_*