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

Preprocessor purge round 11: GRAVFFT

Browse Source 
By splitting gravity implementations into separate translation units.
This commit is contained in:
Tamás Bálint Misius 2023-01-08 13:10:16 +01:00
parent dc8d63fb15
commit 9068920de3
No known key found for this signature in database
GPG Key ID: 5B472A12F6ECA9F2
14 changed files with 294 additions and 257 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
meson.build
View File

@ -350,6 +350,7 @@ conf_data.set('APPID', app_id)
conf_data.set('APPDATA', get_option('app_data'))
conf_data.set('APPVENDOR', get_option('app_vendor'))
conf_data.set('LUACONSOLE', lua_variant != 'none' ? 'true' : 'false')
conf_data.set('GRAVFFT', enable_gravfft ? 'true' : 'false')
data_files = []

2
src/Config.template.h
View File

@ -3,7 +3,6 @@
// Boolean macros (defined / not defined), would be great to get rid of them all.
#mesondefine NOHTTP
#mesondefine GRAVFFT
#mesondefine RENDERER
#mesondefine FONTEDITOR
#mesondefine BETA
@ -16,6 +15,7 @@
#mesondefine MACOSX
#mesondefine X86
constexpr bool GRAVFFT = @GRAVFFT@;
constexpr bool LUACONSOLE = @LUACONSOLE@;
constexpr bool ALLOW_FAKE_NEWER_VERSION = @ALLOW_FAKE_NEWER_VERSION@;
constexpr bool USE_UPDATESERVER = @USE_UPDATESERVER@;

1
src/config/font/meson.build
View File

