Merge branch 'dev'

src/lephisto.c

@@ -561,7 +561,7 @@ static void render_all(void) {
   player_render();
   spfx_render(SPFX_LAYER_FRONT);
   space_renderOverlay(dt);
-  player_renderGUI();
+  player_renderGUI(dt);
   display_fps(dt); /* Exception. */
 }
 

src/perlin.c

@@ -323,6 +323,60 @@ void noise_delete(perlin_data_t* noise) {
   free(noise);
 }
 
+/**
+ * @brief Generate radar inteference.
+ *    @param w Width to generate.
+ *    @param h Height to generate.
+ *    @param rug Rugosity of the interference.
+ *    @return The map generated.
+ */
+float* noise_genRadarInt(const int w, const int h, float rug) {
+  int x, y;
+  float f[2];
+  int octaves;
+  float hurst;
+  float lacunarity;
+  perlin_data_t* noise;
+  float* map;
+  float value;
+
+  /* Pretty default values. */
+  octaves = 3;
+  hurst = NOISE_DEFAULT_HURST;
+  lacunarity = NOISE_DEFAULT_LACUNARITY;
+
+  /* Create noise and data. */
+  noise = noise_new(2, hurst, lacunarity);
+  map = malloc(sizeof(float)*w*h);
+  if(map == NULL) {
+    WARN("Out of memory!");
+    return NULL;
+  }
+
+  /* Start to create the nebulae. */
+  for(y = 0; y < h; y++) {
+
+    f[1] = rug * (float)y / (float)h;
+    for(x = 0; x < w; x++) {
+      
+      f[0] = rug * (float)x / (float)w;
+
+      /* Get the 2d noise. */
+      value = noise_get2(noise, f);
+
+      /* Set the value to [0, 1]. */
+      map[y*w + x] = (value + 1.) / 2.;
+    }
+  }
+
+  /* Clean up. */
+  noise_delete(noise);
+
+  /* Results. */
+  return map;
+
+}
+
 /**
  * @brief Generate a 3d nebulae map.
  *    @param w Width of the map.

src/perlin.h

@@ -1,6 +1,7 @@
 #pragma once
 #include "opengl.h"
 
+float* nouse_genRadarInt(const int w, const int h, float rug);
 float* noise_genNebulaeMap(const int w, const int h, const int n, float rug);
 float* noise_genNebulaePuffMap(const int w, const int h, float rug);
 

src/player.c

@@ -32,6 +32,7 @@
 #include "unidiff.h"
 #include "comm.h"
 #include "intro.h"
+#include "perlin.h"
 #include "player.h"
 
 #define XML_GUI_ID    "GUIs"    /**< XML section identifier for GUI document. */
@@ -51,6 +52,9 @@
 #define PLAYER_ENGINE_CHANNEL    9    /**< Player channel for engine noises. */
 #define PLAYER_GUI_CHANNEL       9    /**< Player channel. */
 
+#define INTERFERENCE_LAYERS      16   /**< Number of interference layers. */
+#define INTERFERENCE_CHANGE_DT   0.1  /**< Speed to change at. */
+
 /* Player stuff. */
 Pilot* player = NULL;                   /**< The player. */
 static Ship* player_ship = NULL;        /**< Temp ship to hold when naming it. */
@@ -90,6 +94,10 @@ int hyperspace_target = -1;             /**< Target hyperspace route. -1 is none
 /* For death etc. */
 static unsigned int player_timer = 0;   /**< For death and such. */
 static Vec2 player_cam;                 /**< Again, for death etc. */
+/* For interference. */
+static int interference_layer    = 5;   /**< Layer of the current interference. */
+static double interference_alpha = 0.;  /**< Alpha of the current interference layer. */
+static double interference_t     = 0.;  /**< Interference timer to control transitions. */
 
 static int* missions_done = NULL; /**< Saves position of completed missions. */
 static int  missions_mdone = 0;   /**< Memory size of completed missions. */
