Rtch/Lephisto
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Change] Restructured a little to prepare for puffs of nebulae.

Browse Source
This commit is contained in:
Allanis 2013-07-22 15:53:09 +01:00
parent 1e7d19b2a6
commit 092b48651d
7 changed files with 199 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
src/lephisto.c
View File

@ -94,13 +94,13 @@ int main(int argc, char** argv) {
/* Initialize SDL for possible warnings. */
SDL_Init(0);
/* Input must be initialized for config to work. */
input_init();
/* Create the home directory if needed. */
if(lfile_dirMakeExist("."))
WARN("Unable to create lephisto directory '%s'", lfile_basePath());
/* Input must be initialized for config to work. */
input_init();
/* Set the configuration. */
snprintf(buf, PATH_MAX, "%s"CONF_FILE, lfile_basePath());
conf_setDefaults(); /* Default config values. */
@ -115,22 +115,6 @@ int main(int argc, char** argv) {
/* Random numbers. */
rng_init();
if(gl_init()) {
/* Initializes video output. */
ERR("Initializing video output failed, exiting...");
SDL_Quit();
exit(EXIT_FAILURE);
}
/* See if the data file is valid. */
if(pack_check(data)) {
ERR("Data file '%s' not found", DATA);
WARN("You can specify what data file you want to use with '-d'");
WARN("See -h or -- help for more infoamtion.");
SDL_Quit();
exit(EXIT_FAILURE);
}
/* OpenGL */
if(gl_init()) { /* Init video output. */
ERR("Initializing video output failed, exiting...");
@ -256,6 +240,7 @@ void unload_all(void) {
missions_free();
factions_free();
commodity_free();
var_cleanup(); /* Clean up mission variables. */
}
/**
@ -371,7 +356,7 @@ static void render_all(void) {
pilots_render();
weapons_render(WEAPON_LAYER_FG);
spfx_render(SPFX_LAYER_BACK);
space_renderOverlay();
space_renderOverlay(cur_dt);
/* FG. */
player_render();
spfx_render(SPFX_LAYER_FRONT);

131
src/nebulae.c
View File

@ -9,10 +9,13 @@
#include "lfile.h"
#include "rng.h"
#include "menu.h"
#include "player.h"
#include "perlin.h"
#define NEBULAE_Z 16 /* Z plane. */
#define NEBULAE_PATH "gen/nebu_%02d.png"
#define NEBULAE_PUFFS 32 /* Amount of puffs to generate. */
#define NEBULAE_PATH_BG "gen/nebu_bg_%dx%d_%02d.png"
#define NEBULAE_PATH_PUFF "gen/nebu_puff_%02d.png"
/* Extern. */
extern double gui_xoff, gui_yoff;
@ -32,8 +35,28 @@ static unsigned int last_render = 0;
static double nebu_view = 0.;
static double nebu_dt = 0.;
/* Puff textures. */
typedef struct NebulaePuffTex_ {
GLuint tex; /* Actualy texture. */
double w, h; /* Real dimensions. */
double pw, ph; /* Padding. */
} NebulaePuffTex;
static NebulaePuffTex nebu_pufftexs[NEBULAE_PUFFS];
/* Puff handling. */
typedef struct NebulaePuff_ {
double x, y; /* Position. */
double a, va; /* Alpha, alpha velocity. */
double height; /* Height vs player. */
NebulaePuffTex* tex; /* Texture. */
} NebulaePuff;
static NebulaePuff* nebu_puffs = NULL;
static int nebu_npuffs = 0;
static int nebu_checkCompat(const char* file);
static void nebu_loadTexture(SDL_Surface* sur, int w, int h, GLuint tex);
static void nebu_generate(void);
static void nebu_generatePuffs(void);
static void saveNebulae(float* map, const uint32_t w, const uint32_t h,
const char* file);
static SDL_Surface* loadNebulae(const char* file);
@ -55,10 +78,12 @@ void nebu_init(void) {
nebu_pw = gl_pot(nebu_w);
nebu_ph = gl_pot(nebu_h);
nebu_generatePuffs();
/* Load each, checking for compatibility and padding. */
glGenTextures(NEBULAE_Z, nebu_textures);
for(i = 0; i < NEBULAE_Z; i++) {
snprintf(nebu_file, PATH_MAX, NEBULAE_PATH, i);
snprintf(nebu_file, PATH_MAX, NEBULAE_PATH_BG, nebu_w, nebu_h, i);
if(nebu_checkCompat(nebu_file)) { /* Incompatable. */
LOG("No nebulae found, generating (this may take a while).");
@ -75,14 +100,28 @@ void nebu_init(void) {
WARN("Nebulae raw size doesn't match expected! (%dx%d instead of %dx%d)",
nebu_sur->w, nebu_sur->h, nebu_pw, nebu_ph);
/* Prepare to load into OpenGL. */
nebu_sur = gl_prepareSurface(nebu_sur);
if((nebu_sur->w != nebu_pw) || (nebu_sur->h != nebu_ph))
/* Load the textures. */
nebu_loadTexture(nebu_sur, nebu_pw, nebu_ph, nebu_textures[i]);
}
DEBUG("Loaded %d Nebulae Layers", NEBULAE_Z);
}
/* Load sur into tex, check for expected size of w and h. */
static void nebu_loadTexture(SDL_Surface* sur, int w, int h, GLuint tex) {
SDL_Surface* nebu_sur;
nebu_sur = gl_prepareSurface(sur);
if((w != 0) && (h != 0) &&
((nebu_sur->w != w) || (nebu_sur->h != h))) {
WARN("Nebulae size doesn't match expected! (%dx%d instead of %dx%d)",
nebu_sur->w, nebu_sur->h, nebu_pw, nebu_ph);
return;
}
/* Load the textures. */
glBindTexture(GL_TEXTURE_2D, nebu_textures[i]);
glBindTexture(GL_TEXTURE_2D, tex);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
@ -96,12 +135,14 @@ void nebu_init(void) {
gl_checkErr();
}
DEBUG("Loaded %d Nebulae Layers", NEBULAE_Z);
}
/* Clean up the nebu subsystem. */
void nebu_exit(void) {
int i;
glDeleteTextures(NEBULAE_Z, nebu_textures);
for(i = 0; i < NEBULAE_PUFFS; i++)
glDeleteTextures(1, &nebu_pufftexs[i].tex);
}
/* Render the nebulae. */
@ -209,16 +250,19 @@ void nebu_render(void) {
gl_checkErr();
}
void nebu_renderOverlay(void) {
void nebu_renderOverlay(const double dt) {
#define ANG45 0.70710678118654757
#define COS225 0.92387953251128674
#define SIN225 0.38268343236508978
glShadeModel(GL_SMOOTH);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glTranslated(gui_xoff+shake_pos.x, gui_yoff+shake_pos.y, 0.);
/* Stuff player partially sees. */
/* Render the puffs. */
nebu_renderPuffs(dt, 0);
/* Mask for area player can still see (partially). */
glShadeModel(GL_SMOOTH);
glBegin(GL_TRIANGLE_FAN);
ACOLOUR(cPurple, 0.);
glVertex2d(0., 0.);
@ -242,10 +286,10 @@ void nebu_renderOverlay(void) {
glVertex2d(-nebu_view, 0.);
glEnd(); /* GL_TRIANGLE_FAN */
/* Solid nebulae for areas the player can't see. */
glShadeModel(GL_FLAT);
ACOLOUR(cPurple, 1.);
/* Stuff player can't see. */
glBegin(GL_TRIANGLE_FAN);
/* Top left. */
glVertex2d(-SCREEN_W/2.-gui_xoff, SCREEN_H/2.-gui_yoff);
@ -296,6 +340,34 @@ void nebu_renderOverlay(void) {
#undef SIN225
}
/* Render the puffs. */
void nebu_renderPuffs(const double dt, int below_player) {
int i;
glPushMatrix(); /* GL_PROJECTION */
glTranslated(-(double)SCREEN_W/2., -(double)SCREEN_H/2., 0.);
for(i = 0; i < nebu_npuffs; i++) {
if((below_player && (nebu_puffs[i].height < 1.)) ||
(!below_player && (nebu_puffs[i].height > 1.))) {
/* Calculate new position. */
nebu_puffs[i].x -= player->solid->vel.x * nebu_puffs[i].height * dt;
nebu_puffs[i].y -= player->solid->vel.y * nebu_puffs[i].height * dt;
/* Calculate new alpha. */
/*nebu_puffs[i].a += nebu_puffs[i].va * dt;*/
/* Check boundaries. */
/* Render. */
ACOLOUR(cPurple, nebu_puffs[i].a);
glBegin(GL_QUADS);
glEnd(); /* GL_QUADS */
}
}
}
/* Prepare the nebulae. */
void nebu_prep(double density, double volatility) {
(void)volatility;
@ -305,7 +377,7 @@ void nebu_prep(double density, double volatility) {
/* Force generation of new nebulae. */
void nebu_forceGenerate(void) {
nebu_w = nebu_h = -9;
nebu_w = nebu_h = -9; /* Magic numbers. ^.^ */
}
/* Generate the nebulae. */
@ -318,13 +390,13 @@ static void nebu_generate(void) {
w = SCREEN_W;
h = SCREEN_H;
/* Generate all the nebulae. */
/* Generate all the nebulae backgrounds. */
nebu = noise_genNebulaeMap(w, h, NEBULAE_Z, 5.);
lfile_dirMakeExist("gen");
/* Save each nebulae as an image. */
for(i = 0; i < NEBULAE_Z; i++) {
snprintf(nebu_file, PATH_MAX, NEBULAE_PATH, i);
snprintf(nebu_file, PATH_MAX, NEBULAE_PATH_BG, w, h, i);
saveNebulae(&nebu[i*w*h], w, h, nebu_file);
}
@ -332,6 +404,33 @@ static void nebu_generate(void) {
free(nebu);
}
/* Generate the nebulae puffs. */
static void nebu_generatePuffs(void) {
int i;
int w, h;
SDL_Surface* sur;
float* nebu;
/* Generate the nebulae puffs. */
for(i = 0; i < NEBULAE_PUFFS; i++) {
/* Generate the nebulae. */
w = h = RNG(20, 64);
nebu = noise_genNebulaePuffMap(w, h, 1.);
sur = nebu_surfaceFromNebulaeMap(nebu, w, h);
free(nebu);
/* Set dimensions. */
nebu_pufftexs[i].w = w;
nebu_pufftexs[i].h = h;
nebu_pufftexs[i].pw = gl_pot(w);
nebu_pufftexs[i].ph = gl_pot(h);
/* Actually create the texture. */
glGenTextures(1, &nebu_pufftexs[i].tex);
nebu_loadTexture(sur, 0, 0, nebu_pufftexs[i].tex);
}
}
/* Check the validity of a nebulae. 0 on success. */
static int nebu_checkCompat(const char* file) {
if(lfile_fileExists(file) == 0) /* First check to see if file exists. */

3
src/nebulae.h
View File

@ -6,7 +6,8 @@ void nebu_exit(void);
/* Render. */
void nebu_render(void);
void nebu_renderOverlay(void);
void nebu_renderOverlay(const double dt);
void nebu_renderPuffs(const double dt, int below_player);
/* Misc. */
void nebu_prep(double density, double volatility);

57
src/perlin.c
View File

@ -2,6 +2,8 @@
#include <stdlib.h>
#include <string.h>
#include "SDL.h"
#include "lephisto.h"
#include "log.h"
#include "rng.h"
@ -239,3 +241,58 @@ float* noise_genNebulaeMap(const int w, const int h, const int n, float rug) {
return nebulae;
}
/* Generate tiny nebuale puffs */
float* noise_genNebulaePuffMap(const int w, const int h, float rug) {
int x, y;
float f[3];
int octaves;
float hurst;
float lacunarity;
perlin_data_t* noise;
float* nebulae;
float value;
float zoom;
float max;
/* Pretty default values. */
octaves = 3;
hurst = NOISE_DEFAULT_HURST;
lacunarity = NOISE_DEFAULT_LACUNARITY;
zoom = rug;
/* Create noise and data. */
noise = noise_new(hurst, lacunarity);
nebulae = malloc(sizeof(float)*w*h);
if(nebulae == NULL) {
WARN("Out of memory!");
return NULL;
}
/* Start to create the nebulae. */
max = 0.;
f[2] = 0.;
for(y = 0; y < h; y++) {
f[1] = zoom * (float)y / (float)h;
for(x = 0; x < w; x++) {
f[0] = zoom * (float)x / (float)w;
value = noise_turbulence(noise, f, octaves);
if(max < value) max = value;
nebulae[y*w + x] = value;
}
}
/* Post filtering. */
value = 1. - max;
for(y = 0; y < h; y++)
for(x = 0; x < w; x++)
nebulae[y*w + x] += value;
/* Clean up. */
noise_delete(noise);
/* Results. */
return nebulae;
}

1
src/perlin.h
View File

@ -2,4 +2,5 @@
#include "opengl.h"
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);

12
src/space.c
View File

@ -71,7 +71,7 @@ static int mstars = 0; /* Memory stars are taking. */
/* Intern. */
static Planet* planet_pull(const char* name);
static void space_renderStars(double dt);
static void space_renderStars(const double dt);
static void space_addFleet(Fleet* fleet);
static StarSystem* system_parse(const xmlNodePtr parent);
static void system_parseJumps(const xmlNodePtr parent);
@ -805,7 +805,7 @@ int space_load(void) {
}
/* Render the system. -- Just playing god now. */
void space_render(double dt) {
void space_render(const double dt) {
if(cur_system == NULL) return;
if(cur_system->nebu_density > 0.)
@ -815,15 +815,15 @@ void space_render(double dt) {
}
/* Render the overlay. */
void space_renderOverlay(void) {
void space_renderOverlay(const double dt) {
if(cur_system == NULL) return;
if(cur_system->nebu_density > 0.)
nebu_renderOverlay();
nebu_renderOverlay(dt);
}
/* Render stars. */
static void space_renderStars(double dt) {
static void space_renderStars(const double dt) {
int i;
unsigned int t, timer;
double x, y, m, b;
@ -835,7 +835,7 @@ static void space_renderStars(double dt) {
t = SDL_GetTicks();
if(!player_isFlag(PLAYER_DESTROYED) && !player_isFlag(PLAYER_CREATING) &&
pilot_isFlag(player, PILOT_HYPERSPACE) && /* Hyperspace fancy effect. */
!paused && (player->ptimer-HYPERSPACE_STARS_BLUR < t)) {
(player->ptimer-HYPERSPACE_STARS_BLUR < t)) {
timer = player->ptimer - HYPERSPACE_STARS_BLUR;

4
src/space.h
View File

@ -120,8 +120,8 @@ char* planet_getSystem(char* planetname);
Planet* planet_get(char* planetname);
/* Render. */
void space_render(double dt);
void space_renderOverlay(void);
void space_render(const double dt);
void space_renderOverlay(const double dt);
void planets_render(void);
/* Update. */