Make a sphere with equidistant vertices

Question

I'm trying to make a spherical burst of rays for the purpose of checking collision, but having specific interactions happen based upon what or where each ray hit. Hence why I'm using rays rather then something simpler such as OverlapSphere.

The reason I'm looking for how to make a sphere is because I can use the same math for my rays, by having them go to the vertices of where the sphere would be. But every way I can find for making a sphere has the lines get closer the near to the poles, which makes sense, as its pretty easy to do. But as you can imagine, its not that useful for my current project.

TL;DR: How do I make a sphere with equidistant vertices? If its not perfectly equidistant its fine, it just needs to pretty close. If this happens, it would be great if you could give how much the difference would be, and where, if applicable.

Extra notes: I've looked at this and this, but the math is way over my head, so what I've been looking for might've just been staring me in the face this whole time.

Answer 1

You could use an icosphere. As the vertices are distributed on equilateral triangles, your vertices are guaranteed to be equidistant.

To construct the icosphere, first you make an icosahedron and then split the faces recursively in smaller triangles as explained in this article.

Answer 2

Are you aware that the sphere given to you by Unity is in fact designed

with this exact goal in mind?

ie, the entire raison d'etre of the sphere built-in to Unity is that the points are fairly smoothly space ...... roughly equidistant, as you phrase it.

To bring up such a sphere in Unity, just do this:

You can then instantly get access to the verts, as you know

Mesh mesh = GetComponent<MeshFilter>().mesh;
Vector3[] vv = mesh.vertices;
int kVerts=vv.Length
for (int i=0; i<kVerts; ++i)
  Debug.Log ... vv[i] 

Note you can easily check "which part of the sphere" they are on by (for example) checking how far they are from your "cities" (or whatever) or just check (for example) the z values to see which hemisphere they are in .. et cetera.

---

Furthermore...

Please note. Regarding your overall reason for wanting to do this:

but having specific interactions happen based upon what or where each ray hit

Note that it could not be easier to do this using PhysX. (The completely built-in game physics in Unity.) Indeed, I have never, ever, looked at a collision without doing something "specific" depending on "where it hit!"

You can for example get the point where the contact was with http://docs.unity3d.com/ScriptReference/RaycastHit-point.html

It's worth noting it is absolutely inconceivable one could write something approaching the performance of PhysX in casual programming.

I hope this makes things easier!

Answer 3

1. slice the sphere into N circles
2. compute perimeter of it
3. divide it by the same angle that create the slice
   • this gives you the number of vertexes
   • and also angle step inside circle
4. cast rays

This is how I coded it in C++ + OpenGL:

// draw unit sphere points (r=1 center=(0,0,0)) ... your rays directions
int ia,na,ib,nb;
double x,y,z,r;
double a,b,da,db;
na=16;                                  // number of slices
da=M_PI/double(na-1);                   // latitude angle step
for (a=-0.5*M_PI,ia=0;ia<na;ia++,a+=da) // slice sphere to circles in xy planes
    {
    r=cos(a);                           // radius of actual circle in xy plane
    z=sin(a);                           // height of actual circle in xy plane
    nb=ceil(2.0*M_PI*r/da);
    db=2.0*M_PI/double(nb);             // longitude angle step
    if ((ia==0)||(ia==na-1)) { nb=1; db=0.0; }  // handle edge cases
    for (b=0.0,ib=0;ib<nb;ib++,b+=db)   // cut circle to vertexes
        {
        x=r*cos(b);                     // compute x,y of vertex
        y=r*sin(b);
        // this just draw the ray direction (x,y,z) as line in OpenGL
        // so you can ignore this
        // instead add the ray cast of yours
        double w=1.2;
        glBegin(GL_LINES);
        glColor3f(1.0,1.0,1.0); glVertex3d(x,y,z);
        glColor3f(0.0,0.0,0.0); glVertex3d(w*x,w*y,w*z);
        glEnd();
        }
    }

This is how it looks like:

• R,G,B lines are the sphere coordinate system axises X,Y,Z
• White-ish lines are your Vertexes (White) + direction (Gray)

[Notes]

• do not forget to include math.h
• and replace the OpenGL stuff with yours

Answer 4

If you want 4, 6, 8, 12 or 20 vertices then you can have exactly equidistant vertices as the Platonic solid which all fit inside a sphere. The actual coordinates of these should be easy to get. For other numbers of vertices you can use other polyhedra and scale the verties so they lie on a sphere. If you need lots of points then a geodesic dome might be a good base. The C60 bucky-ball could be a good base with 60 points. For most of these you should be able to find 3D models from which you can extract coordinates.

Answer 5

I think the easiest way to control points on a sphere is by using spherical coordinates. Then you can control position of points around the sphere by using two angles (rho and phi) and the radius.

Example code for filling points uniformly around a rotating sphere (for fun):

var time = 1; // Increment this variable every frame to see the rotation
var count = 1000;
for (int i = 0; i < count; i++)
{
    var rho = time + i; 
    var phi = 2 * Math.PI * i / count;
    var x = (float)(radius * Math.Sin(phi) * Math.Cos(rho));
    var z = (float)(radius * Math.Sin(phi) * Math.Sin(rho));
    var y = (float)(radius * Math.Cos(phi));
    Draw(x, y, z); // your drawing code for rendering the point
}

Answer 6

As some answers have already suggested, use an icosahedron based solution. The source for this is quite easy to come by (and I have written my own several times) but I find the excellent Primitives Pro plugin extremely handy under many other circumstances, and always use their sphere instead of the built-in Unity one.

Link to Primitives Pro component

Primitives Pro options