U++ forum: Welcome to the forum

GLCtrl::GLLock::GLLock(GLCtrl& ctrl){ hwnd = ctrl.pane.GetHWND(); GLCtrl::CreateContext(); hDC = GetDC(hwnd); wglMakeCurrent(hDC, s_openGLContext); } GLCtrl::GLLock::~GLLock(){ wglMakeCurrent(NULL, NULL); ReleaseDC(hwnd, hDC); }

bool LoadSTL(){ //This function is used when a button is pressed try { GLCtrl::GLLock __(canvas); //Canvas is the GLCtrl object //Shaders Stuff //OpenGL buffer filling and loading //Definition of draw return true; } catch (Exc e) { Exclamation(DeQtf(e)); } return false; }

canvas.ActivateContext(); //Shaders Stuff //OpenGL buffer filling and loading canvas.SwapBuffers(); canvas.DeactivateContext(); // All these method will be proxy and send work to GLPane's classes. return true;

GLCtrl::ContextLock __(canvas); // <- If this is nested glass GL prefix is redundant. // Do we always want buffer swpaing if not I would see additional lock... GLCtrl::ContextLockWithSwapBuffers __(canvas); // <- Alternatively ContextLock can have additional bool parameter (true by default), // however according to the clean code bool parameter should be avoided, so I // use more verbose notation here.

//Class GLCtrl : public Ctrl{ void ActivateContext(); void SwapBuffer(); void DesactivateContext(); struct ContextLock { private: GLCtrl& parent; public: ContextLock(GLCtrl& ctrl); ~ContextLock(); }; struct ContextLockWithSwapBuffers{ private: GLCtrl& parent; public: ContextLockWithSwapBuffers(GLCtrl& ctrl); ~ContextLockWithSwapBuffers(); }; //};

void GLCtrl::ActivateContext(){
	HWND hwnd = pane.GetHWND();
	GLCtrl::CreateContext();
	HDC hDC = GetDC(hwnd);
	wglMakeCurrent(hDC, s_openGLContext);
}
void GLCtrl::SwapBuffer(){
	HWND hwnd = GetHWND();
	HDC hDC = GetDC(hwnd);
	
	SwapBuffers(hDC);
}
void GLCtrl::DesactivateContext(){
	HWND hwnd = GetHWND();
	HDC hDC = GetDC(hwnd);
	
	wglMakeCurrent(NULL, NULL);
	ReleaseDC(hwnd, hDC);
}
GLCtrl::ContextLock::ContextLock(GLCtrl& ctrl) : parent(ctrl){
	HWND hwnd = parent.pane.GetHWND();
	GLCtrl::CreateContext();
	HDC hDC = GetDC(hwnd);
	wglMakeCurrent(hDC, s_openGLContext);
}
GLCtrl::ContextLock::~ContextLock(){
	HWND hwnd = parent.pane.GetHWND();
	HDC hDC = GetDC(hwnd);
	wglMakeCurrent(NULL, NULL);
	ReleaseDC(hwnd, hDC);
}
GLCtrl::ContextLockWithSwapBuffers::ContextLockWithSwapBuffers(GLCtrl& ctrl) : parent(ctrl){
	HWND hwnd = parent.pane.GetHWND();
	GLCtrl::CreateContext();
	HDC hDC = GetDC(hwnd);
	wglMakeCurrent(hDC, s_openGLContext);
}
GLCtrl::ContextLockWithSwapBuffers::~ContextLockWithSwapBuffers(){
	HWND hwnd = parent.pane.GetHWND();
	HDC hDC = GetDC(hwnd);
	
	SwapBuffers(hDC);
	wglMakeCurrent(NULL, NULL);
	ReleaseDC(hwnd, hDC);
}

void GLCtrl::ActivateContext(){
	glXMakeCurrent(s_Display, win, s_GLXContext);
}
void GLCtrl::SwapBuffer(){
	glXSwapBuffers(s_Display, win);
}
void GLCtrl::DesactivateContext(){
	glXMakeCurrent(s_Display, None, NULL);
}
GLCtrl::ContextLock::ContextLock(GLCtrl& ctrl) : parent(ctrl){
	glXMakeCurrent(s_Display, parent.win, s_GLXContext);
}
GLCtrl::ContextLock::~ContextLock(){
	glXMakeCurrent(s_Display, None, NULL);
}
GLCtrl::ContextLockWithSwapBuffers::ContextLockWithSwapBuffers(GLCtrl& ctrl) : parent(ctrl){
	glXMakeCurrent(s_Display, parent.win, s_GLXContext);
}
GLCtrl::ContextLockWithSwapBuffers::~ContextLockWithSwapBuffers(){
	glXSwapBuffers(s_Display, parent.win);
	glXMakeCurrent(s_Display, None, NULL);
}

bool LoadSTL(){ //This function is used when a button is pressed try { canvas.ExecuteGL([&] { //OpenGL buffer filling and loading //Definition of draw }); return true; } catch (Exc e) { Exclamation(DeQtf(e)); } return false; }

bool LoadSTL(){ //This function is used when a button is pressed bool rendered; canvas.ExecuteGL([&] { rendered = renderSTL(); }); return rendered; // Maybe with template magic we could simplify to // return canvas.ExecuteGL([&] -> bool { return renderSTL(); }); } bool rednerSTL() { // All methods calls from here could call to OpenGL... The same is true with lock approach... try { //Context is here... //Shaders Stuff //OpenGL buffer filling and loading //Definition of draw } catch (Exc e) { Exclamation(DeQtf(e)); } return false; }

struct GLLock{ private: GLCtrl& ctrl; bool swap; public: GLLock(GLCtrl& glCtrl, bool swapBuffer = false); ~GLLock(); }; class GLCtrl : public Ctrl { typedef GLCtrl CLASSNAME; friend class GLLock; //************************* //}

GLLock::GLLock(GLCtrl& glCtrl, bool swapBuffer) : ctrl(glCtrl), swap(swapBuffer) { HWND hwnd = ctrl.pane.GetHWND(); HDC hDC = GetDC(hwnd); wglMakeCurrent(hDC, s_openGLContext); } GLLock::~GLLock() { if(swap){ HWND hwnd = ctrl.pane.GetHWND(); HDC hDC = GetDC(hwnd); SwapBuffers(hDC); }else{ glFlush(); } wglMakeCurrent(NULL, NULL); }

GLLock::GLLock(GLCtrl& glCtrl, bool swapBuffer) : ctrl(glCtrl), swap(swapBuffer) { glXMakeCurrent(s_Display, ctrl.win, s_GLXContext); } GLLock::~GLLock() { if(swap){ glXSwapBuffers(s_Display, win); }else{ glFlush(); } glXMakeCurrent(s_Display, None, NULL); }