benjamin
/
Pendulum
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases 4 Wiki Activity

Compare commits

base: benjamin:main
Branches Tags
benjamin:main
..
compare: benjamin:v1.3
Branches Tags
benjamin:main

No commits in common. 'main' and 'v1.3' have entirely different histories.
main ... v1.3

7 changed files with 54 additions and 93 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats
  1. 9
      src/GLWidget.cpp
  2. 4
      src/GLWidget.h
  3. 9
      src/MainWindow.cpp
  4. 2
      src/MainWindow.h
  5. 102
      src/Simulation.cpp
  6. 12
      src/Simulation.h
  7. 5
      src/main.cpp

9
src/GLWidget.cpp
Unescape View File

@ -46,7 +46,6 @@ void GLWidget::initializeGL() {
simulation->semaphore.acquire();
uploadStaticDataToGPU();
makeCurrent();
overlay->init();
}
@ -103,8 +102,6 @@ bool GLWidget::AnyDialogOpen() {
}
void GLWidget::uploadStaticDataToGPU() {
makeCurrent();
auto pendula = &simulation->pendula;
size_t pointCount = std::transform_reduce(pendula->begin(), pendula->end(), 0, [](size_t prev, size_t curr){
@ -186,14 +183,10 @@ void GLWidget::uploadStaticDataToGPU() {
glBindVertexArray(0);
doneCurrent();
simulation->semaphore.release();
}
void GLWidget::changePosition() {
makeCurrent();
auto t1 = system_clock::now();
glBindBuffer(GL_ARRAY_BUFFER, positionVBO);
auto positions = (GLfloat*) glMapBufferRange(GL_ARRAY_BUFFER, 0, GLsizeiptr(positionCount * sizeof(float)), GL_MAP_WRITE_BIT);
@ -208,8 +201,6 @@ void GLWidget::changePosition() {
}
glUnmapBuffer(GL_ARRAY_BUFFER);
// std::cout << duration_cast<microseconds>(system_clock::now() - t1).count() << std::endl;
doneCurrent();
simulation->semaphore.release();
}

4
src/GLWidget.h
Unescape View File

@ -1,7 +1,7 @@
#pragma once
#include <QOpenGLWidget>
#include <QOpenGLFunctions_3_3_Core>
#include <QOpenGLExtraFunctions>
#include <QMatrix3x3>
class Pendulum;
@ -9,7 +9,7 @@ class Simulation;
class QOpenGLShaderProgram;
class Overlay;
class GLWidget : public QOpenGLWidget, protected QOpenGLFunctions_3_3_Core {
class GLWidget : public QOpenGLWidget, protected QOpenGLExtraFunctions {
public:
explicit GLWidget(Simulation *);
Overlay * overlay;

9
src/MainWindow.cpp
Unescape View File

@ -18,14 +18,13 @@
#include <QTimer>
#include "Overlay.h"
#include "Slider.h"
#include <QOffscreenSurface>
MainWindow::MainWindow() {
simulationThread = new QThread(this);
simulationThread->setObjectName("Simulation");
simulation = new Simulation;
simulation->moveToThread(simulationThread);
connect(simulationThread, &QThread::started, simulation, &Simulation::initialize);
simulationThread->start();
masses = std::vector<double>(MaxSegments);
lengths = std::vector<double>(MaxSegments);
@ -37,9 +36,7 @@ MainWindow::MainWindow() {
normalizeLengths();
auto offSurface = new QOffscreenSurface;
offSurface->create();
simulation->offSurface = offSurface;
QMetaObject::invokeMethod(simulation, &Simulation::initialize);
}
void MainWindow::buildUI() {
@ -386,13 +383,13 @@ QWidget * MainWindow::buildSimulationUI() {
// GPU-Acceleration
{
auto useGPU = new QCheckBox("Use GPU-Acceleration");
useGPU->setCheckState(Qt::Checked);
connect(useGPU, &QCheckBox::stateChanged, simulation, &Simulation::useGPUChanged);
connect(simulation, &Simulation::gpuNotSupported, [useGPU](const std::string &message){
useGPU->setCheckState(Qt::Unchecked);
useGPU->setEnabled(false);
useGPU->setToolTip(QString::fromStdString(message));
});
useGPU->setCheckState(Qt::Unchecked);
lyt->addWidget(useGPU);
}

2
src/MainWindow.h
Unescape View File

@ -15,12 +15,12 @@ class MainWindow : public QWidget {
public:
explicit MainWindow();
~MainWindow() override;
QThread * simulationThread;
private:
void buildUI();
QWidget * buildAddUI();
QWidget * buildSimulationUI();
Simulation * simulation;
QThread * simulationThread;
GLWidget * glWidget = nullptr;

102
src/Simulation.cpp
Unescape View File

@ -23,19 +23,15 @@ void Simulation::initialize() {
// OpenGL Offscreen functions
{
context = new QOpenGLContext;
auto format = QSurfaceFormat::defaultFormat();
format.setVersion(4, 3);
context->setFormat(format);
auto context = new QOpenGLContext(this);
context->setFormat(QSurfaceFormat::defaultFormat());
context->create();
context->makeCurrent(offSurface);
f = new QOpenGLFunctions_4_3_Core;
if (!f->initializeOpenGLFunctions()){
std::string message = "OpenGL 4.3 is required for Compute Shaders! Falling back to CPU-Multithreading.";
printf("%s\n", message.c_str());
useGPUAcceleration = false;
emit gpuNotSupported(message);
} else if (!context->hasExtension("GL_ARB_gpu_shader_fp64")){
auto surface = new QOffscreenSurface(nullptr, this);
surface->setFormat(context->format());
surface->create();
context->makeCurrent(surface);
initializeOpenGLFunctions();
if (!context->hasExtension("GL_ARB_gpu_shader_fp64")){
std::string message = "Double precision not supported by OpenGL! Falling back to CPU-Multithreading.";
printf("%s\n", message.c_str());
useGPUAcceleration = false;
@ -43,19 +39,13 @@ void Simulation::initialize() {
}
}
if (!useGPUAcceleration){
context->doneCurrent();
return;
}
// Read GPU Limits
{
for (int i = 0; i < 3; i++){
f->glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, i, gpuLimits.maxWGCount + i);
f->glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, i, gpuLimits.maxWGSize + i);
glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_COUNT, i, gpuLimits.maxWGCount + i);
glGetIntegeri_v(GL_MAX_COMPUTE_WORK_GROUP_SIZE, i, gpuLimits.maxWGSize + i);
}
f->glGetIntegerv(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS, &gpuLimits.maxWGInvocations);
glGetIntegerv(GL_MAX_COMPUTE_WORK_GROUP_INVOCATIONS, &gpuLimits.maxWGInvocations);
printf("Max work group count: (%d, %d, %d)\n", gpuLimits.maxWGCount[0], gpuLimits.maxWGCount[1], gpuLimits.maxWGCount[2]);
printf("Max work group size: (%d, %d, %d)\n", gpuLimits.maxWGSize[0], gpuLimits.maxWGSize[1], gpuLimits.maxWGSize[2]);
@ -68,22 +58,19 @@ void Simulation::initialize() {
program->addShaderFromSourceFile(QOpenGLShader::Compute, ":/shaders/compute.glsl");
program->link();
f->glGenBuffers(6, &SSBO.positions);
f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, SSBO.positions);
f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, SSBO.velocities);
f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, SSBO.invMasses);
f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, SSBO.lengths);
f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, SSBO.indices);
f->glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, SSBO.segmentCounts);
glGenBuffers(6, &SSBO.positions);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 0, SSBO.positions);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 1, SSBO.velocities);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, SSBO.invMasses);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 3, SSBO.lengths);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 4, SSBO.indices);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 5, SSBO.segmentCounts);
}
context->doneCurrent();
}
// When the layout changes
void Simulation::updateGPUData() {
context->makeCurrent(offSurface);
std::vector<GLdouble> positions;
std::vector<GLdouble> velocities;
std::vector<GLdouble> invMasses;
@ -113,20 +100,18 @@ void Simulation::updateGPUData() {
auto indicesSize = GLsizeiptr(indices.size() * sizeof(GLuint));
auto segmentCountsSize = GLsizeiptr(segmentCounts.size() * sizeof(GLuint));
f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.positions);
f->glBufferData(GL_SHADER_STORAGE_BUFFER, posSize, positions.data(), GL_DYNAMIC_DRAW);
f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.velocities);
f->glBufferData(GL_SHADER_STORAGE_BUFFER, velSize, velocities.data(), GL_DYNAMIC_DRAW);
f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.invMasses);
f->glBufferData(GL_SHADER_STORAGE_BUFFER, invMassSize, invMasses.data(), GL_STATIC_DRAW);
f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.lengths);
f->glBufferData(GL_SHADER_STORAGE_BUFFER, lengthSize, lengths.data(), GL_STATIC_DRAW);
f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.indices);
f->glBufferData(GL_SHADER_STORAGE_BUFFER, indicesSize, indices.data(), GL_STATIC_DRAW);
f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.segmentCounts);
f->glBufferData(GL_SHADER_STORAGE_BUFFER, segmentCountsSize, segmentCounts.data(), GL_STATIC_DRAW);
context->doneCurrent();
glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.positions);
glBufferData(GL_SHADER_STORAGE_BUFFER, posSize, positions.data(), GL_DYNAMIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.velocities);
glBufferData(GL_SHADER_STORAGE_BUFFER, velSize, velocities.data(), GL_DYNAMIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.invMasses);
glBufferData(GL_SHADER_STORAGE_BUFFER, invMassSize, invMasses.data(), GL_STATIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.lengths);
glBufferData(GL_SHADER_STORAGE_BUFFER, lengthSize, lengths.data(), GL_STATIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.indices);
glBufferData(GL_SHADER_STORAGE_BUFFER, indicesSize, indices.data(), GL_STATIC_DRAW);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.segmentCounts);
glBufferData(GL_SHADER_STORAGE_BUFFER, segmentCountsSize, segmentCounts.data(), GL_STATIC_DRAW);
}
// Every few milliseconds
@ -144,19 +129,18 @@ void Simulation::update() {
double newKineticEnergy = 0;
if (useGPUAcceleration) {
context->makeCurrent(offSurface);
program->bind();
f->glUniform1d(program->uniformLocation("h"), h);
f->glUniform1d(program->uniformLocation("gravity"), gravity);
f->glUniform1ui(program->uniformLocation("substeps"), substeps);
glUniform1d(program->uniformLocation("h"), h);
glUniform1d(program->uniformLocation("gravity"), gravity);
glUniform1ui(program->uniformLocation("substeps"), substeps);
f->glDispatchCompute(pendula.size(), 1, 1);
f->glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
glDispatchCompute(pendula.size(), 1, 1);
glMemoryBarrier(GL_SHADER_STORAGE_BARRIER_BIT);
// Read updated positions
{
f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.positions);
auto * newPositions = (double*) f->glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.positions);
auto * newPositions = (double*) glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY);
int index = 0;
for (Pendulum * p : pendula){
for (Vector &point : p->X){
@ -164,13 +148,13 @@ void Simulation::update() {
point.y = newPositions[index++];
}
}
f->glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
}
// Read updated velocities
{
f->glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.velocities);
auto * newVelocities = (double*) f->glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, SSBO.velocities);
auto * newVelocities = (double*) glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_READ_ONLY);
int index = 0;
for (Pendulum * p : pendula){
for (Vector &velocity : p->V){
@ -178,7 +162,7 @@ void Simulation::update() {
velocity.y = newVelocities[index++];
}
}
f->glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
glUnmapBuffer(GL_SHADER_STORAGE_BUFFER);
}
#pragma omp parallel for
@ -190,7 +174,7 @@ void Simulation::update() {
#pragma omp atomic
newKineticEnergy += localKineticEnergy;
}
context->doneCurrent();
} else {
// CPU-Multithreading
#pragma omp parallel for
@ -224,7 +208,6 @@ void Simulation::clearPendula() {
pendula.shrink_to_fit();
updateEnergy();
if (useGPUAcceleration)
updateGPUData();
emit layoutChanged();
@ -237,7 +220,6 @@ void Simulation::addPendula(const std::vector<Pendulum *> &add) {
pendula.push_back(p);
updateEnergy();
if (useGPUAcceleration)
updateGPUData();
emit layoutChanged();

12
src/Simulation.h
Unescape View File

@ -5,13 +5,11 @@
#include <semaphore>
#include <QOpenGLFunctions_4_3_Core>
class QOffscreenSurface;
class QTimer;
class FPS;
class Pendulum;
class QOpenGLShaderProgram;
class Simulation : public QObject {
class Simulation : public QObject, protected QOpenGLFunctions_4_3_Core {
Q_OBJECT
public:
explicit Simulation();
@ -31,23 +29,19 @@ public:
std::binary_semaphore semaphore = std::binary_semaphore(1);
FPS * ups;
QOffscreenSurface* offSurface;
QOpenGLContext* context;
void initialize();
void updateEnergy();
signals:
void gpuNotSupported(const std::string &message);
void layoutChanged();
void positionChanged();
public slots:
void initialize();
void clearPendula();
void addPendula(const std::vector<Pendulum *> &add);
void useGPUChanged(int);
private slots:
void update();
private:
QOpenGLFunctions_4_3_Core * f;
void updateGPUData();
struct GPULimits {
int maxWGCount[3];
@ -65,5 +59,5 @@ private:
} SSBO;
QTimer * timer;
int updateInterval = 16;
bool useGPUAcceleration = true;
bool useGPUAcceleration = false;
};

5
src/main.cpp
Unescape View File

@ -2,14 +2,13 @@
#include <QSurfaceFormat>
#include "MainWindow.h"
#include <QIcon>
#include <QThread>
int main(int argc, char* argv[]) {
QSurfaceFormat fmt = QSurfaceFormat::defaultFormat();
fmt.setDepthBufferSize(24);
fmt.setSamples(8);
fmt.setSwapInterval(1);
fmt.setVersion(3, 3);
fmt.setVersion(4, 3);
fmt.setProfile(QSurfaceFormat::CoreProfile);
QSurfaceFormat::setDefaultFormat(fmt);
@ -20,7 +19,5 @@ int main(int argc, char* argv[]) {
w.setWindowIcon(QIcon(":/icons/app_icon.ico"));
w.show();
w.simulationThread->start();
return QApplication::exec();
}

Write Preview
Loading…
Cancel
Save