@@ -117,6 +125,7 @@ typedef struct Radar_ {
   double h;           /**< Height. */
   RadarShape shape;   /**< Shape. */
   double res;         /**< Resolution. */
+  glTexture* interference[INTERFERENCE_LAYERS]; /**< Interference texture. */
 } Radar;
 
 /* Radar res. */
@@ -218,14 +227,17 @@ static void player_newShipMake(char* name);
 /* Sound. */
 static void player_initSound(void);
 /* Gui. */
+static void gui_createInterference(void);
 static void rect_parseParam(const xmlNodePtr parent, char* name, double* param);
 static void rect_parse(const xmlNodePtr parent,
                        double* x, double* y, double* w, double* h);
 static int gui_parse(const xmlNodePtr parent, const char* name);
+static void gui_cleanup(void);
+/* Render GUI. */
 static void gui_renderPilot(const Pilot* p);
 static void gui_renderHealth(const glColour* c, const Rect* r,
     const glTexture* tex, const double w);
-static void gui_cleanup(void);
+static void gui_renderInterference(double dt);
 /* Save/Load. */
 static int player_saveShip(xmlTextWriterPtr writer, Pilot* ship, char* loc);
 static int player_parse(xmlNodePtr parent);
@@ -846,7 +858,6 @@ void player_renderBG(void) {
  *
  * @brief Render the player.
  */
-static int can_jump = 0; /**< Store whether or not the player is able to jump. */
 void player_render(void) {
   Pilot* p;
   glColour* c;
@@ -884,12 +895,11 @@ void player_render(void) {
   }
 }
 
+static int can_jump = 0; /**< Store whether or not the player is able to jump. */
 /**
- * @fn void player_renderGUI(void)
- *
  * @brief Render the players GUI.
  */
-void player_renderGUI(void) {
+void player_renderGUI(double dt) {
   int i, j;
   double x, y;
   char str[10];
@@ -947,16 +957,15 @@ void player_renderGUI(void) {
   planets_minimap(gui.radar.res, gui.radar.w, gui.radar.h, gui.radar.shape);
 
   /* Weapons. */
-  glBegin(GL_POINTS);
-  COLOUR(cRadar_weap);
   weapon_minimap(gui.radar.res, gui.radar.w, gui.radar.h, gui.radar.shape);
-  glEnd();
 
-  /* Render the pilots. */
+  /* Render the pilot_nstack. */
-  for(j = 0, i = 1; i < pilot_nstack; i++) {
+  j = 0;
-    /* Skip the player. */
+  for(i = 1; i < pilot_nstack; i++) { /* Skip the player. */
-    if(pilot_stack[i]->id == player->target) j = i;
+    if(pilot_stack[i]->id == player->target)
-    else gui_renderPilot(pilot_stack[i]);
+      j = i;
+    else
+      gui_renderPilot(pilot_stack[i]);
   }
   /* Render the targetted pilot. */
   if(j != 0) gui_renderPilot(pilot_stack[j]);
@@ -972,6 +981,9 @@ void player_renderGUI(void) {
 
   glPopMatrix(); /* GL_PROJECTION. */
 
+  /* Interference. */
+  gui_renderInterference(dt);
+
   /* Nav. */
   if(planet_target >= 0) {
     /* Planet landing target. */
@@ -1187,6 +1199,45 @@ void player_renderGUI(void) {
   }
 }
 
+/**
+ * @brief Render interference if needed.
+ *    @param dt Current deltatick.
+ */
+static void gui_renderInterference(double dt) {
+  glColour c;
+  glTexture* tex;
+  int t;
+
+  /* Must be displaying inteference. */
+  if(interference_alpha <= 0.)
+    return;
+
+  /* Calculate frame to draw. */
+  interference_t += dt;
+  if(interference_t > INTERFERENCE_CHANGE_DT) { /* Time to change. */
+    t = RNG(0, INTERFERENCE_LAYERS-1);
+    if(t != interference_layer)
+      interference_layer = t;
+    else
+      interference_layer = (interference_layer == INTERFERENCE_LAYERS-1) ?
+        0 : interference_layer+1;
+    interference_t -= INTERFERENCE_CHANGE_DT;
+  }
+
+  /* Render the interference. */
+  c.r = c.g = c.b = 1.;
+  c.a = interference_alpha;
+  tex = gui.radar.interference[interference_layer];
+  if(gui.radar.shape == RADAR_CIRCLE)
+    gl_blitStatic(tex,
+        gui.radar.x - gui.radar.w,
+        gui.radar.y - gui.radar.w, &c);
+  else if(gui.radar.shape == RADAR_RECT)
+    gl_blitStatic(tex,
+        gui.radar.x - gui.radar.w / 2,
+        gui.radar.y - gui.radar.h/2, &c);
+}
+
 /* Renders a pilot. */
 static void gui_renderPilot(const Pilot* p) {
   int x, y, sx, sy;
@@ -1427,9 +1478,86 @@ static void rect_parse(const xmlNodePtr parent,
   rect_parseParam(parent, "y", y);
 }
 
+/**
+ * @brief Create the interference map for the current gui.
+ */
+static void gui_createInterference(void) {
+  uint8_t raw;
+  int i, j, k;
+  float* map;
+  uint32_t* pix;
+  SDL_Surface* sur;
+  int w, h, hw, hh;
+  float c;
+  int r;
+
+  /* Dimension shortcuts. */
+  if(gui.radar.shape == RADAR_CIRCLE) {
+    w = gui.radar.w*2.;
+    h = w;
+  }
+  else if(gui.radar.shape == RADAR_RECT) {
+    w = gui.radar.w;
+    h = gui.radar.h;
+  }
+
+  for(k = 0; k < INTERFERENCE_LAYERS; k++) {
+    /* Free the old texture. */
+    if(gui.radar.interference[k] != NULL)
+      gl_freeTexture(gui.radar.interference[k]);
+
+    /* Create the temp surface. */
+    sur = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 32, RGBAMASK);
+    pix = sur->pixels;
+
+    /* Load the interference map. */
+    map = noise_genRadarInt(w, h, 100.);
+
+    /* Create the texture. */
+    SDL_LockSurface(sur);
+    if(gui.radar.shape == RADAR_CIRCLE) {
+      r = pow2((int)gui.radar.w);
+      hw = w/2;
+      hh = h/2;
+      for(i = 0; i < h; i++) {
+        for(j = 0; j < w; j++) {
+          /* Must be in circle. */
+          if(pow2(i-hh) + pow2(j-hw) > r)
+            continue;
+          c = map[i*w + j];
+          raw = 0xff & (uint8_t)((float)0xff * c);
+          memset(&pix[i*w + j], raw, sizeof(uint32_t));
+          pix[i*w + j] |= AMASK;
+        }
+      }
+    }
+    else if(gui.radar.shape == RADAR_RECT) {
+      for(i = 0; i < h*w; i++) {
+        /* Process pixels. */
+        c = map[i];
+        raw = 0xff & (uint8_t)((float)0xff * c);
+        memset(&pix[i], raw, sizeof(uint32_t));
+        pix[i] |= AMASK;
+      }    
+    }
+    SDL_UnlockSurface(sur);
+
+    /* Set the interference. */
+    gui.radar.interference[k] = gl_loadImage(sur);
+
+    /* Clean up. */
+    free(map);
+  }
+}
+
 /* Parse a gui node. */
 #define RELATIVIZE(a) \
 { (a).x += VX(gui.frame); (a).y = VY(gui.frame) + gui.gfx_frame->h-(a).y; }
+/**
+ * @brief Parses a gui node.
+ *    @param Parent node to parse from.
+ *    @param name Name of the GUI to load.
+ */
 static int gui_parse(const xmlNodePtr parent, const char* name) {
   xmlNodePtr cur, node;
   char* tmp, buf[PATH_MAX];
@@ -1582,7 +1710,10 @@ static int gui_parse(const xmlNodePtr parent, const char* name) {
       rect_parse(node, &gui.misc.x, &gui.misc.y, &gui.misc.w, &gui.misc.h);
       RELATIVIZE(gui.misc);
     }
-  } while((node = node->next));
+  } while(xml_nextNode(node));
+
+  /* Some postprocessing. */
+  gui_createInterference();
 
   return 0;
 }
@@ -1592,6 +1723,8 @@ static int gui_parse(const xmlNodePtr parent, const char* name) {
  * @brief Clean up the GUI.
  */
 static void gui_cleanup(void) {
+  int i;
+
   /* Free textures. */
   if(gui.gfx_frame != NULL) {
     gl_freeTexture(gui.gfx_frame);
@@ -1622,6 +1755,13 @@ static void gui_cleanup(void) {
     gl_freeTexture(gui.gfx_fuel);
     gui.gfx_fuel = NULL;
   }
+
+  for(i = 0; i < INTERFERENCE_LAYERS; i++) {
+    if(gui.radar.interference[i] != NULL) {
+      gl_freeTexture(gui.radar.interference[i]);
+      gui.radar.interference[i] = NULL;
+    }
+  }
 }
 
 /**

src/player.h

@@ -44,7 +44,7 @@ int gui_init(void);
 void gui_free(void);
 void player_render(void);
 void player_renderBG(void);   /* Render BG layer. */
-void player_renderGUI(void);  /* Render the GUI stuff. */
+void player_renderGUI(double dt);  /* Render the GUI stuff. */
 
 /* Misc. */
 void player_message(const char* fmt, ...);

src/space.c

@@ -103,7 +103,7 @@ int space_sysLoad(xmlNodePtr parent);
 /* Draw the planet. Used in planet.c */
 /* Matrix mode is already displaced to center of the minimap. */
 #define PIXEL(x,y)  if((shape == RADAR_RECT && ABS(x)<w/2. && ABS(y)<h/2.) || \
-  (shape == RADAR_CIRCLE && (((x)*(x)+(y)*(y)) < rc))) glVertex2i((x),(y))
+  (shape == RADAR_CIRCLE && (((x)*(x)+(y)*(y)) <= rc))) glVertex2i((x),(y))
 void planets_minimap(const double res, const double w,
     const double h, const RadarShape shape) {
   int i;

src/weapon.c

@@ -119,15 +119,21 @@ void weapon_minimap(const double res, const double w,
  */
 #define PIXEL(x,y) \
   if((shape == RADAR_RECT && ABS(x) < w/2. && ABS(y)<h/2.) || \
-  (shape == RADAR_CIRCLE && (((x)*(x)+(y)*(y))<rc))) \
+    (shape == RADAR_CIRCLE && (((x)*(x)+(y)*(y)) <= rc))) \
-  glVertex2i((x),(y)) /**< Set a pixel if within range. */
+    glVertex2i((x),(y)) /**< Set a pixel if within range. */
 void weapon_minimap(const double res, const double w,
     const double h, const RadarShape shape) {
   int i, rc;
   double x, y;
 
-  if(shape == RADAR_CIRCLE) rc = (int)(w*w);
+  /* Begin the points. */
+  glBegin(GL_POINTS);
+  COLOUR(cRadar_weap);
 
+  if(shape == RADAR_CIRCLE)
+    rc = (int)(w*w);
+
+  /* Draw the points for the weapons on all layers. */
   for(i = 0; i < nwbackLayer; i++) {
     x = (wbackLayer[i]->solid->pos.x - player->solid->pos.x) / res;
     y = (wbackLayer[i]->solid->pos.y - player->solid->pos.y) / res;
@@ -139,6 +145,9 @@ void weapon_minimap(const double res, const double w,
     y = (wfrontLayer[i]->solid->pos.y - player->solid->pos.y) / res;
     PIXEL(x,y);
   }
+
+  /* End the points. */
+  glEnd();
 }
 #undef PIXEL