@ -2,7 +2,6 @@ font_conf_data = conf_data
font_conf_data.set('FONTEDITOR', true)
font_conf_data.set('RENDERER', false)
font_conf_data.set('NOHTTP', true)
font_conf_data.set('GRAVFFT', false)
configure_file(
input: config_template,
output: 'Config.h',

1
src/config/powder/meson.build
View File

@ -2,7 +2,6 @@ powder_conf_data = conf_data
powder_conf_data.set('FONTEDITOR', false)
powder_conf_data.set('RENDERER', false)
powder_conf_data.set('NOHTTP', not enable_http)
powder_conf_data.set('GRAVFFT', enable_gravfft)
configure_file(
input: config_template,
output: 'Config.h',

1
src/config/render/meson.build
View File

@ -2,7 +2,6 @@ render_conf_data = conf_data
render_conf_data.set('FONTEDITOR', false)
render_conf_data.set('RENDERER', true)
render_conf_data.set('NOHTTP', true)
render_conf_data.set('GRAVFFT', false)
configure_file(
input: config_template,
output: 'Config.h',

5
src/gui/game/IntroText.h
View File

@ -45,9 +45,10 @@ inline ByteString IntroText()
{
sb << " LUACONSOLE";
}
#ifdef GRAVFFT
if constexpr (GRAVFFT)
{
sb << " GRAVFFT";
#endif
}
#ifdef REALISTIC
sb << " REALISTIC";
#endif

202
src/simulation/FftGravity.cpp Normal file
View File

@ -0,0 +1,202 @@
#include "Gravity.h"
#include "Misc.h"
#include <cstring>
#include <cmath>
#include <fftw3.h>
struct FftGravity : public Gravity
{
bool grav_fft_status = false;
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_plan plan_gravmap, plan_gravx_inverse, plan_gravy_inverse;
void grav_fft_init();
void grav_fft_cleanup();
FftGravity() : Gravity(CtorTag{})
{
}
~FftGravity();
};
FftGravity::~FftGravity()
{
stop_grav_async();
grav_fft_cleanup();
}
void FftGravity::grav_fft_init()
{
int xblock2 = XCELLS*2;
int yblock2 = YCELLS*2;
int fft_tsize = (xblock2/2+1)*yblock2;
float distance, scaleFactor;
fftwf_plan plan_ptgravx, plan_ptgravy;
if (grav_fft_status) return;
//use fftw malloc function to ensure arrays are aligned, to get better performance
th_ptgravx = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_ptgravy = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_ptgravxt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_ptgravyt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_gravmapbig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravmapbigt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_gravxbig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravybig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravxbigt = reinterpret_cast<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
plan_ptgravx = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_ptgravx, th_ptgravxt, FFTW_MEASURE);
plan_ptgravy = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_ptgravy, th_ptgravyt, FFTW_MEASURE);
plan_gravmap = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_gravmapbig, th_gravmapbigt, FFTW_MEASURE);
plan_gravx_inverse = fftwf_plan_dft_c2r_2d(yblock2, xblock2, th_gravxbigt, th_gravxbig, FFTW_MEASURE);
plan_gravy_inverse = fftwf_plan_dft_c2r_2d(yblock2, xblock2, th_gravybigt, th_gravybig, FFTW_MEASURE);
//NCELL*4 is size of data array, scaling needed because FFTW calculates an unnormalized DFT
scaleFactor = -float(M_GRAV)/(NCELL*4);
//calculate velocity map caused by a point mass
for (int y = 0; y < yblock2; y++)
{
for (int x = 0; x < xblock2; x++)
{
if (x == XCELLS && y == YCELLS)
continue;
distance = hypotf(float(x-XCELLS), float(y-YCELLS));
th_ptgravx[y * xblock2 + x] = scaleFactor * (x - XCELLS) / powf(distance, 3);
th_ptgravy[y * xblock2 + x] = scaleFactor * (y - YCELLS) / powf(distance, 3);
}
}
th_ptgravx[yblock2 * xblock2 / 2 + xblock2 / 2] = 0.0f;
th_ptgravy[yblock2 * xblock2 / 2 + xblock2 / 2] = 0.0f;
//transform point mass velocity maps
fftwf_execute(plan_ptgravx);
fftwf_execute(plan_ptgravy);
fftwf_destroy_plan(plan_ptgravx);
fftwf_destroy_plan(plan_ptgravy);
fftwf_free(th_ptgravx);
fftwf_free(th_ptgravy);
//clear padded gravmap
memset(th_gravmapbig, 0, xblock2 * yblock2 * sizeof(float));
grav_fft_status = true;
}
void FftGravity::grav_fft_cleanup()
{
if (!grav_fft_status) return;
fftwf_free(th_ptgravxt);
fftwf_free(th_ptgravyt);
fftwf_free(th_gravmapbig);
fftwf_free(th_gravmapbigt);
fftwf_free(th_gravxbig);
fftwf_free(th_gravybig);
fftwf_free(th_gravxbigt);
fftwf_free(th_gravybigt);
fftwf_destroy_plan(plan_gravmap);
fftwf_destroy_plan(plan_gravx_inverse);
fftwf_destroy_plan(plan_gravy_inverse);
grav_fft_status = false;
}
void Gravity::get_result()
{
std::swap(gravy, th_gravy);
std::swap(gravx, th_gravx);
std::swap(gravp, th_gravp);
}
void Gravity::update_grav()
{
auto *fftGravity = static_cast<FftGravity *>(this);
if (!fftGravity->grav_fft_status)
fftGravity->grav_fft_init();
auto *th_gravmapbig = fftGravity->th_gravmapbig;
auto *th_gravxbig = fftGravity->th_gravxbig;
auto *th_gravybig = fftGravity->th_gravybig;
auto *th_ptgravxt = fftGravity->th_ptgravxt;
auto *th_ptgravyt = fftGravity->th_ptgravyt;
auto *th_gravmapbigt = fftGravity->th_gravmapbigt;
auto *th_gravxbigt = fftGravity->th_gravxbigt;
auto *th_gravybigt = fftGravity->th_gravybigt;
auto &plan_gravmap = fftGravity->plan_gravmap;
auto &plan_gravx_inverse = fftGravity->plan_gravx_inverse;
auto &plan_gravy_inverse = fftGravity->plan_gravy_inverse;
int xblock2 = XCELLS*2, yblock2 = YCELLS*2;
int fft_tsize = (xblock2/2+1)*yblock2;
float mr, mc, pr, pc, gr, gc;
if (memcmp(th_ogravmap, th_gravmap, sizeof(float)*NCELL) != 0)
{
th_gravchanged = 1;
membwand(th_gravmap, gravmask, NCELL*sizeof(float), NCELL*sizeof(unsigned));
//copy gravmap into padded gravmap array
for (int y = 0; y < YCELLS; y++)
{
for (int x = 0; x < XCELLS; x++)
{
th_gravmapbig[(y+YCELLS)*xblock2+XCELLS+x] = th_gravmap[y*XCELLS+x];
}
}
//transform gravmap
fftwf_execute(plan_gravmap);
//do convolution (multiply the complex numbers)
for (int i = 0; i < fft_tsize; i++)
{
mr = th_gravmapbigt[i][0];
mc = th_gravmapbigt[i][1];
pr = th_ptgravxt[i][0];
pc = th_ptgravxt[i][1];
gr = mr*pr-mc*pc;
gc = mr*pc+mc*pr;
th_gravxbigt[i][0] = gr;
th_gravxbigt[i][1] = gc;
pr = th_ptgravyt[i][0];
pc = th_ptgravyt[i][1];
gr = mr*pr-mc*pc;
gc = mr*pc+mc*pr;
th_gravybigt[i][0] = gr;
th_gravybigt[i][1] = gc;
}
//inverse transform, and copy from padded arrays into normal velocity maps
fftwf_execute(plan_gravx_inverse);
fftwf_execute(plan_gravy_inverse);
for (int y = 0; y < YCELLS; y++)
{
for (int x = 0; x < XCELLS; x++)
{
th_gravx[y*XCELLS+x] = th_gravxbig[y*xblock2+x];
th_gravy[y*XCELLS+x] = th_gravybig[y*xblock2+x];
th_gravp[y*XCELLS+x] = hypotf(th_gravxbig[y*xblock2+x], th_gravybig[y*xblock2+x]);
}
}
}
else
{
th_gravchanged = 0;
}
// Copy th_ogravmap into th_gravmap (doesn't matter what th_ogravmap is afterwards)
std::swap(th_gravmap, th_ogravmap);
}
GravityPtr Gravity::Create()
{
return GravityPtr(new FftGravity());
}
void GravityDeleter::operator ()(Gravity *ptr) const
{
delete static_cast<FftGravity *>(ptr);
}

