maybe fixed for windows

src/GLWidget.cpp

@@ -46,6 +46,7 @@ void GLWidget::initializeGL() {
 	simulation->semaphore.acquire();
 	uploadStaticDataToGPU();
 
+	makeCurrent();
 	overlay->init();
 }
 
@@ -102,6 +103,8 @@ 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){
@@ -183,10 +186,14 @@ 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);
@@ -201,6 +208,8 @@ void GLWidget::changePosition() {
 	}
 	glUnmapBuffer(GL_ARRAY_BUFFER);
 	// std::cout << duration_cast<microseconds>(system_clock::now() - t1).count() << std::endl;
+
+	doneCurrent();
 	simulation->semaphore.release();
 }
 

src/MainWindow.cpp

@@ -18,13 +18,14 @@
 #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);
-	simulationThread->start();
+	connect(simulationThread, &QThread::started, simulation, &Simulation::initialize);
 
 	masses = std::vector<double>(MaxSegments);
 	lengths = std::vector<double>(MaxSegments);
@@ -36,7 +37,9 @@ MainWindow::MainWindow() {
 
 	normalizeLengths();
 
-	QMetaObject::invokeMethod(simulation, &Simulation::initialize);
+	auto offSurface = new QOffscreenSurface;
+	offSurface->create();
+	simulation->offSurface = offSurface;
 }
 
 void MainWindow::buildUI() {

src/MainWindow.h

@@ -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;
 

src/Simulation.cpp

@@ -23,15 +23,12 @@ void Simulation::initialize() {
 
 	// OpenGL Offscreen functions
 	{
-		auto context = new QOpenGLContext(this);
+		context = new QOpenGLContext;
-        auto format = QSurfaceFormat::defaultFormat();
+		auto format = QSurfaceFormat::defaultFormat();
-        format.setVersion(4, 3);
+		format.setVersion(4, 3);
 		context->setFormat(format);
 		context->create();
-		auto surface = new QOffscreenSurface(nullptr, this);
+		context->makeCurrent(offSurface);
-		surface->setFormat(context->format());
-		surface->create();
-		context->makeCurrent(surface);
 		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.";
@@ -46,8 +43,11 @@ void Simulation::initialize() {
 		}
 	}
 
-    if (!useGPUAcceleration)
+    if (!useGPUAcceleration){
-        return;
+		context->doneCurrent();
+		return;
+	}
+
 
 	// Read GPU Limits
 	{
@@ -77,10 +77,13 @@ void Simulation::initialize() {
         f->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;
@@ -122,6 +125,8 @@ void Simulation::updateGPUData() {
     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();
 }
 
 // Every few milliseconds
@@ -139,6 +144,7 @@ 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);
@@ -184,7 +190,7 @@ void Simulation::update() {
 			#pragma omp atomic
 			newKineticEnergy += localKineticEnergy;
 		}
-
+		context->doneCurrent();
 	} else {
 		// CPU-Multithreading
 		#pragma omp parallel for

src/Simulation.h

@@ -5,6 +5,7 @@
 #include <semaphore>
 #include <QOpenGLFunctions_4_3_Core>
 
+class QOffscreenSurface;
 class QTimer;
 class FPS;
 class Pendulum;
@@ -30,13 +31,16 @@ public:
 	std::binary_semaphore semaphore = std::binary_semaphore(1);
 	FPS * ups;
 
-	void initialize();
+	QOffscreenSurface* offSurface;
+	QOpenGLContext* context;
+
 	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);

src/main.cpp

@@ -2,6 +2,7 @@
 #include <QSurfaceFormat>
 #include "MainWindow.h"
 #include <QIcon>
+#include <QThread>
 
 int main(int argc, char* argv[]) {
 	QSurfaceFormat fmt = QSurfaceFormat::defaultFormat();
@@ -19,5 +20,7 @@ int main(int argc, char* argv[]) {
 	w.setWindowIcon(QIcon(":/icons/app_icon.ico"));
 	w.show();
 
+	w.simulationThread->start();
+
 	return QApplication::exec();
 }