OVR: Make interstellar stars appear infinitely away

[mercenary-reloaded.git] / src / mercenary / render.c

diff --git a/src/mercenary/render.c b/src/mercenary/render.c
index 7e1226d..4e8b98e 100644 (file)
--- a/src/mercenary/render.c
+++ b/src/mercenary/render.c
@@ -2133,7 +2133,7 @@ void render_one_item(render_item_t *render_item, int vr)
                double circle_x[PLANET_VERTICES], circle_y[PLANET_VERTICES], circle_z[PLANET_VERTICES];
                double crescent_x[PLANET_VERTICES], crescent_y[PLANET_VERTICES], crescent_z[PLANET_VERTICES];
                double x[PLANET_VERTICES], y[PLANET_VERTICES], z[PLANET_VERTICES];
-               double size, angle, fabs_angle, crescent;
+               double dist, size, angle, fabs_angle, crescent;
                double _sin, _cos;
                int i;
                int rc;
@@ -2158,6 +2158,9 @@ void render_one_item(render_item_t *render_item, int vr)
                rotate_coordinate(roll, pitch, yaw, &sun_x, &sun_y, &sun_z);
                rotate_coordinate(roll, pitch, yaw, &loc_x, &loc_y, &loc_z);
 
+               /* distance to planet */
+               dist = sqrt(loc_x * loc_x + loc_y * loc_y + loc_z * loc_z);
+
                /* calculate direction of the sun */
                angle_sun_h = atan2(sun_x, sun_z);
                angle_loc_h = atan2(loc_x, loc_z);
@@ -2213,9 +2216,9 @@ void render_one_item(render_item_t *render_item, int vr)
                        }
                }
                for (i = 0; i < PLANET_VERTICES; i++) {
-                       x[i] = loc_x + circle_x[i];
-                       y[i] = loc_y + circle_y[i];
-                       z[i] = loc_z + circle_z[i];
+                       x[i] = (loc_x + circle_x[i]) / dist * 1000000.0;
+                       y[i] = (loc_y + circle_y[i]) / dist * 1000000.0;
+                       z[i] = (loc_z + circle_z[i]) / dist * 1000000.0;
                }
                opengl_render_polygon_and_line(x, y, z, PLANET_VERTICES); /* no culling, its a planet! */
 
@@ -2237,27 +2240,27 @@ void render_one_item(render_item_t *render_item, int vr)
                if (angle > M_PI / 2.0 || (angle < 0.0 && angle > -M_PI / 2.0)) {
                        /* to the right */
                        for (i = 0; i < PLANET_VERTICES / 2 + 1; i++) {
-                               x[i] = loc_x + circle_x[i];
-                               y[i] = loc_y + circle_y[i];
-                               z[i] = loc_z + circle_z[i];
+                               x[i] = (loc_x + circle_x[i]) / dist * 1000000.0;
+                               y[i] = (loc_y + circle_y[i]) / dist * 1000000.0;
+                               z[i] = (loc_z + circle_z[i]) / dist * 1000000.0;
                        }
                        _sin = sin((1.0 - angle / (M_PI / 2)) * (M_PI / 2.0));
                        for (; i < PLANET_VERTICES; i++) {
-                               x[i] = loc_x + crescent_x[i];
-                               y[i] = loc_y + crescent_y[i];
-                               z[i] = loc_z + crescent_z[i];
+                               x[i] = (loc_x + crescent_x[i]) / dist * 1000000.0;
+                               y[i] = (loc_y + crescent_y[i]) / dist * 1000000.0;
+                               z[i] = (loc_z + crescent_z[i]) / dist * 1000000.0;
                        }
                } else {
                        /* to the left */
                        for (i = 0; i < PLANET_VERTICES / 2 + 1; i++) {
-                               x[i] = loc_x + crescent_x[i];
-                               y[i] = loc_y + crescent_y[i];
-                               z[i] = loc_z + crescent_z[i];
+                               x[i] = (loc_x + crescent_x[i]) / dist * 1000000.0;
+                               y[i] = (loc_y + crescent_y[i]) / dist * 1000000.0;
+                               z[i] = (loc_z + crescent_z[i]) / dist * 1000000.0;
                        }
                        for (; i < PLANET_VERTICES; i++) {
-                               x[i] = loc_x + circle_x[i];
-                               y[i] = loc_y + circle_y[i];
-                               z[i] = loc_z + circle_z[i];
+                               x[i] = (loc_x + circle_x[i]) / dist * 1000000.0;
+                               y[i] = (loc_y + circle_y[i]) / dist * 1000000.0;
+                               z[i] = (loc_z + circle_z[i]) / dist * 1000000.0;
                        }
                }
                opengl_render_polygon_and_line(x, y, z, PLANET_VERTICES); /* no culling, its a planet! */
