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

arbitrary gravity code cleanup

Browse Source 
Was working on modernizing the code in my mod, copied all the changes here too
This commit is contained in:
jacob1 2019-08-05 00:05:54 -04:00
parent ee2a765758
commit e280fea031
6 changed files with 354 additions and 383 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/gui/game/GameModel.cpp
View File

@ -174,7 +174,7 @@ GameModel::~GameModel()
Client::Ref().SetPref("Renderer.DebugMode", ren->debugLines); //These two should always be equivalent, even though they are different things Client::Ref().SetPref("Renderer.DebugMode", ren->debugLines); //These two should always be equivalent, even though they are different things
Client::Ref().SetPref("Simulation.EdgeMode", edgeMode); Client::Ref().SetPref("Simulation.EdgeMode", edgeMode);
Client::Ref().SetPref("Simulation.NewtonianGravity", sim->grav->ngrav_enable); Client::Ref().SetPref("Simulation.NewtonianGravity", sim->grav->IsEnabled());
Client::Ref().SetPref("Simulation.AmbientHeat", sim->aheat_enable); Client::Ref().SetPref("Simulation.AmbientHeat", sim->aheat_enable);
Client::Ref().SetPref("Simulation.PrettyPowder", sim->pretty_powder); Client::Ref().SetPref("Simulation.PrettyPowder", sim->pretty_powder);
@ -719,11 +719,11 @@ void GameModel::SetSaveFile(SaveFile * newSave, bool invertIncludePressure)
sim->legacy_enable = saveData->legacyEnable; sim->legacy_enable = saveData->legacyEnable;
sim->water_equal_test = saveData->waterEEnabled; sim->water_equal_test = saveData->waterEEnabled;
sim->aheat_enable = saveData->aheatEnable; sim->aheat_enable = saveData->aheatEnable;
if(saveData->gravityEnable && !sim->grav->ngrav_enable) if(saveData->gravityEnable && !sim->grav->IsEnabled())
{ {
sim->grav->start_grav_async(); sim->grav->start_grav_async();
} }
else if(!saveData->gravityEnable && sim->grav->ngrav_enable) else if(!saveData->gravityEnable && sim->grav->IsEnabled())
{ {
sim->grav->stop_grav_async(); sim->grav->stop_grav_async();
} }
@ -995,7 +995,7 @@ void GameModel::SetNewtonianGravity(bool newtonainGravity)
bool GameModel::GetNewtonianGrvity() bool GameModel::GetNewtonianGrvity()
{ {
return sim->grav->ngrav_enable; return sim->grav->IsEnabled();
} }
void GameModel::ShowGravityGrid(bool showGrid) void GameModel::ShowGravityGrid(bool showGrid)

2
src/gui/options/OptionsModel.cpp
View File

@ -46,7 +46,7 @@ void OptionsModel::SetAmbientHeatSimulation(bool state)
bool OptionsModel::GetNewtonianGravity() bool OptionsModel::GetNewtonianGravity()
{ {
return sim->grav->ngrav_enable?true:false; return sim->grav->IsEnabled();
} }
void OptionsModel::SetNewtonianGravity(bool state) void OptionsModel::SetNewtonianGravity(bool state)

2
src/lua/LegacyLuaAPI.cpp
View File

@ -1226,7 +1226,7 @@ int luatpt_gravity(lua_State* l)
int acount = lua_gettop(l); int acount = lua_gettop(l);
if (acount == 0) if (acount == 0)
{ {
lua_pushinteger(l, luacon_sim->grav->ngrav_enable); lua_pushinteger(l, luacon_sim->grav->IsEnabled() ? 1 : 0);
return 1; return 1;
} }
int gravstate = luaL_checkint(l, 1); int gravstate = luaL_checkint(l, 1);

610
src/simulation/Gravity.cpp
View File

