Star Field - Lots Of Poly or Transparent Texture

[Nidre]

I am developing a space game which will work on Android and iOS devices.We are tying to target as much as devices as we can.While developing it i have faced a simple problem.I have to make decision but since i couldnt test on many devices i dont have a spesific idea that i can accept as correct way on my own. So what im asking is a little bit explanation about which method from the below could be better and why ?

Scenerio:

There will be a 2d low vert simple plane which contains space texture.
I need to add stars with a different y position to have a feeling of depth.
(I’m using a perspective camera to have this feeling.They look like they are moving in different speeds due to distance)

1st option : adding a stars texture on top of the space texture with a different plane and alpha blend them.That would cause a lot of fillrate due to lots of transparent areas.

2nd option : I would add little meshes in the shape of stars with very less or no transparent.That would mean a single mesh for each star and a lot of polys/verts.

3rd option : Im glad to hear any option of yours

[whydoidoit]

Sure - you make a single mesh - but it’s going to contain a whole lot of sets of billboards, one for each star (this is what dynamic batching / static batching is doing for you BTW, but it has limits).

BTW this is very similar to the legacy particle system’s renderer - which is why I thought that was a good idea!

If the stars are moving then you will update these billboards (quad made of two triangles) each frame, you will certainly want to rotate them to face the opposite direction to the main camera’s forward vector).

Off the top of my head the step would be:

• Decide on the number of stars - maximum for one mesh would be around 16k
• Create a mesh object
• Create an array of Vector3s for the vertices
• Create an array of Vector2s for the uvs
• Create an array of ints for the triangles
• Create the initial points (can stick them all at 0,0,0) for now -
• map the UVs of the 4 points of each quad.
• Create the six triangle entries for each quad referring to the 4 vertices
• Update the mesh

From now on you just need to modify the vertices each frame. Keep the vertices array, update it and then set it back into the mesh each frame.

Then you need to move those vertices to the stars position in the game each frame and rotate them so that they face the negative of the Camera.main.transform.forward. Basically a star would have a position but not a rotation, you could store them in a List or a Vector3.

Now the hard part - make the quad face the camera at the right position. Your meshes renderer would be set at 0,0,0 and you would have set the bounds for the mesh to be really huge so that it always renders.

For each of your stars you would move the position of the vertices. Actually a simple way of doing that is have a dummy object that you:

  dummyTransform.forward = -Camera.main.transform.forward;

Before your loop setup a vertexIndex to 0 - then for each star:

 dummyTransform.position = startPosition;

And then update the 4 vertices:

             points[vertexIndex++] =  dummyTransform.TransformPoint(topLeft); 
	/* Top R 1 */ points[vertexIndex++] =  dummyTransform.TransformPoint(topRight); 
	/* Bot L 2 */ points[vertexIndex++] =  dummyTransform.TransformPoint(bottomLeft); 
	/* Bot R 3 */ points[vertexIndex++] =  dummyTransform.TransformPoint(bottomRight);