matthew/The-Powder-Toy
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Use reduced resolution gravity maps for improved performance

Browse Source
This commit is contained in:
Simon Robertshaw 2011-12-19 21:35:40 +00:00
parent a523dcab79
commit 810adc81fe
11 changed files with 154 additions and 152 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
includes/gravity.h
View File

@ -7,20 +7,17 @@ extern int ngrav_enable; //Newtonian gravity
extern int gravwl_timeout; extern int gravwl_timeout;
extern int gravityMode; extern int gravityMode;
extern float gravmap[YRES/CELL][XRES/CELL]; //Maps to be used by the main thread float *gravmap;//Maps to be used by the main thread
extern float *gravpf; float *gravp;
extern float *gravxf; float *gravy;
extern float *gravyf; float *gravx;
extern unsigned *gravmaskf; unsigned *gravmask;
extern float th_ogravmap[YRES/CELL][XRES/CELL]; // Maps to be processed by the gravity thread float *th_ogravmap;// Maps to be processed by the gravity thread
extern float th_gravmap[YRES/CELL][XRES/CELL]; float *th_gravmap;
extern float th_gravx[YRES/CELL][XRES/CELL]; float *th_gravx;
extern float th_gravy[YRES/CELL][XRES/CELL]; float *th_gravy;
extern float *th_gravpf; float *th_gravp;
extern float *th_gravxf;
extern float *th_gravyf;
extern float th_gravp[YRES/CELL][XRES/CELL];
void gravity_init(); void gravity_init();
void gravity_cleanup(); void gravity_cleanup();

4
src/elements/gbmb.c
View File

@ -19,8 +19,8 @@ int update_GBMB(UPDATE_FUNC_ARGS) {
} }
} }
if(parts[i].life>20) if(parts[i].life>20)
gravmap[y/CELL][x/CELL] = 20; gravmap[(y/CELL)*(XRES/CELL)+(x/CELL)] = 20;
if(parts[i].life<20 && parts[i].life>=1) if(parts[i].life<20 && parts[i].life>=1)
gravmap[y/CELL][x/CELL] = -80; gravmap[(y/CELL)*(XRES/CELL)+(x/CELL)] = -80;
return 0; return 0;
} }

4
src/elements/gpmp.c
View File

@ -11,9 +11,9 @@ int update_GPMP(UPDATE_FUNC_ARGS) {
if (parts[i].temp<= -256.0+273.15) if (parts[i].temp<= -256.0+273.15)
parts[i].temp = -256.0+273.15; parts[i].temp = -256.0+273.15;
gravmap[y/CELL][x/CELL] = 0.2f*(parts[i].temp-273.15); gravmap[(y/CELL)*(XRES/CELL)+(x/CELL)] = 0.2f*(parts[i].temp-273.15);
if (y+CELL<YRES && pv[y/CELL+1][x/CELL]<(parts[i].temp-273.15)) if (y+CELL<YRES && pv[y/CELL+1][x/CELL]<(parts[i].temp-273.15))
gravmap[y/CELL+1][x/CELL] += 0.1f*((parts[i].temp-273.15)-gravmap[y/CELL+1][x/CELL]); gravmap[(y/CELL+1)*(XRES/CELL)+(x/CELL)] += 0.1f*((parts[i].temp-273.15)-gravmap[(y/CELL+1)*(XRES/CELL)+(x/CELL)]);
for (rx=-2; rx<3; rx++) for (rx=-2; rx<3; rx++)
for (ry=-2; ry<3; ry++) for (ry=-2; ry<3; ry++)
if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry)) if (x+rx>=0 && y+ry>0 && x+rx<XRES && y+ry<YRES && (rx || ry))

2
src/elements/nbhl.c
View File

@ -1,6 +1,6 @@
#include <element.h> #include <element.h>
int update_NBHL(UPDATE_FUNC_ARGS) { int update_NBHL(UPDATE_FUNC_ARGS) {
gravmap[y/CELL][x/CELL] += 0.1f; gravmap[(y/CELL)*(XRES/CELL)+(x/CELL)] += 0.1f;
return 0; return 0;
} }

2
src/elements/nwhl.c
View File

@ -1,6 +1,6 @@
#include <element.h> #include <element.h>
int update_NWHL(UPDATE_FUNC_ARGS) { int update_NWHL(UPDATE_FUNC_ARGS) {
gravmap[y/CELL][x/CELL] -= 0.1f; gravmap[(y/CELL)*(XRES/CELL)+(x/CELL)] -= 0.1f;
return 0; return 0;
} }