223
src/simulation/Gravity.cpp
View File

@ -9,9 +9,7 @@
#include "Simulation.h"
#include "SimulationData.h"
#define GRAV_DIFF
Gravity::Gravity()
Gravity::Gravity(CtorTag)
{
// Allocate full size Gravmaps
unsigned int size = NCELL;
@ -30,9 +28,6 @@ Gravity::Gravity()
Gravity::~Gravity()
{
stop_grav_async();
#ifdef GRAVFFT
grav_fft_cleanup();
#endif
delete[] th_ogravmap;
delete[] th_gravmap;
@ -58,84 +53,6 @@ void Gravity::Clear()
ignoreNextResult = true;
}
#ifdef GRAVFFT
void Gravity::grav_fft_init()
{
int xblock2 = XCELLS*2;
int yblock2 = YCELLS*2;
int fft_tsize = (xblock2/2+1)*yblock2;
float distance, scaleFactor;
fftwf_plan plan_ptgravx, plan_ptgravy;
if (grav_fft_status) return;
//use fftw malloc function to ensure arrays are aligned, to get better performance
th_ptgravx = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_ptgravy = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_ptgravxt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_ptgravyt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_gravmapbig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravmapbigt = reinterpret_cast<fftwf_complex*>(fftwf_malloc(fft_tsize * sizeof(fftwf_complex)));
th_gravxbig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravybig = reinterpret_cast<float*>(fftwf_malloc(xblock2 * yblock2 * sizeof(float)));
th_gravxbigt = reinterpret_cast<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
plan_ptgravx = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_ptgravx, th_ptgravxt, FFTW_MEASURE);
plan_ptgravy = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_ptgravy, th_ptgravyt, FFTW_MEASURE);
plan_gravmap = fftwf_plan_dft_r2c_2d(yblock2, xblock2, th_gravmapbig, th_gravmapbigt, FFTW_MEASURE);
plan_gravx_inverse = fftwf_plan_dft_c2r_2d(yblock2, xblock2, th_gravxbigt, th_gravxbig, FFTW_MEASURE);
plan_gravy_inverse = fftwf_plan_dft_c2r_2d(yblock2, xblock2, th_gravybigt, th_gravybig, FFTW_MEASURE);
//NCELL*4 is size of data array, scaling needed because FFTW calculates an unnormalized DFT
scaleFactor = -float(M_GRAV)/(NCELL*4);
//calculate velocity map caused by a point mass
for (int y = 0; y < yblock2; y++)
{
for (int x = 0; x < xblock2; x++)
{
if (x == XCELLS && y == YCELLS)
continue;
distance = sqrtf(pow(x-XCELLS, 2.0f) + pow(y-YCELLS, 2.0f));
th_ptgravx[y * xblock2 + x] = scaleFactor * (x - XCELLS) / pow(distance, 3);
th_ptgravy[y * xblock2 + x] = scaleFactor * (y - YCELLS) / pow(distance, 3);
}
}
th_ptgravx[yblock2 * xblock2 / 2 + xblock2 / 2] = 0.0f;
th_ptgravy[yblock2 * xblock2 / 2 + xblock2 / 2] = 0.0f;
//transform point mass velocity maps
fftwf_execute(plan_ptgravx);
fftwf_execute(plan_ptgravy);
fftwf_destroy_plan(plan_ptgravx);
fftwf_destroy_plan(plan_ptgravy);
fftwf_free(th_ptgravx);
fftwf_free(th_ptgravy);
//clear padded gravmap
memset(th_gravmapbig, 0, xblock2 * yblock2 * sizeof(float));
grav_fft_status = true;
}
void Gravity::grav_fft_cleanup()
{
if (!grav_fft_status) return;
fftwf_free(th_ptgravxt);
fftwf_free(th_ptgravyt);
fftwf_free(th_gravmapbig);
fftwf_free(th_gravmapbigt);
fftwf_free(th_gravxbig);
fftwf_free(th_gravybig);
fftwf_free(th_gravxbigt);
fftwf_free(th_gravybigt);
fftwf_destroy_plan(plan_gravmap);
fftwf_destroy_plan(plan_gravx_inverse);
fftwf_destroy_plan(plan_gravy_inverse);
grav_fft_status = false;
}
#endif
void Gravity::gravity_update_async()
{
int result;
@ -153,16 +70,8 @@ void Gravity::gravity_update_async()
{
if (th_gravchanged && !ignoreNextResult)
{
#if !defined(GRAVFFT) && defined(GRAV_DIFF)
memcpy(gravy, th_gravy, NCELL*sizeof(float));
memcpy(gravx, th_gravx, NCELL*sizeof(float));
memcpy(gravp, th_gravp, NCELL*sizeof(float));
#else
// Copy thread gravity maps into this one
std::swap(gravy, th_gravy);
std::swap(gravx, th_gravx);
std::swap(gravp, th_gravp);
#endif
get_result();
}
ignoreNextResult = false;
@ -194,11 +103,6 @@ void Gravity::update_grav_async()
std::fill(&th_gravx[0], &th_gravx[0] + NCELL, 0.0f);
std::fill(&th_gravp[0], &th_gravp[0] + NCELL, 0.0f);
#ifdef GRAVFFT
if (!grav_fft_status)
grav_fft_init();
#endif
std::unique_lock<std::mutex> l(gravmutex);
while (!thread_done)
{
@ -255,129 +159,6 @@ void Gravity::stop_grav_async()
std::fill(&gravmap[0], &gravmap[0] + NCELL, 0.0f);
}
#ifdef GRAVFFT
void Gravity::update_grav()
{
int xblock2 = XCELLS*2, yblock2 = YCELLS*2;
int fft_tsize = (xblock2/2+1)*yblock2;
float mr, mc, pr, pc, gr, gc;
if (memcmp(th_ogravmap, th_gravmap, sizeof(float)*NCELL) != 0)
{
th_gravchanged = 1;
membwand(th_gravmap, gravmask, NCELL*sizeof(float), NCELL*sizeof(unsigned));
//copy gravmap into padded gravmap array
for (int y = 0; y < YCELLS; y++)
{
for (int x = 0; x < XCELLS; x++)
{
th_gravmapbig[(y+YCELLS)*xblock2+XCELLS+x] = th_gravmap[y*XCELLS+x];
}
}
//transform gravmap
fftwf_execute(plan_gravmap);
//do convolution (multiply the complex numbers)
for (int i = 0; i < fft_tsize; i++)
{
mr = th_gravmapbigt[i][0];
mc = th_gravmapbigt[i][1];
pr = th_ptgravxt[i][0];
pc = th_ptgravxt[i][1];
gr = mr*pr-mc*pc;
gc = mr*pc+mc*pr;
th_gravxbigt[i][0] = gr;
th_gravxbigt[i][1] = gc;
pr = th_ptgravyt[i][0];
pc = th_ptgravyt[i][1];
gr = mr*pr-mc*pc;
gc = mr*pc+mc*pr;
th_gravybigt[i][0] = gr;
th_gravybigt[i][1] = gc;
}
//inverse transform, and copy from padded arrays into normal velocity maps
fftwf_execute(plan_gravx_inverse);
fftwf_execute(plan_gravy_inverse);
for (int y = 0; y < YCELLS; y++)
{
for (int x = 0; x < XCELLS; x++)
{
th_gravx[y*XCELLS+x] = th_gravxbig[y*xblock2+x];
th_gravy[y*XCELLS+x] = th_gravybig[y*xblock2+x];
th_gravp[y*XCELLS+x] = sqrtf(pow(th_gravxbig[y*xblock2+x],2)+pow(th_gravybig[y*xblock2+x],2));
}
}
}
else
{
th_gravchanged = 0;
}
// Copy th_ogravmap into th_gravmap (doesn't matter what th_ogravmap is afterwards)
std::swap(th_gravmap, th_ogravmap);
}
#else
// gravity without fast Fourier transforms
void Gravity::update_grav(void)
{
int x, y, i, j;
float val, distance;
th_gravchanged = 0;
#ifndef GRAV_DIFF
//Find any changed cells
for (i=0; i<YCELLS; i++)
{
if(changed)
break;
for (j=0; j<XCELLS; j++)
{
if(th_ogravmap[i*XCELLS+j]!=th_gravmap[i*XCELLS+j]){
changed = 1;
break;
}
}
}
if(!changed)
goto fin;
memset(th_gravy, 0, NCELL*sizeof(float));
memset(th_gravx, 0, NCELL*sizeof(float));
#endif
th_gravchanged = 1;
membwand(th_gravmap, gravmask, NCELL*sizeof(float), NCELL*sizeof(unsigned));
for (i = 0; i < YCELLS; i++) {
for (j = 0; j < XCELLS; j++) {
#ifdef GRAV_DIFF
if (th_ogravmap[i*XCELLS+j] != th_gravmap[i*XCELLS+j])
{
#else
if (th_gravmap[i*XCELLS+j] > 0.0001f || th_gravmap[i*XCELLS+j]<-0.0001f) //Only calculate with populated or changed cells.
{
#endif
for (y = 0; y < YCELLS; y++) {
for (x = 0; x < XCELLS; x++) {
if (x == j && y == i)//Ensure it doesn't calculate with itself
continue;
distance = sqrt(pow(j - x, 2.0f) + pow(i - y, 2.0f));
#ifdef GRAV_DIFF
val = th_gravmap[i*XCELLS+j] - th_ogravmap[i*XCELLS+j];
#else
val = th_gravmap[i*XCELLS+j];
#endif
th_gravx[y*XCELLS+x] += M_GRAV * val * (j - x) / pow(distance, 3.0f);
th_gravy[y*XCELLS+x] += M_GRAV * val * (i - y) / pow(distance, 3.0f);
th_gravp[y*XCELLS+x] += M_GRAV * val / pow(distance, 2.0f);
}
}
}
}
}
memcpy(th_ogravmap, th_gravmap, NCELL*sizeof(float));
}
#endif
bool Gravity::grav_mask_r(int x, int y, char checkmap[YCELLS][XCELLS], char shape[YCELLS][XCELLS])
{
int x1, x2;

36
src/simulation/Gravity.h
View File

@ -1,20 +1,17 @@
#pragma once
#include "Config.h"
#include "GravityPtr.h"
#include <thread>
#include <mutex>
#include <condition_variable>
#ifdef GRAVFFT
#include <fftw3.h>
#endif
#include <memory>
class Simulation;
class Gravity
{
private:
protected:
bool enabled = false;
// Maps to be processed by the gravity thread
@ -33,18 +30,6 @@ private:
int gravthread_done = 0;
bool ignoreNextResult = false;
#ifdef GRAVFFT
bool grav_fft_status = false;
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_plan plan_gravmap, plan_gravx_inverse, plan_gravy_inverse;
#endif
struct mask_el {
char *shape;
char shapeout;
@ -56,15 +41,17 @@ private:
void mask_free(mask_el *c_mask_el);
void update_grav();
void get_result();
void update_grav_async();
#ifdef GRAVFFT
void grav_fft_init();
void grav_fft_cleanup();
#endif
struct CtorTag // Please use Gravity::Create().
{
};
public:
Gravity(CtorTag);
~Gravity();
//Maps to be used by the main thread
float *gravmap = nullptr;
float *gravp = nullptr;
@ -84,6 +71,5 @@ public:
void stop_grav_async();
void gravity_mask();
Gravity();
~Gravity();
static GravityPtr Create();
};

9
src/simulation/GravityPtr.h Normal file
View File

@ -0,0 +1,9 @@
#pragma once
#include <memory>
class Gravity;
struct GravityDeleter
{
void operator ()(Gravity *ptr) const;
};
using GravityPtr = std::unique_ptr<Gravity, GravityDeleter>;

53
src/simulation/PlainGravity.cpp Normal file
View File

@ -0,0 +1,53 @@
#include "Gravity.h"
#include "Misc.h"
#include <cmath>
#include <cstring>
// gravity without fast Fourier transforms
void Gravity::get_result()
{
memcpy(gravy, th_gravy, NCELL*sizeof(float));
memcpy(gravx, th_gravx, NCELL*sizeof(float));
memcpy(gravp, th_gravp, NCELL*sizeof(float));
}
void Gravity::update_grav(void)
{
th_gravchanged = 1;
membwand(th_gravmap, gravmask, NCELL*sizeof(float), NCELL*sizeof(unsigned));
for (int i = 0; i < YCELLS; i++)
{
for (int j = 0; j < XCELLS; j++)
{
if (th_ogravmap[i*XCELLS+j] != th_gravmap[i*XCELLS+j])
{
for (int y = 0; y < YCELLS; y++)
{
for (int x = 0; x < XCELLS; x++)
{
if (x == j && y == i)//Ensure it doesn't calculate with itself
continue;
auto distance = hypotf(j - x, i - y);
float val;
val = th_gravmap[i*XCELLS+j] - th_ogravmap[i*XCELLS+j];
th_gravx[y*XCELLS+x] += M_GRAV * val * (j - x) / powf(distance, 3.0f);
th_gravy[y*XCELLS+x] += M_GRAV * val * (i - y) / powf(distance, 3.0f);
th_gravp[y*XCELLS+x] += M_GRAV * val / powf(distance, 2.0f);
}
}
}
}
}
memcpy(th_ogravmap, th_gravmap, NCELL*sizeof(float));
}
GravityPtr Gravity::Create()
{
return GravityPtr(new Gravity(CtorTag{}));
}
void GravityDeleter::operator ()(Gravity *ptr) const
{
delete ptr;
}

3
src/simulation/Simulation.cpp
View File

@ -5198,7 +5198,6 @@ void Simulation::AfterSim()
Simulation::~Simulation()
{
delete grav;
delete air;
}
@ -5240,7 +5239,7 @@ Simulation::Simulation():
elementRecount = true;
//Create and attach gravity simulation
grav = new Gravity();
grav = Gravity::Create();
//Give air sim references to our data
grav->bmap = bmap;
//Gravity sim gives us maps to use

3
src/simulation/Simulation.h
View File

@ -15,6 +15,7 @@
#include "BuiltinGOL.h"
#include "MenuSection.h"
#include "CoordStack.h"
#include "GravityPtr.h"
#include "Element.h"
@ -37,7 +38,7 @@ class Simulation
{
public:
Gravity * grav;
GravityPtr grav;
Air * air;
std::vector<sign> signs;

7
src/simulation/meson.build
View File

@ -19,3 +19,10 @@ subdir('simtools')
powder_files += simulation_files
render_files += simulation_files
if enable_gravfft
powder_files += files('FftGravity.cpp')
else
powder_files += files('PlainGravity.cpp')
endif
render_files += files('PlainGravity.cpp')