@@ -2419,7 +2422,7 @@ void render_one_item(render_item_t *render_item, int vr)
                        gamecolor2gl(&red, &green, &blue, color[render_item->u.interstars.color[i]]);
                        opengl_render_color(red, green, blue, debug_opacity);
                        /* render point */
-                       opengl_render_point(160.0 - (double)render_item->u.interstars.x[i], 68.0 - (double)render_item->u.interstars.y[i], z, 0.0);
+                       opengl_render_point((160.0 - (double)render_item->u.interstars.x[i]) * 100, (68.0 - (double)render_item->u.interstars.y[i]) * 100, z * 100, 0.0);
                }
                break;
        }
@@ -2563,9 +2566,6 @@ static render_item_t *interpolate_door(double inter)
 {
        static render_item_t interpolated;
        render_item_t *old_vertices = render_list_old, *new_vertices = render_list_new;
-       int nomatch_x_count = 0;
-       int nomatch_z_count = 0;
-       int nomatch_x[4], nomatch_z[4];
        int i, ii;
 
        /* find old and new vertices */
@@ -2578,51 +2578,29 @@ static render_item_t *interpolate_door(double inter)
        if (!old_vertices || !new_vertices)
                return NULL;
 
-       /* all verices must match except four */
+       memcpy(&interpolated, new_vertices, sizeof(interpolated));
        ii = MAX_INTERIOR_VERTEX >> 2;
        for (i = 0; i < ii; i++) {
+               /* vertex must exist in both frames */
                if (!old_vertices->u.vertices_interior.set[i] || !new_vertices->u.vertices_interior.set[i])
                        continue;
-               if (old_vertices->u.vertices_interior.x[i] != new_vertices->u.vertices_interior.x[i]) {
-                       if (nomatch_x_count == 4)
-                               return NULL;
-                       nomatch_x[nomatch_x_count++] = i;
-               }
+               /* all verices must not have be too far away */
+               if (fabs(old_vertices->u.vertices_interior.x[i] - new_vertices->u.vertices_interior.x[i]) > 100.0)
+                       return NULL;
+               if (fabs(old_vertices->u.vertices_interior.z[i] - new_vertices->u.vertices_interior.z[i]) > 100.0)
+                       return NULL;
+               /* interpolate */
+               interpolated.u.vertices_interior.x[i] =
+               (double)old_vertices->u.vertices_interior.x[i] * (1.0 - inter) +
+               (double)new_vertices->u.vertices_interior.x[i] * inter;
+               interpolated.u.vertices_interior.z[i] =
+               (double)old_vertices->u.vertices_interior.z[i] * (1.0 - inter) +
+               (double)new_vertices->u.vertices_interior.z[i] * inter;
        }
        for (i = 0; i < 4; i++) {
                if (old_vertices->u.vertices_interior.y[i] != new_vertices->u.vertices_interior.y[i])
                        return NULL;
        }
-       for (i = 0; i < ii; i++) {
-               if (!old_vertices->u.vertices_interior.set[i] || !new_vertices->u.vertices_interior.set[i])
-                       continue;
-               if (old_vertices->u.vertices_interior.z[i] != new_vertices->u.vertices_interior.z[i]) {
-                       if (nomatch_z_count == 4)
-                               return NULL;
-                       nomatch_z[nomatch_z_count++] = i;
-               }
-       }
-
-       /* copy, even if not interpolated */
-       memcpy(&interpolated, new_vertices, sizeof(interpolated));
-
-       /* only four x missmatch */
-       if (nomatch_x_count == 4 || nomatch_x_count == 2) {
-               for (i = 0; i < nomatch_x_count; i++) {
-                       interpolated.u.vertices_interior.x[nomatch_x[i]] =
-                       (double)old_vertices->u.vertices_interior.x[nomatch_x[i]] * (1.0 - inter) +
-                       (double)new_vertices->u.vertices_interior.x[nomatch_x[i]] * inter;
-               }
-       }
-
-       /* only four z missmatch */
-       if (nomatch_z_count == 4 || nomatch_z_count == 2) {
-               for (i = 0; i < nomatch_z_count; i++) {
-                       interpolated.u.vertices_interior.z[nomatch_z[i]] =
-                       (double)old_vertices->u.vertices_interior.z[nomatch_z[i]] * (1.0 - inter) +
-                       (double)new_vertices->u.vertices_interior.z[nomatch_z[i]] * inter;
-               }
-       }
 
        return &interpolated;
 }