4
src/elements/stkm.c
View File

@ -80,8 +80,8 @@ int run_stickman(playerst* playerp, UPDATE_FUNC_ARGS) {
} }
} }
gvx += gravxf[XRES*(int)parts[i].y + (int)parts[i].x]; gvx += gravx[((int)parts[i].y/CELL)*(XRES/CELL)+((int)parts[i].x/CELL)];
gvy += gravyf[XRES*(int)parts[i].y + (int)parts[i].x]; gvy += gravy[((int)parts[i].y/CELL)*(XRES/CELL)+((int)parts[i].x/CELL)];
parts[i].vx -= gvx*dt; //Head up! parts[i].vx -= gvx*dt; //Head up!
parts[i].vy -= gvy*dt; parts[i].vy -= gvy*dt;

31
src/graphics.c
View File

@ -1427,7 +1427,7 @@ void draw_grav_zones(pixel * vid)
{ {
for (x=0; x<XRES/CELL; x++) for (x=0; x<XRES/CELL; x++)
{ {
if(gravmaskf[y*CELL*XRES+x*CELL]) if(gravmask[y*(XRES/CELL)+x])
{ {
for (j=0; j<CELL; j++)//draws the colors for (j=0; j<CELL; j++)//draws the colors
for (i=0; i<CELL; i++) for (i=0; i<CELL; i++)
@ -1449,16 +1449,16 @@ void draw_grav(pixel *vid)
{ {
for (x=0; x<XRES/CELL; x++) for (x=0; x<XRES/CELL; x++)
{ {
ca = ((y*CELL)*XRES)+(x*CELL); ca = y*(XRES/CELL)+x;
if(fabsf(gravpf[ca]) <= 0.001f && fabsf(gravyf[ca]) <= 0.001f) if(fabsf(gravx[ca]) <= 0.001f && fabsf(gravy[ca]) <= 0.001f)
continue; continue;
nx = x*CELL; nx = x*CELL;
ny = y*CELL; ny = y*CELL;
dist = fabsf(gravyf[ca])+fabsf(gravxf[ca]); dist = fabsf(gravy[ca])+fabsf(gravx[ca]);
for(i = 0; i < 4; i++) for(i = 0; i < 4; i++)
{ {
nx -= gravxf[ca]*0.5f; nx -= gravx[ca]*0.5f;
ny -= gravyf[ca]*0.5f; ny -= gravy[ca]*0.5f;
addpixel(vid, (int)(nx+0.5f), (int)(ny+0.5f), 255, 255, 255, (int)(dist*20.0f)); addpixel(vid, (int)(nx+0.5f), (int)(ny+0.5f), 255, 255, 255, (int)(dist*20.0f));
} }
} }
@ -2664,11 +2664,11 @@ void draw_parts_fbo()
glUniform1i(glGetUniformLocation(lensProg, "pTex"), 0); glUniform1i(glGetUniformLocation(lensProg, "pTex"), 0);
glActiveTexture(GL_TEXTURE1); glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, partsTFX); glBindTexture(GL_TEXTURE_2D, partsTFX);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, XRES, YRES, GL_RED, GL_FLOAT, gravxf); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, XRES/CELL, YRES/CELL, GL_RED, GL_FLOAT, gravx);
glUniform1i(glGetUniformLocation(lensProg, "tfX"), 1); glUniform1i(glGetUniformLocation(lensProg, "tfX"), 1);
glActiveTexture(GL_TEXTURE2); glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, partsTFY); glBindTexture(GL_TEXTURE_2D, partsTFY);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, XRES, YRES, GL_GREEN, GL_FLOAT, gravyf); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, XRES/CELL, YRES/CELL, GL_GREEN, GL_FLOAT, gravy);
glUniform1i(glGetUniformLocation(lensProg, "tfY"), 2); glUniform1i(glGetUniformLocation(lensProg, "tfY"), 2);
glActiveTexture(GL_TEXTURE0); glActiveTexture(GL_TEXTURE0);
glUniform1fv(glGetUniformLocation(lensProg, "xres"), 1, &xres); glUniform1fv(glGetUniformLocation(lensProg, "xres"), 1, &xres);
@ -3111,19 +3111,20 @@ void render_signs(pixel *vid_buf)
void render_gravlensing(pixel *src, pixel * dst) void render_gravlensing(pixel *src, pixel * dst)
{ {
int nx, ny, rx, ry, gx, gy, bx, by; int nx, ny, rx, ry, gx, gy, bx, by, co;
int r, g, b; int r, g, b;
pixel t; pixel t;
for(nx = 0; nx < XRES; nx++) for(nx = 0; nx < XRES; nx++)
{ {
for(ny = 0; ny < YRES; ny++) for(ny = 0; ny < YRES; ny++)
{ {
rx = (int)(nx-gravxf[(ny*XRES)+nx]*0.75f+0.5f); co = (ny/CELL)*(XRES/CELL)+(nx/CELL);
ry = (int)(ny-gravyf[(ny*XRES)+nx]*0.75f+0.5f); rx = (int)(nx-gravx[co]*0.75f+0.5f);
gx = (int)(nx-gravxf[(ny*XRES)+nx]*0.875f+0.5f); ry = (int)(ny-gravy[co]*0.75f+0.5f);
gy = (int)(ny-gravyf[(ny*XRES)+nx]*0.875f+0.5f); gx = (int)(nx-gravx[co]*0.875f+0.5f);
bx = (int)(nx-gravxf[(ny*XRES)+nx]+0.5f); gy = (int)(ny-gravy[co]*0.875f+0.5f);
by = (int)(ny-gravyf[(ny*XRES)+nx]+0.5f); bx = (int)(nx-gravx[co]+0.5f);
by = (int)(ny-gravy[co]+0.5f);
if(rx > 0 && rx < XRES && ry > 0 && ry < YRES && gx > 0 && gx < XRES && gy > 0 && gy < YRES && bx > 0 && bx < XRES && by > 0 && by < YRES) if(rx > 0 && rx < XRES && ry > 0 && ry < YRES && gx > 0 && gx < XRES && gy > 0 && gy < YRES && bx > 0 && bx < XRES && by > 0 && by < YRES)
{ {
t = dst[ny*(XRES+BARSIZE)+nx]; t = dst[ny*(XRES+BARSIZE)+nx];

172
src/gravity.c
View File

@ -9,24 +9,22 @@
#endif #endif
float gravmap[YRES/CELL][XRES/CELL]; //Maps to be used by the main thread float *gravmap;//Maps to be used by the main thread
float *gravpf; float *gravp;
float *gravyf; float *gravy;
float *gravxf; float *gravx;
unsigned *gravmaskf; unsigned *gravmask;
float th_ogravmap[YRES/CELL][XRES/CELL]; // Maps to be processed by the gravity thread float *th_ogravmap;// Maps to be processed by the gravity thread
float th_gravmap[YRES/CELL][XRES/CELL]; float *th_gravmap;
float th_gravx[YRES/CELL][XRES/CELL]; float *th_gravx;
float th_gravy[YRES/CELL][XRES/CELL]; float *th_gravy;
float th_gravp[YRES/CELL][XRES/CELL]; float *th_gravp;
float *th_gravpf;
float *th_gravyf;
float *th_gravxf;
int gravwl_timeout = 0; int gravwl_timeout = 0;
int gravityMode = 0; // starts enabled in "vertical" mode... int gravityMode = 0; // starts enabled in "vertical" mode...
int ngrav_enable = 0; //Newtonian gravity, will be set by save int ngrav_enable = 0; //Newtonian gravity
int th_gravchanged = 0;
pthread_t gravthread; pthread_t gravthread;
pthread_mutex_t gravmutex; pthread_mutex_t gravmutex;
@ -63,13 +61,16 @@ void bilinear_interpolation(float *src, float *dst, int sw, int sh, int rw, int
void gravity_init() void gravity_init()
{ {
//Allocate full size Gravmaps //Allocate full size Gravmaps
th_gravyf = calloc(XRES*YRES, sizeof(float)); th_ogravmap = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
th_gravxf = calloc(XRES*YRES, sizeof(float)); th_gravmap = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
th_gravpf = calloc(XRES*YRES, sizeof(float)); th_gravy = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravyf = calloc(XRES*YRES, sizeof(float)); th_gravx = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravxf = calloc(XRES*YRES, sizeof(float)); th_gravp = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravpf = calloc(XRES*YRES, sizeof(float)); gravmap = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravmaskf = malloc(XRES*YRES*sizeof(unsigned)); gravy = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravx = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravp = calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravmask = calloc((XRES/CELL)*(YRES/CELL), sizeof(unsigned));
} }
void gravity_cleanup() void gravity_cleanup()
@ -88,22 +89,28 @@ void gravity_update_async()
result = grav_ready; result = grav_ready;
if(result) //Did the gravity thread finish? if(result) //Did the gravity thread finish?
{ {
memcpy(th_gravmap, gravmap, sizeof(gravmap)); //Move our current gravmap to be processed other thread
if (!sys_pause||framerender){ //Only update if not paused if (!sys_pause||framerender){ //Only update if not paused
//Switch the full size gravmaps, we don't really need the two above any more //Switch the full size gravmaps, we don't really need the two above any more
float *tmpf; float *tmpf;
tmpf = gravyf;
gravyf = th_gravyf; if(th_gravchanged)
th_gravyf = tmpf; {
tmpf = gravy;
tmpf = gravxf; gravy = th_gravy;
gravxf = th_gravxf; th_gravy = tmpf;
th_gravxf = tmpf;
tmpf = gravx;
tmpf = gravpf; gravx = th_gravx;
gravpf = th_gravpf; th_gravx = tmpf;
th_gravpf = tmpf;
tmpf = gravp;
gravp = th_gravp;
th_gravp = tmpf;
}
tmpf = gravmap;
gravmap = th_gravmap;
th_gravmap = tmpf;
grav_ready = 0; //Tell the other thread that we're ready for it to continue grav_ready = 0; //Tell the other thread that we're ready for it to continue
pthread_cond_signal(&gravcv); pthread_cond_signal(&gravcv);
@ -111,8 +118,8 @@ void gravity_update_async()
} }
pthread_mutex_unlock(&gravmutex); pthread_mutex_unlock(&gravmutex);
//Apply the gravity mask //Apply the gravity mask
membwand(gravyf, gravmaskf, XRES*YRES*sizeof(float), XRES*YRES*sizeof(unsigned)); membwand(gravy, gravmask, (XRES/CELL)*(YRES/CELL)*sizeof(float), (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
membwand(gravxf, gravmaskf, XRES*YRES*sizeof(float), XRES*YRES*sizeof(unsigned)); membwand(gravx, gravmask, (XRES/CELL)*(YRES/CELL)*sizeof(float), (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
} }
} }
@ -120,13 +127,14 @@ void* update_grav_async(void* unused)
{ {
int done = 0; int done = 0;
int thread_done = 0; int thread_done = 0;
memset(th_ogravmap, 0, sizeof(th_ogravmap)); memset(th_ogravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravmap, 0, sizeof(th_gravmap)); memset(th_gravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravy, 0, sizeof(th_gravy)); memset(th_gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravx, 0, sizeof(th_gravx)); memset(th_gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravyf, 0, XRES*YRES*sizeof(float)); memset(th_gravp, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravxf, 0, XRES*YRES*sizeof(float)); //memset(th_gravy, 0, XRES*YRES*sizeof(float));
memset(th_gravpf, 0, XRES*YRES*sizeof(float)); //memset(th_gravx, 0, XRES*YRES*sizeof(float));
//memset(th_gravp, 0, XRES*YRES*sizeof(float));
#ifdef GRAVFFT #ifdef GRAVFFT
grav_fft_init(); grav_fft_init();
#endif #endif
@ -163,9 +171,9 @@ void start_grav_async()
pthread_create(&gravthread, NULL, update_grav_async, NULL); //Start asynchronous gravity simulation pthread_create(&gravthread, NULL, update_grav_async, NULL); //Start asynchronous gravity simulation
ngrav_enable = 1; ngrav_enable = 1;
} }
memset(gravyf, 0, XRES*YRES*sizeof(float)); memset(gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravxf, 0, XRES*YRES*sizeof(float)); memset(gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravpf, 0, XRES*YRES*sizeof(float)); memset(gravp, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
} }
void stop_grav_async() void stop_grav_async()
@ -180,9 +188,9 @@ void stop_grav_async()
ngrav_enable = 0; ngrav_enable = 0;
} }
//Clear the grav velocities //Clear the grav velocities
memset(gravyf, 0, XRES*YRES*sizeof(float)); memset(gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravxf, 0, XRES*YRES*sizeof(float)); memset(gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravpf, 0, XRES*YRES*sizeof(float)); memset(gravp, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
} }
#ifdef GRAVFFT #ifdef GRAVFFT
@ -269,13 +277,16 @@ void grav_fft_cleanup()
void update_grav() void update_grav()
{ {
int x, y, changed = 0; int x, y, changed = 0;
int xblock2 = XRES/CELL*2, yblock2 = YRES/CELL*2;
int i, fft_tsize = (xblock2/2+1)*yblock2;
float mr, mc, pr, pc, gr, gc;
for (y=0; y<YRES/CELL; y++) for (y=0; y<YRES/CELL; y++)
{ {
if(changed) if(changed)
break; break;
for (x=0; x<XRES/CELL; x++) for (x=0; x<XRES/CELL; x++)
{ {
if(th_ogravmap[y][x]!=th_gravmap[y][x]){ if(th_ogravmap[y*(XRES/CELL)+x]!=th_gravmap[y*(XRES/CELL)+x]){
changed = 1; changed = 1;
break; break;
} }
@ -283,9 +294,7 @@ void update_grav()
} }
if(changed) if(changed)
{ {
int xblock2 = XRES/CELL*2, yblock2 = YRES/CELL*2; th_gravchanged = 1;
int i, fft_tsize = (xblock2/2+1)*yblock2;
float mr, mc, pr, pc, gr, gc;
if (!grav_fft_status) grav_fft_init(); if (!grav_fft_status) grav_fft_init();
//copy gravmap into padded gravmap array //copy gravmap into padded gravmap array
@ -293,7 +302,7 @@ void update_grav()
{ {
for (x=0; x<XRES/CELL; x++) for (x=0; x<XRES/CELL; x++)
{ {
th_gravmapbig[(y+YRES/CELL)*xblock2+XRES/CELL+x] = th_gravmap[y][x]; th_gravmapbig[(y+YRES/CELL)*xblock2+XRES/CELL+x] = th_gravmap[y*(XRES/CELL)+x];
} }
} }
//transform gravmap //transform gravmap
@ -323,16 +332,18 @@ void update_grav()
{ {
for (x=0; x<XRES/CELL; x++) for (x=0; x<XRES/CELL; x++)
{ {
th_gravx[y][x] = th_gravxbig[y*xblock2+x]; th_gravx[y*(XRES/CELL)+x] = th_gravxbig[y*xblock2+x];
th_gravy[y][x] = th_gravybig[y*xblock2+x]; th_gravy[y*(XRES/CELL)+x] = th_gravybig[y*xblock2+x];
th_gravp[y][x] = sqrtf(pow(th_gravxbig[y*xblock2+x],2)+pow(th_gravybig[y*xblock2+x],2)); th_gravp[y*(XRES/CELL)+x] = sqrtf(pow(th_gravxbig[y*xblock2+x],2)+pow(th_gravybig[y*xblock2+x],2));
} }
} }
} }
memcpy(th_ogravmap, th_gravmap, sizeof(th_gravmap)); else
bilinear_interpolation(th_gravy, th_gravyf, XRES/CELL, YRES/CELL, XRES, YRES); {
bilinear_interpolation(th_gravx, th_gravxf, XRES/CELL, YRES/CELL, XRES, YRES); th_gravchanged = 0;
bilinear_interpolation(th_gravp, th_gravpf, XRES/CELL, YRES/CELL, XRES, YRES); }
memcpy(th_ogravmap, th_gravmap, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
} }
#else #else
@ -342,6 +353,7 @@ void update_grav(void)
{ {
int x, y, i, j, changed = 0; int x, y, i, j, changed = 0;
float val, distance; float val, distance;
th_gravchanged = 0;
#ifndef GRAV_DIFF #ifndef GRAV_DIFF
//Find any changed cells //Find any changed cells
for (i=0; i<YRES/CELL; i++) for (i=0; i<YRES/CELL; i++)
@ -350,7 +362,7 @@ void update_grav(void)
break; break;
for (j=0; j<XRES/CELL; j++) for (j=0; j<XRES/CELL; j++)
{ {
if(th_ogravmap[i][j]!=th_gravmap[i][j]){ if(th_ogravmap[i*(XRES/CELL)+j]!=th_gravmap[i*(XRES/CELL)+j]){
changed = 1; changed = 1;
break; break;
} }
@ -358,16 +370,17 @@ void update_grav(void)
} }
if(!changed) if(!changed)
goto fin; goto fin;
memset(th_gravy, 0, sizeof(th_gravy)); memset(th_gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravx, 0, sizeof(th_gravx)); memset(th_gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
#endif #endif
th_gravchanged = 1;
for (i = 0; i < YRES / CELL; i++) { for (i = 0; i < YRES / CELL; i++) {
for (j = 0; j < XRES / CELL; j++) { for (j = 0; j < XRES / CELL; j++) {
#ifdef GRAV_DIFF #ifdef GRAV_DIFF
if (th_ogravmap[i][j] != th_gravmap[i][j]) if (th_ogravmap[i*(XRES/CELL)+j] != th_gravmap[i*(XRES/CELL)+j])
{ {
#else #else
if (th_gravmap[i][j] > 0.0001f || th_gravmap[i][j]<-0.0001f) //Only calculate with populated or changed cells. if (th_gravmap[i*(XRES/CELL)+j] > 0.0001f || th_gravmap[i*(XRES/CELL)+j]<-0.0001f) //Only calculate with populated or changed cells.
{ {
#endif #endif
for (y = 0; y < YRES / CELL; y++) { for (y = 0; y < YRES / CELL; y++) {
@ -376,24 +389,21 @@ void update_grav(void)
continue; continue;
distance = sqrt(pow(j - x, 2) + pow(i - y, 2)); distance = sqrt(pow(j - x, 2) + pow(i - y, 2));
#ifdef GRAV_DIFF #ifdef GRAV_DIFF
val = th_gravmap[i][j] - th_ogravmap[i][j]; val = th_gravmap[i*(XRES/CELL)+j] - th_ogravmap[i*(XRES/CELL)+j];
#else #else
val = th_gravmap[i][j]; val = th_gravmap[i*(XRES/CELL)+j];
#endif #endif
th_gravx[y][x] += M_GRAV * val * (j - x) / pow(distance, 3); th_gravx[y*(XRES/CELL)+x] += M_GRAV * val * (j - x) / pow(distance, 3);
th_gravy[y][x] += M_GRAV * val * (i - y) / pow(distance, 3); th_gravy[y*(XRES/CELL)+x] += M_GRAV * val * (i - y) / pow(distance, 3);
th_gravp[y][x] += M_GRAV * val / pow(distance, 2); th_gravp[y*(XRES/CELL)+x] += M_GRAV * val / pow(distance, 2);
} }
} }
} }
} }
} }
bilinear_interpolation(th_gravy, th_gravyf, XRES/CELL, YRES/CELL, XRES, YRES);
bilinear_interpolation(th_gravx, th_gravxf, XRES/CELL, YRES/CELL, XRES, YRES);
bilinear_interpolation(th_gravp, th_gravpf, XRES/CELL, YRES/CELL, XRES, YRES);
fin: fin:
memcpy(th_ogravmap, th_gravmap, sizeof(th_gravmap)); memcpy(th_ogravmap, th_gravmap, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravmap, 0, sizeof(th_gravmap)); memset(th_gravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
} }
#endif #endif
@ -467,7 +477,7 @@ void gravity_mask()
} }
} }
c_mask_el = t_mask_el; c_mask_el = t_mask_el;
memset(gravmaskf, 0, XRES*YRES*sizeof(unsigned)); memset(gravmask, 0, (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
while(c_mask_el!=NULL) while(c_mask_el!=NULL)
{ {
char *cshape = c_mask_el->shape; char *cshape = c_mask_el->shape;
@ -480,13 +490,7 @@ void gravity_mask()
maskvalue = 0xFFFFFFFF; maskvalue = 0xFFFFFFFF;
else else
maskvalue = 0x00000000; maskvalue = 0x00000000;
for (j=0; j<CELL; j++) gravmask[y*(XRES/CELL)+x] = maskvalue;
{
for (i=0; i<CELL; i++)
{
gravmaskf[(y*CELL+j)*XRES+x*CELL+i] = maskvalue;
}
}
} }
} }
} }

28
src/luaconsole.c
View File

@ -969,7 +969,7 @@ int luatpt_set_gravity(lua_State* l)
for (nx = x1; nx<x1+width; nx++) for (nx = x1; nx<x1+width; nx++)
for (ny = y1; ny<y1+height; ny++) for (ny = y1; ny<y1+height; ny++)
{ {
gravmap[ny][nx] = value; gravmap[ny*(XRES/CELL)+nx] = value;
} }
return 0; return 0;
} }
@ -980,22 +980,22 @@ int luatpt_reset_gravity_field(lua_State* l)
int x1, y1, width, height; int x1, y1, width, height;
x1 = abs(luaL_optint(l, 1, 0)); x1 = abs(luaL_optint(l, 1, 0));
y1 = abs(luaL_optint(l, 2, 0)); y1 = abs(luaL_optint(l, 2, 0));
width = abs(luaL_optint(l, 3, XRES)); width = abs(luaL_optint(l, 3, XRES/CELL));
height = abs(luaL_optint(l, 4, YRES)); height = abs(luaL_optint(l, 4, YRES/CELL));
if(x1 > XRES-1) if(x1 > (XRES/CELL)-1)
x1 = XRES-1; x1 = (XRES/CELL)-1;
if(y1 > YRES-1) if(y1 > (YRES/CELL)-1)
y1 = YRES-1; y1 = (YRES/CELL)-1;
if(x1+width > XRES-1) if(x1+width > (XRES/CELL)-1)
width = XRES-x1; width = (XRES/CELL)-x1;
if(y1+height > YRES-1) if(y1+height > (YRES/CELL)-1)
height = YRES-y1; height = (YRES/CELL)-y1;
for (nx = x1; nx<x1+width; nx++) for (nx = x1; nx<x1+width; nx++)
for (ny = y1; ny<y1+height; ny++) for (ny = y1; ny<y1+height; ny++)
{ {
gravxf[ny*XRES+nx] = 0; gravx[ny*(XRES/CELL)+nx] = 0;
gravyf[ny*XRES+nx] = 0; gravy[ny*(XRES/CELL)+nx] = 0;
gravpf[ny*XRES+nx] = 0; gravp[ny*(XRES/CELL)+nx] = 0;
} }
return 0; return 0;
} }

10
src/main.c
View File

@ -1153,10 +1153,10 @@ void clear_sim(void)
memset(fire_r, 0, sizeof(fire_r)); memset(fire_r, 0, sizeof(fire_r));
memset(fire_g, 0, sizeof(fire_g)); memset(fire_g, 0, sizeof(fire_g));
memset(fire_b, 0, sizeof(fire_b)); memset(fire_b, 0, sizeof(fire_b));
memset(gravmaskf, 0xFF, XRES*YRES*sizeof(unsigned)); memset(gravmask, 0xFFFFFFFF, (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
memset(gravyf, 0, XRES*YRES*sizeof(float)); memset(gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravxf, 0, XRES*YRES*sizeof(float)); memset(gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravpf, 0, XRES*YRES*sizeof(float)); memset(gravp, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
for(x = 0; x < XRES/CELL; x++){ for(x = 0; x < XRES/CELL; x++){
for(y = 0; y < YRES/CELL; y++){ for(y = 0; y < YRES/CELL; y++){
hv[y][x] = 273.15f+22.0f; //Set to room temperature hv[y][x] = 273.15f+22.0f; //Set to room temperature
@ -2673,7 +2673,7 @@ int main(int argc, char *argv[])
sprintf(heattext, "Empty, Pressure: %3.2f", pv[(y/sdl_scale)/CELL][(x/sdl_scale)/CELL]); sprintf(heattext, "Empty, Pressure: %3.2f", pv[(y/sdl_scale)/CELL][(x/sdl_scale)/CELL]);
if (DEBUG_MODE) if (DEBUG_MODE)
{ {
sprintf(coordtext, "X:%d Y:%d. GX: %.2f GY: %.2f", x/sdl_scale, y/sdl_scale, gravxf[((y/sdl_scale)*XRES)+(x/sdl_scale)], gravyf[((y/sdl_scale)*XRES)+(x/sdl_scale)]); sprintf(coordtext, "X:%d Y:%d. GX: %.2f GY: %.2f", x/sdl_scale, y/sdl_scale, gravx[(((y/sdl_scale)/CELL)*(XRES/CELL))+((x/sdl_scale)/CELL)], gravy[(((y/sdl_scale)/CELL)*(XRES/CELL))+((x/sdl_scale)/CELL)]);
} }
} }
} }

26
src/powder.c
View File

@ -760,13 +760,13 @@ inline int create_part(int p, int x, int y, int tv)//the function for creating a
} }
if (t==SPC_PGRV) if (t==SPC_PGRV)
{ {
gravmap[y/CELL][x/CELL] = 5; gravmap[(y/CELL)*(XRES/CELL)+(x/CELL)] = 5;
return -1; return -1;
} }
if (t==SPC_NGRV) if (t==SPC_NGRV)
{ {
gravmap[y/CELL][x/CELL] = -5; gravmap[(y/CELL)*(XRES/CELL)+(x/CELL)] = -5;
return -1; return -1;
} }
@ -1801,13 +1801,13 @@ void update_particles_i(pixel *vid, int start, int inc)
if (t==PT_ANAR) if (t==PT_ANAR)
{ {
// perhaps we should have a ptypes variable for this // perhaps we should have a ptypes variable for this
pGravX -= gravxf[(y*XRES)+x]; pGravX -= gravx[(y/CELL)*(XRES/CELL)+(x/CELL)];
pGravY -= gravyf[(y*XRES)+x]; pGravY -= gravy[(y/CELL)*(XRES/CELL)+(x/CELL)];
} }
else if(t!=PT_STKM && t!=PT_STKM2 && t!=PT_FIGH && !(ptypes[t].properties & TYPE_SOLID)) else if(t!=PT_STKM && t!=PT_STKM2 && t!=PT_FIGH && !(ptypes[t].properties & TYPE_SOLID))
{ {
pGravX += gravxf[(y*XRES)+x]; pGravX += gravx[(y/CELL)*(XRES/CELL)+(x/CELL)];
pGravY += gravyf[(y*XRES)+x]; pGravY += gravy[(y/CELL)*(XRES/CELL)+(x/CELL)];
} }
//velocity updates for the particle //velocity updates for the particle
parts[i].vx *= ptypes[t].loss; parts[i].vx *= ptypes[t].loss;
@ -2063,7 +2063,7 @@ void update_particles_i(pixel *vid, int start, int inc)
s = 1; s = 1;
gravtot = fabs(gravyf[(y*XRES)+x])+fabs(gravxf[(y*XRES)+x]); gravtot = fabs(gravy[(y/CELL)*(XRES/CELL)+(x/CELL)])+fabs(gravx[(y/CELL)*(XRES/CELL)+(x/CELL)]);
if (pv[y/CELL][x/CELL]>ptransitions[t].phv&&ptransitions[t].pht>-1) { if (pv[y/CELL][x/CELL]>ptransitions[t].phv&&ptransitions[t].pht>-1) {
// particle type change due to high pressure // particle type change due to high pressure
if (ptransitions[t].pht!=PT_NUM) if (ptransitions[t].pht!=PT_NUM)
@ -2449,8 +2449,8 @@ killed:
pGravX = ptGrav * ((float)(nx - XCNTR) / pGravD); pGravX = ptGrav * ((float)(nx - XCNTR) / pGravD);
pGravY = ptGrav * ((float)(ny - YCNTR) / pGravD); pGravY = ptGrav * ((float)(ny - YCNTR) / pGravD);
} }
pGravX += gravxf[(ny*XRES)+nx]; pGravX += gravx[(ny/CELL)*(XRES/CELL)+(nx/CELL)];
pGravY += gravyf[(ny*XRES)+nx]; pGravY += gravy[(ny/CELL)*(XRES/CELL)+(nx/CELL)];
if (fabsf(pGravY)>fabsf(pGravX)) if (fabsf(pGravY)>fabsf(pGravX))
mv = fabsf(pGravY); mv = fabsf(pGravY);
else else
@ -2508,8 +2508,8 @@ killed:
pGravX = ptGrav * ((float)(nx - XCNTR) / pGravD); pGravX = ptGrav * ((float)(nx - XCNTR) / pGravD);
pGravY = ptGrav * ((float)(ny - YCNTR) / pGravD); pGravY = ptGrav * ((float)(ny - YCNTR) / pGravD);
} }
pGravX += gravxf[(ny*XRES)+nx]; pGravX += gravx[(ny/CELL)*(XRES/CELL)+(nx/CELL)];
pGravY += gravyf[(ny*XRES)+nx]; pGravY += gravy[(ny/CELL)*(XRES/CELL)+(nx/CELL)];
if (fabsf(pGravY)>fabsf(pGravX)) if (fabsf(pGravY)>fabsf(pGravX))
mv = fabsf(pGravY); mv = fabsf(pGravY);
else else