Hi i am trying to draw a spiral galaxy without usage of point sprites, so far i was able to draw billboards, but in order to display galaxy properly i need to change their size in realtime, with glpointsprites i could just define where i want to put a sprite and set its maximum and minimum size (the whole sizing thing was automatic), like in this video.

Main problem is that i set point sprite size with pixels, and with billboards i use numbers.

So far i set a fixed size:

But it only looks good from this distance.

Anyway, i am now trying to write a sizing function for these billboards, where minimum size is 1 pixel (less than 100.0f dist from a billboard) and maximum is 35 pixels. (more than 3500.0f dist from a billboard)

BUT the problem is how do i calculate size of a billboard to a coressponding size in pixels?

I tried to do some perspective calculations but i am far from getting it done, any help?

and pls dont ask why i dont want to use point sprites, cuz i won't run my program on a different computer after every build, and mine (that i work on) does not support such thing. Oh and i cant use shaders aswell.

But maybe my GL_POINT_SPRITE implementation lacks of something since my cards supports them but i cant make these point textured.

i am very very pleased, however i dont quite understand this maybe i am a lil bit drunk (ok i am) but could you describe 'so, to get the pointsize we transform (size, size, Z, W) with the projection matrix' and this second code, it looks like a fragment shader, i am not aware of multiplying a matrix with 4d point.

I have few questions:

First of all will vector * matrix will look similar to this? :

where right [] is my vector ;]

second thing is about your code:

vec4 position = matview * vec4(in_vertex.xyz, 1.0);
vec4 projsize = matproj * vec4(size, size, position.zw); <- whats this size?
gl_PointSize = size * screensize.x / projsize.x;

maybe i didnt precise my needs: i have a billboard and i must make it to be 32 pixels big when i am 3500 units away from it. ;]

I believe i found a solution, had to use pencil and ruler ;]

take a look at this there will be an explanation under it:

So we have a viewport, we know how far a particle is from our camera.

we also know FOV, and we know what screen_width we have (the opengl window width in pixels ;])

so now ze math: we calculate C from distance_particle_camera / (cosine of FOV/2)

then we calculate a from C*C - distance_particle_camera*distance_particle_camera

now we know that 2*a is related to our screen_width (that opengl window - in pixels)

as we know what size in pixels should particle be (depending on the distance from camera) we can calculate:

x = (dest_particle_size_in_pixels / screen_width_in_pixels) and then

2*a*x is our numeric particle width, tommorow i will check it ;f

yep it works, however i have another question:

On what distance particles go to their max size?

the code looks like this:

 float sizeFromDistance(float dist,float maxsize)
 {

  if (dist >= 8000.0f) return maxsize;

 return      (dist / 8000.0f) * maxsize;

//  return 1.0f;
 }



elsefunc()
{
sizecoeff = cos(45.0f*imopi);  where 45.0f is FOV /2.0f and const float imopi           = 0.017453292519943295769236907684886;   //PI / 180

float dst = n3ddistance(particlepos, campos); // just a distance between 2 points
	float C = 	dst / sizecoeff;
	float x = sizeFromDistance(dst,35.0f) / 1024.0f; //where 1024 is my screen width in pixels
	float a = C*C - dst*dst;
	a = sqrt(a);
	float pointsize = 2.0f*a*x;


}