@ -1,241 +1,83 @@
#include "Gravity.h" #include "Gravity.h"
#include "SimulationData.h"
#include <cmath> #include <cmath>
#include <iostream>
#include <sys/types.h> #include <sys/types.h>
#include "CoordStack.h"
#include "Misc.h" #include "Misc.h"
#include "Simulation.h" #include "Simulation.h"
#include "SimulationData.h"
void Gravity::bilinear_interpolation(float *src, float *dst, int sw, int sh, int rw, int rh)
Gravity::Gravity()
{ {
int y, x, fxceil, fyceil; // Allocate full size Gravmaps
float fx, fy, fyc, fxc; unsigned int size = (XRES / CELL) * (YRES / CELL);
double intp; th_ogravmap = new float[size];
float tr, tl, br, bl; th_gravmap = new float[size];
//Bilinear interpolation for upscaling th_gravy = new float[size];
for (y=0; y<rh; y++) th_gravx = new float[size];
for (x=0; x<rw; x++) th_gravp = new float[size];
{ gravmap = new float[size];
fx = ((float)x)*((float)sw)/((float)rw); gravy = new float[size];
fy = ((float)y)*((float)sh)/((float)rh); gravx = new float[size];
fxc = modf(fx, &intp); gravp = new float[size];
fyc = modf(fy, &intp); gravmask = new unsigned[size];
fxceil = (int)ceil(fx);
fyceil = (int)ceil(fy);
if (fxceil>=sw) fxceil = sw-1;
if (fyceil>=sh) fyceil = sh-1;
tr = src[sw*(int)floor(fy)+fxceil];
tl = src[sw*(int)floor(fy)+(int)floor(fx)];
br = src[sw*fyceil+fxceil];
bl = src[sw*fyceil+(int)floor(fx)];
dst[rw*y+x] = ((tl*(1.0f-fxc))+(tr*(fxc)))*(1.0f-fyc) + ((bl*(1.0f-fxc))+(br*(fxc)))*(fyc);
}
} }
bool ignoreNextResult = false; Gravity::~Gravity()
void Gravity::Clear()
{
std::fill(gravy, gravy+((XRES/CELL)*(YRES/CELL)), 0.0f);
std::fill(gravx, gravx+((XRES/CELL)*(YRES/CELL)), 0.0f);
std::fill(gravp, gravp+((XRES/CELL)*(YRES/CELL)), 0.0f);
std::fill(gravmap, gravmap+((XRES/CELL)*(YRES/CELL)), 0.0f);
std::fill(gravmask, gravmask+((XRES/CELL)*(YRES/CELL)), 0xFFFFFFFF);
ignoreNextResult = true;
}
void Gravity::gravity_init()
{
ngrav_enable = 0;
//Allocate full size Gravmaps
th_ogravmap = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
th_gravmap = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
th_gravy = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
th_gravx = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
th_gravp = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravmap = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravy = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravx = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravp = (float *)calloc((XRES/CELL)*(YRES/CELL), sizeof(float));
gravmask = (unsigned int *)calloc((XRES/CELL)*(YRES/CELL), sizeof(unsigned));
obmap = (unsigned char (*)[XRES/CELL])calloc((XRES/CELL)*(YRES/CELL), sizeof(unsigned char));
}
void Gravity::gravity_cleanup()
{ {
stop_grav_async(); stop_grav_async();
#ifdef GRAVFFT #ifdef GRAVFFT
grav_fft_cleanup(); grav_fft_cleanup();
#endif #endif
//Free gravity info
free(th_ogravmap); delete[] th_ogravmap;
free(th_gravmap); delete[] th_gravmap;
free(th_gravy); delete[] th_gravy;
free(th_gravx); delete[] th_gravx;
free(th_gravp); delete[] th_gravp;
free(gravmap); delete[] gravmap;
free(gravy); delete[] gravy;
free(gravx); delete[] gravx;
free(gravp); delete[] gravp;
free(gravmask); delete[] gravmask;
free(obmap);
} }
void Gravity::gravity_update_async() void Gravity::Clear()
{ {
int result; int size = (XRES / CELL) * (YRES / CELL);
if (ngrav_enable) std::fill(gravy, gravy + size, 0.0f);
{ std::fill(gravx, gravx + size, 0.0f);
bool signal_grav = false; std::fill(gravp, gravp + size, 0.0f);
std::fill(gravmap, gravmap + size, 0.0f);
std::fill(gravmask, gravmask + size, 0xFFFFFFFF);
{ ignoreNextResult = true;
std::unique_lock<std::mutex> l(gravmutex, std::defer_lock);
if (l.try_lock())
{
result = grav_ready;
if (result) //Did the gravity thread finish?
{
float *tmpf;
if (th_gravchanged && !ignoreNextResult)
{
#if !defined(GRAVFFT) && defined(GRAV_DIFF)
memcpy(gravy, th_gravy, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memcpy(gravx, th_gravx, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memcpy(gravp, th_gravp, (XRES/CELL)*(YRES/CELL)*sizeof(float));
#else
tmpf = gravy;
gravy = th_gravy;
th_gravy = tmpf;
tmpf = gravx;
gravx = th_gravx;
th_gravx = tmpf;
tmpf = gravp;
gravp = th_gravp;
th_gravp = tmpf;
#endif
}
ignoreNextResult = false;
tmpf = gravmap;
gravmap = th_gravmap;
th_gravmap = tmpf;
grav_ready = 0; //Tell the other thread that we're ready for it to continue
signal_grav = true;
}
}
}
if (signal_grav)
{
gravcv.notify_one();
}
//Apply the gravity mask
membwand(gravy, gravmask, (XRES/CELL)*(YRES/CELL)*sizeof(float), (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
membwand(gravx, gravmask, (XRES/CELL)*(YRES/CELL)*sizeof(float), (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
memset(gravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
}
}
void Gravity::update_grav_async()
{
int done = 0;
int thread_done = 0;
memset(th_ogravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(th_gravp, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
//memset(th_gravy, 0, XRES*YRES*sizeof(float));
//memset(th_gravx, 0, XRES*YRES*sizeof(float));
//memset(th_gravp, 0, XRES*YRES*sizeof(float));
#ifdef GRAVFFT
if (!grav_fft_status)
grav_fft_init();
#endif
std::unique_lock<std::mutex> l(gravmutex);
while (!thread_done)
{
if (!done)
{
// run gravity update
update_grav();
done = 1;
grav_ready = 1;
thread_done = gravthread_done;
} else {
// wait for main thread
gravcv.wait(l);
done = grav_ready;
thread_done = gravthread_done;
}
}
}
void Gravity::start_grav_async()
{
if (ngrav_enable) //If it's already enabled, restart it
stop_grav_async();
gravthread_done = 0;
grav_ready = 0;
gravthread = std::thread([this]() { update_grav_async(); }); //Start asynchronous gravity simulation
ngrav_enable = 1;
memset(gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravp, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
}
void Gravity::stop_grav_async()
{
if (ngrav_enable)
{
{
std::lock_guard<std::mutex> g(gravmutex);
gravthread_done = 1;
}
gravcv.notify_one();
gravthread.join();
ngrav_enable = 0;
}
//Clear the grav velocities
memset(gravy, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravx, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravp, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memset(gravmap, 0, (XRES/CELL)*(YRES/CELL)*sizeof(float));
} }
#ifdef GRAVFFT #ifdef GRAVFFT
void Gravity::grav_fft_init() void Gravity::grav_fft_init()
{ {
int xblock2 = XRES/CELL*2; int xblock2 = XRES/CELL*2;
int yblock2 = YRES/CELL*2; int yblock2 = YRES/CELL*2;
int x, y, fft_tsize = (xblock2/2+1)*yblock2; int fft_tsize = (xblock2/2+1)*yblock2;
float distance, scaleFactor; float distance, scaleFactor;
fftwf_plan plan_ptgravx, plan_ptgravy; fftwf_plan plan_ptgravx, plan_ptgravy;
if (grav_fft_status) return; if (grav_fft_status) return;
//use fftw malloc function to ensure arrays are aligned, to get better performance //use fftw malloc function to ensure arrays are aligned, to get better performance
th_ptgravx = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_ptgravx = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_ptgravy = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_ptgravy = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_ptgravxt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_ptgravxt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_ptgravyt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_ptgravyt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_gravmapbig = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_gravmapbig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravmapbigt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_gravmapbigt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_gravxbig = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_gravxbig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravybig = (float*)fftwf_malloc(xblock2*yblock2*sizeof(float)); th_gravybig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravxbigt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_gravxbigt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_gravybigt = (fftwf_complex*)fftwf_malloc(fft_tsize*sizeof(fftwf_complex)); th_gravybigt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
//select best algorithm, could use FFTW_PATIENT or FFTW_EXHAUSTIVE but that increases the time taken to plan, and I don't see much increase in execution speed //select best algorithm, could use FFTW_PATIENT or FFTW_EXHAUSTIVE but that increases the time taken to plan, and I don't see much increase in execution speed
plan_ptgravx = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_ptgravx, th_ptgravxt, FFTW_MEASURE); plan_ptgravx = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_ptgravx, th_ptgravxt, FFTW_MEASURE);
@ -247,18 +89,19 @@ void Gravity::grav_fft_init()
//(XRES/CELL)*(YRES/CELL)*4 is size of data array, scaling needed because FFTW calculates an unnormalized DFT //(XRES/CELL)*(YRES/CELL)*4 is size of data array, scaling needed because FFTW calculates an unnormalized DFT
scaleFactor = -M_GRAV/((XRES/CELL)*(YRES/CELL)*4); scaleFactor = -M_GRAV/((XRES/CELL)*(YRES/CELL)*4);
//calculate velocity map caused by a point mass //calculate velocity map caused by a point mass
for (y=0; y<yblock2; y++) for (int y = 0; y < yblock2; y++)
{ {
for (x=0; x<xblock2; x++) for (int x = 0; x < xblock2; x++)
{ {
if (x==XRES/CELL && y==YRES/CELL) continue; if (x == XRES / CELL && y == YRES / CELL)
continue;
distance = sqrtf(pow(x-(XRES/CELL), 2.0f) + pow(y-(YRES/CELL), 2.0f)); distance = sqrtf(pow(x-(XRES/CELL), 2.0f) + pow(y-(YRES/CELL), 2.0f));
th_ptgravx[y*xblock2+x] = scaleFactor*(x-(XRES/CELL)) / pow(distance, 3.0f); th_ptgravx[y * xblock2 + x] = scaleFactor * (x - (XRES / CELL)) / pow(distance, 3);
th_ptgravy[y*xblock2+x] = scaleFactor*(y-(YRES/CELL)) / pow(distance, 3.0f); th_ptgravy[y * xblock2 + x] = scaleFactor * (y - (YRES / CELL)) / pow(distance, 3);
} }
} }
th_ptgravx[yblock2*xblock2/2+xblock2/2] = 0.0f; th_ptgravx[yblock2 * xblock2 / 2 + xblock2 / 2] = 0.0f;
th_ptgravy[yblock2*xblock2/2+xblock2/2] = 0.0f; th_ptgravy[yblock2 * xblock2 / 2 + xblock2 / 2] = 0.0f;
//transform point mass velocity maps //transform point mass velocity maps
fftwf_execute(plan_ptgravx); fftwf_execute(plan_ptgravx);
@ -269,7 +112,7 @@ void Gravity::grav_fft_init()
fftwf_free(th_ptgravy); fftwf_free(th_ptgravy);
//clear padded gravmap //clear padded gravmap
memset(th_gravmapbig,0,xblock2*yblock2*sizeof(float)); memset(th_gravmapbig, 0, xblock2 * yblock2 * sizeof(float));
grav_fft_status = true; grav_fft_status = true;
} }
@ -290,34 +133,144 @@ void Gravity::grav_fft_cleanup()
fftwf_destroy_plan(plan_gravy_inverse); fftwf_destroy_plan(plan_gravy_inverse);
grav_fft_status = false; grav_fft_status = false;
} }
#endif
void Gravity::update_grav() void Gravity::gravity_update_async()
{ {
int x, y, changed = 0; int result;
int xblock2 = XRES/CELL*2, yblock2 = YRES/CELL*2; if (!enabled)
int i, fft_tsize = (xblock2/2+1)*yblock2; return;
float mr, mc, pr, pc, gr, gc;
for (y=0; y<YRES/CELL; y++) bool signal_grav = false;
{ {
if(changed) std::unique_lock<std::mutex> l(gravmutex, std::defer_lock);
break; if (l.try_lock())
for (x=0; x<XRES/CELL; x++)
{ {
if(th_ogravmap[y*(XRES/CELL)+x] != th_gravmap[y*(XRES/CELL)+x] || bmap[y][x] != obmap[y][x]){ result = grav_ready;
changed = 1; if (result) //Did the gravity thread finish?
break; {
if (th_gravchanged && !ignoreNextResult)
{
#if !defined(GRAVFFT) && defined(GRAV_DIFF)
memcpy(gravy, th_gravy, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memcpy(gravx, th_gravx, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memcpy(gravp, th_gravp, (XRES/CELL)*(YRES/CELL)*sizeof(float));
#else
std::swap(gravy, th_gravy);
std::swap(gravx, th_gravx);
std::swap(gravp, th_gravp);
#endif
}
ignoreNextResult = false;
std::swap(gravmap, th_gravmap);
grav_ready = 0; //Tell the other thread that we're ready for it to continue
signal_grav = true;
} }
} }
} }
if(changed)
if (signal_grav)
{
gravcv.notify_one();
}
unsigned int size = (XRES / CELL) * (YRES / CELL);
membwand(gravy, gravmask, size * sizeof(float), size * sizeof(unsigned));
membwand(gravx, gravmask, size * sizeof(float), size * sizeof(unsigned));
std::fill(&gravmap[0], &gravmap[size], 0);
}
void Gravity::update_grav_async()
{
int done = 0;
int thread_done = 0;
unsigned int size = (XRES / CELL) * (YRES / CELL);
std::fill(&th_ogravmap[0], &th_ogravmap[size], 0);
std::fill(&th_gravmap[0], &th_gravmap[size], 0);
std::fill(&th_gravy[0], &th_gravy[size], 0);
std::fill(&th_gravx[0], &th_gravx[size], 0);
std::fill(&th_gravp[0], &th_gravp[size], 0);
#ifdef GRAVFFT
if (!grav_fft_status)
grav_fft_init();
#endif
std::unique_lock<std::mutex> l(gravmutex);
while (!thread_done)
{
if (!done)
{
// run gravity update
update_grav();
done = 1;
grav_ready = 1;
thread_done = gravthread_done;
}
else
{
// wait for main thread
gravcv.wait(l);
done = grav_ready;
thread_done = gravthread_done;
}
}
}
void Gravity::start_grav_async()
{
if (enabled) //If it's already enabled, restart it
stop_grav_async();
gravthread_done = 0;
grav_ready = 0;
gravthread = std::thread([this]() { update_grav_async(); }); //Start asynchronous gravity simulation
enabled = true;
unsigned int size = (XRES / CELL) * (YRES / CELL);
std::fill(&gravy[0], &gravy[size], 0);
std::fill(&gravx[0], &gravx[size], 0);
std::fill(&gravp[0], &gravp[size], 0);
std::fill(&gravmap[0], &gravmap[size], 0);
}
void Gravity::stop_grav_async()
{
if (enabled)
{
{
std::lock_guard<std::mutex> g(gravmutex);
gravthread_done = 1;
}
gravcv.notify_one();
gravthread.join();
enabled = false;
}
// Clear the grav velocities
unsigned int size = (XRES / CELL) * (YRES / CELL);
std::fill(&gravy[0], &gravy[size], 0);
std::fill(&gravx[0], &gravx[size], 0);
std::fill(&gravp[0], &gravp[size], 0);
std::fill(&gravmap[0], &gravmap[size], 0);
}
#ifdef GRAVFFT
void Gravity::update_grav()
{
int xblock2 = XRES/CELL*2, yblock2 = YRES/CELL*2;
int fft_tsize = (xblock2/2+1)*yblock2;
float mr, mc, pr, pc, gr, gc;
if (memcmp(th_ogravmap, th_gravmap, sizeof(float)*(XRES/CELL)*(YRES/CELL)) != 0)
{ {
th_gravchanged = 1; th_gravchanged = 1;
membwand(th_gravmap, gravmask, (XRES/CELL)*(YRES/CELL)*sizeof(float), (XRES/CELL)*(YRES/CELL)*sizeof(unsigned)); membwand(th_gravmap, gravmask, (XRES/CELL)*(YRES/CELL)*sizeof(float), (XRES/CELL)*(YRES/CELL)*sizeof(unsigned));
//copy gravmap into padded gravmap array //copy gravmap into padded gravmap array
for (y=0; y<YRES/CELL; y++) for (int y = 0; y < YRES / CELL; y++)
{ {
for (x=0; x<XRES/CELL; x++) for (int x = 0; x < XRES / CELL; x++)
{ {
th_gravmapbig[(y+YRES/CELL)*xblock2+XRES/CELL+x] = th_gravmap[y*(XRES/CELL)+x]; th_gravmapbig[(y+YRES/CELL)*xblock2+XRES/CELL+x] = th_gravmap[y*(XRES/CELL)+x];
} }
@ -325,7 +278,7 @@ void Gravity::update_grav()
//transform gravmap //transform gravmap
fftwf_execute(plan_gravmap); fftwf_execute(plan_gravmap);
//do convolution (multiply the complex numbers) //do convolution (multiply the complex numbers)
for (i=0; i<fft_tsize; i++) for (int i = 0; i < fft_tsize; i++)
{ {
mr = th_gravmapbigt[i][0]; mr = th_gravmapbigt[i][0];
mc = th_gravmapbigt[i][1]; mc = th_gravmapbigt[i][1];
@ -345,9 +298,9 @@ void Gravity::update_grav()
//inverse transform, and copy from padded arrays into normal velocity maps //inverse transform, and copy from padded arrays into normal velocity maps
fftwf_execute(plan_gravx_inverse); fftwf_execute(plan_gravx_inverse);
fftwf_execute(plan_gravy_inverse); fftwf_execute(plan_gravy_inverse);
for (y=0; y<YRES/CELL; y++) for (int y = 0; y < YRES / CELL; y++)
{ {
for (x=0; x<XRES/CELL; x++) for (int x = 0; x < XRES / CELL; x++)
{ {
th_gravx[y*(XRES/CELL)+x] = th_gravxbig[y*xblock2+x]; th_gravx[y*(XRES/CELL)+x] = th_gravxbig[y*xblock2+x];
th_gravy[y*(XRES/CELL)+x] = th_gravybig[y*xblock2+x]; th_gravy[y*(XRES/CELL)+x] = th_gravybig[y*xblock2+x];
@ -359,8 +312,9 @@ void Gravity::update_grav()
{ {
th_gravchanged = 0; th_gravchanged = 0;
} }
memcpy(th_ogravmap, th_gravmap, (XRES/CELL)*(YRES/CELL)*sizeof(float));
memcpy(obmap, bmap, (XRES/CELL)*(YRES/CELL)*sizeof(unsigned char)); // Copy th_ogravmap into th_gravmap (doesn't matter what th_ogravmap is afterwards)
std::swap(th_gravmap, th_ogravmap);
} }
#else #else
@ -427,121 +381,147 @@ fin:
void Gravity::grav_mask_r(int x, int y, char checkmap[YRES/CELL][XRES/CELL], char shape[YRES/CELL][XRES/CELL], char *shapeout) bool Gravity::grav_mask_r(int x, int y, char checkmap[YRES/CELL][XRES/CELL], char shape[YRES/CELL][XRES/CELL])
{ {
if(x < 0 || x >= XRES/CELL || y < 0 || y >= YRES/CELL) int x1, x2;
return; bool ret = false;
if(x == 0 || y ==0 || y == (YRES/CELL)-1 || x == (XRES/CELL)-1) try
*shapeout = 1;
int x1 = x, x2 = x;
while (x1 >= 1)
{ {
if(checkmap[y][x1-1] || bmap[y][x1-1]==WL_GRAV) CoordStack cs;
break; cs.push(x, y);
x1--; do
{
cs.pop(x, y);
x1 = x2 = x;
while (x1 >= 0)
{
if (x1 == 0)
{
ret = true;
break;
}
else if (checkmap[y][x1-1] || bmap[y][x1-1] == WL_GRAV)
break;
x1--;
}
while (x2 <= XRES/CELL-1)
{
if (x2 == XRES/CELL-1)
{
ret = true;
break;
}
else if (checkmap[y][x2+1] || bmap[y][x2+1] == WL_GRAV)
break;
x2++;
}
for (x = x1; x <= x2; x++)
{
shape[y][x] = 1;
checkmap[y][x] = 1;
}
if (y == 0)
{
for (x = x1; x <= x2; x++)
if (bmap[y][x] != WL_GRAV)
ret = true;
}
else if (y >= 1)
{
for (x = x1; x <= x2; x++)
if (!checkmap[y-1][x] && bmap[y-1][x] != WL_GRAV)
{
if (y-1 == 0)
ret = true;
cs.push(x, y-1);
}
}
if (y < YRES/CELL-1)
for (x=x1; x<=x2; x++)
if (!checkmap[y+1][x] && bmap[y+1][x] != WL_GRAV)
{
if (y+1 == YRES/CELL-1)
ret = true;
cs.push(x, y+1);
}
} while (cs.getSize()>0);
} }
while (x2 < (XRES/CELL)-1) catch (std::exception& e)
{ {
if(checkmap[y][x2+1] || bmap[y][x2+1]==WL_GRAV) std::cerr << e.what() << std::endl;
break; ret = false;
x2++;
} }
return ret;
// fill span
for (x = x1; x <= x2; x++)
checkmap[y][x] = shape[y][x] = 1;
if(y >= 1)
for(x = x1; x <= x2; x++)
if(!checkmap[y-1][x] && bmap[y-1][x]!=WL_GRAV)
grav_mask_r(x, y-1, checkmap, shape, shapeout);
if(y < (YRES/CELL)-1)
for(x = x1; x <= x2; x++)
if(!checkmap[y+1][x] && bmap[y+1][x]!=WL_GRAV)
grav_mask_r(x, y+1, checkmap, shape, shapeout);
return;
} }
void Gravity::mask_free(mask_el *c_mask_el){ void Gravity::mask_free(mask_el *c_mask_el)
if(c_mask_el==NULL) {
if (c_mask_el == nullptr)
return; return;
if(c_mask_el->next!=NULL) delete[] c_mask_el->next;
mask_free((mask_el*)c_mask_el->next); delete[] c_mask_el->shape;
free(c_mask_el->shape); delete[] c_mask_el;
free(c_mask_el);
} }
void Gravity::gravity_mask() void Gravity::gravity_mask()
{ {
char checkmap[YRES/CELL][XRES/CELL]; char checkmap[YRES/CELL][XRES/CELL];
int x = 0, y = 0;
unsigned maskvalue; unsigned maskvalue;
mask_el *t_mask_el = NULL; mask_el *t_mask_el = nullptr;
mask_el *c_mask_el = NULL; mask_el *c_mask_el = nullptr;
if(!gravmask) if (!gravmask)
return; return;
memset(checkmap, 0, sizeof(checkmap)); memset(checkmap, 0, sizeof(checkmap));
for(x = 0; x < XRES/CELL; x++) for (int x = 0; x < XRES / CELL; x++)
{ {
for(y = 0; y < YRES/CELL; y++) for(int y = 0; y < YRES / CELL; y++)
{ {
if(bmap[y][x]!=WL_GRAV && checkmap[y][x] == 0) if (bmap[y][x] != WL_GRAV && checkmap[y][x] == 0)
{ {
//Create a new shape // Create a new shape
if(t_mask_el==NULL){ if (t_mask_el == nullptr)
t_mask_el = (mask_el *)malloc(sizeof(mask_el)); {
t_mask_el->shape = (char *)malloc((XRES/CELL)*(YRES/CELL)); t_mask_el = new mask_el[sizeof(mask_el)];
memset(t_mask_el->shape, 0, (XRES/CELL)*(YRES/CELL)); t_mask_el->shape = new char[(XRES / CELL) * (YRES / CELL)];
std::fill(&t_mask_el->shape[0], &t_mask_el->shape[(XRES / CELL) * (YRES / CELL)], 0);
t_mask_el->shapeout = 0; t_mask_el->shapeout = 0;
t_mask_el->next = NULL; t_mask_el->next = nullptr;
c_mask_el = t_mask_el; c_mask_el = t_mask_el;
} else {
c_mask_el->next = (mask_el *)malloc(sizeof(mask_el));
c_mask_el = (mask_el *)c_mask_el->next;
c_mask_el->shape = (char *)malloc((XRES/CELL)*(YRES/CELL));
memset(c_mask_el->shape, 0, (XRES/CELL)*(YRES/CELL));
c_mask_el->shapeout = 0;
c_mask_el->next = NULL;
} }
//Fill the shape else
grav_mask_r(x, y, (char (*)[XRES/CELL])checkmap, (char (*)[XRES/CELL])c_mask_el->shape, (char*)&c_mask_el->shapeout); {
c_mask_el->next = new mask_el[sizeof(mask_el)];
c_mask_el = c_mask_el->next;
c_mask_el->shape = new char[(XRES / CELL) * (YRES / CELL)];
std::fill(&c_mask_el->shape[0], &c_mask_el->shape[(XRES / CELL) * (YRES / CELL)], 0);
c_mask_el->shapeout = 0;
c_mask_el->next = nullptr;
}
// Fill the shape
if (grav_mask_r(x, y, checkmap, reinterpret_cast<char(*)[XRES/CELL]>(c_mask_el->shape)))
c_mask_el->shapeout = 1;
} }
} }
} }
c_mask_el = t_mask_el; c_mask_el = t_mask_el;
memset(gravmask, 0, (XRES/CELL)*(YRES/CELL)*sizeof(unsigned)); std::fill(&gravmask[0], &gravmask[(XRES / CELL) * (YRES / CELL)], 0);
while(c_mask_el!=NULL) while (c_mask_el != nullptr)
{ {
char *cshape = c_mask_el->shape; char *cshape = c_mask_el->shape;
for(x = 0; x < XRES/CELL; x++) for (int x = 0; x < XRES / CELL; x++)
{ {
for(y = 0; y < YRES/CELL; y++) for (int y = 0; y < YRES / CELL; y++)
{ {
if(cshape[y*(XRES/CELL)+x]){ if (cshape[y * (XRES / CELL) + x])
if(c_mask_el->shapeout) {
if (c_mask_el->shapeout)
maskvalue = 0xFFFFFFFF; maskvalue = 0xFFFFFFFF;
else else
maskvalue = 0x00000000; maskvalue = 0x00000000;
gravmask[y*(XRES/CELL)+x] = maskvalue; gravmask[y * (XRES / CELL) + x] = maskvalue;
} }
} }
} }
c_mask_el = (mask_el*)c_mask_el->next; c_mask_el = c_mask_el->next;
} }
mask_free(t_mask_el); mask_free(t_mask_el);
} }
#ifdef GRAVFFT
Gravity::Gravity():
grav_fft_status(false)
{
gravity_init();
}
#else
Gravity::Gravity()
{
gravity_init();
}
#endif
Gravity::~Gravity()
{
gravity_cleanup();
}

105
src/simulation/Gravity.h
View File

@ -12,90 +12,81 @@
class Simulation; class Simulation;
struct mask_el {
char *shape;
char shapeout;
void *next;
};
typedef struct mask_el mask_el;
class Gravity class Gravity
{ {
private: private:
float *th_ogravmap; bool enabled = false;
float *th_gravmap;
float *th_gravx;
float *th_gravy;
float *th_gravp;
int th_gravchanged; // Maps to be processed by the gravity thread
float *th_ogravmap = nullptr;
float *th_gravmap = nullptr;
float *th_gravx = nullptr;
float *th_gravy = nullptr;
float *th_gravp = nullptr;
int th_gravchanged = 0;
std::thread gravthread; std::thread gravthread;
std::mutex gravmutex; std::mutex gravmutex;
std::condition_variable gravcv; std::condition_variable gravcv;
int grav_ready; int grav_ready = 0;
int gravthread_done; int gravthread_done = 0;
bool ignoreNextResult = false;
#ifdef GRAVFFT #ifdef GRAVFFT
bool grav_fft_status; bool grav_fft_status = false;
float *th_ptgravx, *th_ptgravy, *th_gravmapbig, *th_gravxbig, *th_gravybig; float *th_ptgravx = nullptr;
float *th_ptgravy = nullptr;
float *th_gravmapbig = nullptr;
float *th_gravxbig = nullptr;
float *th_gravybig = nullptr;
fftwf_complex *th_ptgravxt, *th_ptgravyt, *th_gravmapbigt, *th_gravxbigt, *th_gravybigt; fftwf_complex *th_ptgravxt, *th_ptgravyt, *th_gravmapbigt, *th_gravxbigt, *th_gravybigt;
fftwf_plan plan_gravmap, plan_gravx_inverse, plan_gravy_inverse; fftwf_plan plan_gravmap, plan_gravx_inverse, plan_gravy_inverse;
#endif #endif
//Simulation * sim; struct mask_el {
public: char *shape;
unsigned *gravmask; char shapeout;
float *gravmap; mask_el *next;
float *gravp; };
float *gravy; using mask_el = struct mask_el;
float *gravx;
unsigned char (*bmap)[XRES/CELL]; bool grav_mask_r(int x, int y, char checkmap[YRES/CELL][XRES/CELL], char shape[YRES/CELL][XRES/CELL]);
unsigned char (*obmap)[XRES/CELL];
int ngrav_enable;
void grav_mask_r(int x, int y, char checkmap[YRES/CELL][XRES/CELL], char shape[YRES/CELL][XRES/CELL], char *shapeout);
void mask_free(mask_el *c_mask_el); void mask_free(mask_el *c_mask_el);
void update_grav();
void update_grav_async();
#ifdef GRAVFFT
void grav_fft_init();
void grav_fft_cleanup();
#endif
public:
//Maps to be used by the main thread
float *gravmap = nullptr;
float *gravp = nullptr;
float *gravy = nullptr;
float *gravx = nullptr;
unsigned *gravmask = nullptr;
unsigned char (*bmap)[XRES/CELL];
bool IsEnabled() { return enabled; }
void Clear(); void Clear();
void gravity_init();
void gravity_cleanup();
void gravity_update_async(); void gravity_update_async();
void update_grav_async();
void start_grav_async(); void start_grav_async();
void stop_grav_async(); void stop_grav_async();
void update_grav();
void gravity_mask(); void gravity_mask();
void bilinear_interpolation(float *src, float *dst, int sw, int sh, int rw, int rh);
#ifdef GRAVFFT
void grav_fft_init();
void grav_fft_cleanup();
#endif
Gravity(); Gravity();
~Gravity(); ~Gravity();
}; };
/*extern int ngrav_enable; //Newtonian gravity
extern int gravwl_timeout;
extern int gravityMode;*/
/*float *gravmap;//Maps to be used by the main thread
float *gravp;
float *gravy;
float *gravx;
unsigned *gravmask;
float *th_ogravmap;// Maps to be processed by the gravity thread
float *th_gravmap;
float *th_gravx;
float *th_gravy;
float *th_gravp;*/
#endif #endif

10
src/simulation/Simulation.cpp
View File

@ -492,7 +492,7 @@ void Simulation::SaveSimOptions(GameSave * gameSave)
gameSave->edgeMode = edgeMode; gameSave->edgeMode = edgeMode;
gameSave->legacyEnable = legacy_enable; gameSave->legacyEnable = legacy_enable;
gameSave->waterEEnabled = water_equal_test; gameSave->waterEEnabled = water_equal_test;
gameSave->gravityEnable = grav->ngrav_enable; gameSave->gravityEnable = grav->IsEnabled();
gameSave->aheatEnable = aheat_enable; gameSave->aheatEnable = aheat_enable;
} }
@ -538,7 +538,7 @@ void Simulation::Restore(const Snapshot & snap)
RecalcFreeParticles(false); RecalcFreeParticles(false);
std::copy(snap.PortalParticles.begin(), snap.PortalParticles.end(), &portalp[0][0][0]); std::copy(snap.PortalParticles.begin(), snap.PortalParticles.end(), &portalp[0][0][0]);
std::copy(snap.WirelessData.begin(), snap.WirelessData.end(), &wireless[0][0]); std::copy(snap.WirelessData.begin(), snap.WirelessData.end(), &wireless[0][0]);
if (grav->ngrav_enable) if (grav->IsEnabled())
{ {
grav->Clear(); grav->Clear();
std::copy(snap.GravVelocityX.begin(), snap.GravVelocityX.end(), gravx); std::copy(snap.GravVelocityX.begin(), snap.GravVelocityX.end(), gravx);
@ -702,7 +702,7 @@ SimulationSample Simulation::GetSample(int x, int y)
sample.AirVelocityX = vx[y/CELL][x/CELL]; sample.AirVelocityX = vx[y/CELL][x/CELL];
sample.AirVelocityY = vy[y/CELL][x/CELL]; sample.AirVelocityY = vy[y/CELL][x/CELL];
if(grav->ngrav_enable) if(grav->IsEnabled())
{ {
sample.Gravity = gravp[(y/CELL)*(XRES/CELL)+(x/CELL)]; sample.Gravity = gravp[(y/CELL)*(XRES/CELL)+(x/CELL)];
sample.GravityVelocityX = gravx[(y/CELL)*(XRES/CELL)+(x/CELL)]; sample.GravityVelocityX = gravx[(y/CELL)*(XRES/CELL)+(x/CELL)];
@ -4702,7 +4702,7 @@ killed:
goto movedone; goto movedone;
} }
} }
if (elements[t].Falldown>1 && !grav->ngrav_enable && gravityMode==0 && parts[i].vy>fabsf(parts[i].vx)) if (elements[t].Falldown>1 && !grav->IsEnabled() && gravityMode==0 && parts[i].vy>fabsf(parts[i].vx))
{ {
s = 0; s = 0;
// stagnant is true if FLAG_STAGNANT was set for this particle in previous frame // stagnant is true if FLAG_STAGNANT was set for this particle in previous frame
@ -5209,7 +5209,7 @@ void Simulation::BeforeSim()
if(aheat_enable) if(aheat_enable)
air->update_airh(); air->update_airh();
if(grav->ngrav_enable) if(grav->IsEnabled())
{ {
grav->gravity_update_async(); grav->gravity_update_async();