viewport changes

Globals.h

@@ -204,13 +204,22 @@ struct global_settings {
 
 	struct extraviewport_config {
 		std::string monitor;
-		int width;
+		int width, height;
-		int height;
 		glm::mat4 transform;
 	};
-
 	std::vector<extraviewport_config> extra_viewports;
 
+	struct pythonviewport_config {
+		std::string surface;
+
+		std::string monitor;
+		glm::ivec2 size;
+
+		glm::ivec2 offset;
+		glm::ivec2 cut;
+	};
+	std::vector<pythonviewport_config> python_viewports;
+
 	std::vector<std::pair<std::string, std::string>> network_servers;
 	std::optional<std::pair<std::string, std::string>> network_client;
 

application.cpp

@@ -486,6 +486,9 @@ eu07_application::window( int const Windowindex, bool visible, int width, int he
     if( childwindow != nullptr ) {
         m_windows.emplace_back( childwindow );
     }
+
+	glfwFocusWindow(m_windows.front()); // restore focus to main window
+
     return childwindow;
 }
 
@@ -494,21 +497,23 @@ GLFWmonitor* eu07_application::find_monitor(const std::string &str) {
 	GLFWmonitor **monitors = glfwGetMonitors(&monitor_count);
 
 	for (size_t i = 0; i < monitor_count; i++) {
-		std::string name(glfwGetMonitorName(monitors[i]));
+		if (describe_monitor(monitors[i]) == str)
-		std::replace(std::begin(name), std::end(name), ' ', '_');
-
-		int x, y;
-		glfwGetMonitorPos(monitors[i], &x, &y);
-
-		std::string desc = name + ":" + std::to_string(x) + "," + std::to_string(y);
-
-		if (desc == str)
 			return monitors[i];
 	}
 
 	return nullptr;
 }
 
+std::string eu07_application::describe_monitor(GLFWmonitor *monitor) {
+	std::string name(glfwGetMonitorName(monitor));
+	std::replace(std::begin(name), std::end(name), ' ', '_');
+
+	int x, y;
+	glfwGetMonitorPos(monitor, &x, &y);
+
+	return name + ":" + std::to_string(x) + "," + std::to_string(y);
+}
+
 // private:
 
 void
@@ -601,27 +606,21 @@ eu07_application::init_glfw() {
 
     // match requested video mode to current to allow for
     // fullwindow creation when resolution is the same
-	auto *monitor { glfwGetPrimaryMonitor() };
+
 	{
 		int monitor_count;
 		GLFWmonitor **monitors = glfwGetMonitors(&monitor_count);
 
 		WriteLog("available monitors:");
 		for (size_t i = 0; i < monitor_count; i++) {
-			std::string name(glfwGetMonitorName(monitors[i]));
+			WriteLog(describe_monitor(monitors[i]));
-			std::replace(std::begin(name), std::end(name), ' ', '_');
-
-			int x, y;
-			glfwGetMonitorPos(monitors[i], &x, &y);
-
-			std::string desc = name + ":" + std::to_string(x) + "," + std::to_string(y);
-			WriteLog(desc);
-
-			if (desc == Global.fullscreen_monitor)
-				monitor = monitors[i];
 		}
 	}
 
+	auto *monitor { find_monitor(Global.fullscreen_monitor) };
+	if (!monitor)
+		monitor = glfwGetPrimaryMonitor();
+
     auto const *vmode { glfwGetVideoMode( monitor ) };
 
     glfwWindowHint( GLFW_RED_BITS, vmode->redBits );
@@ -735,6 +734,10 @@ eu07_application::init_gfx() {
     if (!GfxRenderer.Init(m_windows.front()))
         return -1;
 
+	for (const global_settings::extraviewport_config &conf : Global.extra_viewports)
+		if (!GfxRenderer.AddViewport(conf))
+			return -1;
+
     return 0;
 }
 

application.h

@@ -100,6 +100,8 @@ private:
     int  init_audio();
     int  init_modes();
 	bool init_network();
+
+	std::string describe_monitor(GLFWmonitor *monitor);
 // members
 
     bool m_screenshot_queued = false;

gl/buffer.cpp

@@ -42,6 +42,12 @@ void gl::buffer::unbind(targets target)
     binding_points[target] = 0;
 }
 
+void gl::buffer::unbind()
+{
+	for (size_t i = 0; i < sizeof(binding_points) / sizeof(GLuint); i++)
+		unbind((targets)i);
+}
+
 gl::buffer::buffer()
 {
     glGenBuffers(1, *this);

gl/buffer.h

@@ -37,6 +37,7 @@ namespace gl
         void bind(targets target);
         void bind_base(targets target, GLuint index);
         static void unbind(targets target);
+		static void unbind();
 
         void allocate(targets target, int size, GLenum hint);
         void upload(targets target, const void *data, int offset, int size);

renderer.cpp

@@ -167,22 +167,10 @@ bool opengl_renderer::Init(GLFWwindow *Window)
 	default_viewport.main = true;
 	default_viewport.window = m_window;
 
-	for (const global_settings::extraviewport_config &conf : Global.extra_viewports) {
+	if (!init_viewport(default_viewport))
-		m_viewports.push_back(std::make_unique<viewport_config>());
+		return false;
-		viewport_config &vp = *m_viewports.back().get();
-		vp.width = conf.width;
-		vp.height = conf.height;
-		vp.window = Application.window(-1, true, vp.width, vp.height, Application.find_monitor(conf.monitor));
-		vp.camera_transform = conf.transform;
-		std::cout << "ZXZ " << glm::to_string(vp.camera_transform) << std::endl;
-	}
-
-	for (auto &viewport : m_viewports) {
-		if (!init_viewport(*viewport.get()))
-			return false;
-	}
-
 	glfwMakeContextCurrent(m_window);
+	gl::buffer::unbind();
 
 	if (Global.gfx_shadowmap_enabled)
 	{
@@ -301,6 +289,22 @@ bool opengl_renderer::Init(GLFWwindow *Window)
 	return true;
 }
 
+bool opengl_renderer::AddViewport(const global_settings::extraviewport_config &conf)
+{
+	m_viewports.push_back(std::make_unique<viewport_config>());
+	viewport_config &vp = *m_viewports.back().get();
+	vp.width = conf.width;
+	vp.height = conf.height;
+	vp.window = Application.window(-1, true, vp.width, vp.height, Application.find_monitor(conf.monitor));
+	vp.camera_transform = conf.transform;
+
+	bool ret = init_viewport(vp);
+	glfwMakeContextCurrent(m_window);
+	gl::buffer::unbind();
+
+	return ret;
+}
+
 bool opengl_renderer::init_viewport(viewport_config &vp)
 {
 	glfwMakeContextCurrent(vp.window);
@@ -445,6 +449,7 @@ bool opengl_renderer::Render()
 	}
 
 	glfwMakeContextCurrent(m_window);
+	gl::buffer::unbind();
 	m_current_viewport = &(*m_viewports.front());
 
 	m_drawcount = m_cellqueue.size();
@@ -525,17 +530,16 @@ void opengl_renderer::Render_pass(viewport_config &vp, rendermode const Mode)
 
 		glDebug("context switch");
 		glfwMakeContextCurrent(vp.window);
+		gl::buffer::unbind();
 		m_current_viewport = &vp;
 
 		if (!simulation::is_ready)
 		{
-			if (!vp.main)
-				break;
-
 			gl::framebuffer::unbind();
 			glClearColor(0.0f, 0.5f, 0.0f, 1.0f);
 			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-			Application.render_ui();
+			if (vp.main)
+				Application.render_ui();
 			break;
 		}
 
@@ -1047,7 +1051,7 @@ void opengl_renderer::setup_pass(viewport_config &Viewport, renderpass_config &C
 	glm::mat4 frustumtest_proj;
 
 	float const fovy = glm::radians(Global.FieldOfView / Global.ZoomFactor);
-	float const aspect = std::max(1.f, (float)Global.iWindowWidth) / std::max(1.f, (float)Global.iWindowHeight);
+	float const aspect = std::max(1.f, (float)Viewport.width) / std::max(1.f, (float)Viewport.height);
 
 	Config.viewport_camera.position() = Global.pCamera.Pos;
 
@@ -3458,9 +3462,7 @@ void opengl_renderer::Render_Alpha(TSubModel *Submodel)
 void opengl_renderer::Update_Pick_Control()
 {
 	// context-switch workaround
-	gl::buffer::unbind(gl::buffer::PIXEL_PACK_BUFFER);
+	gl::buffer::unbind();
-	gl::buffer::unbind(gl::buffer::PIXEL_UNPACK_BUFFER);
-	gl::buffer::unbind(gl::buffer::ARRAY_BUFFER);
 
 	if (!m_picking_pbo->is_busy())
 	{

renderer.h

@@ -130,6 +130,8 @@ class opengl_renderer
 
 	// methods
 	bool Init(GLFWwindow *Window);
+	bool AddViewport(const global_settings::extraviewport_config &conf);
+
 	// main draw call. returns false on error
 	bool Render();
 	void SwapBuffers();

texturewindow.cpp

@@ -17,38 +17,19 @@ texture_window::texture_window(texture_handle src, std::string surfacename)
 	tex.create();
 	m_source = tex.id;
 
-	glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE);
-
 	int window_w = m_win_w, window_h = m_win_h;
 
-	{
+	auto iter = Global.python_monitormap.find(surfacename);
-		int monitor_count;
+	if (iter != Global.python_monitormap.end())
-		GLFWmonitor **monitors = glfwGetMonitors(&monitor_count);
+		monitor = Application.find_monitor((*iter).second);
 
-		for (size_t i = 0; i < monitor_count; i++) {
+	if (monitor) {
-			std::string name(glfwGetMonitorName(monitors[i]));
+		const GLFWvidmode *mode = glfwGetVideoMode(monitor);
-			std::replace(std::begin(name), std::end(name), ' ', '_');
+		window_w = mode->width;
-
+		window_h = mode->height;
-			int x, y;
-			glfwGetMonitorPos(monitors[i], &x, &y);
-
-			std::string desc = name + ":" + std::to_string(x) + "," + std::to_string(y);
-
-			auto iter = Global.python_monitormap.find(surfacename);
-			if (iter != Global.python_monitormap.end()
-			        && (*iter).second == desc) {
-				monitor = monitors[i];
-
-				const GLFWvidmode *mode = glfwGetVideoMode(monitor);
-				window_w = mode->width;
-				window_h = mode->height;
-				break;
-			}
-		}
 	}
 
-	GLFWwindow *root = Application.window();
+	m_window = Application.window(-1, true, window_w, window_h, monitor);
-	m_window = glfwCreateWindow(window_w, window_h, ("EU07: surface " + surfacename).c_str(), monitor, root);
 
 	glfwSetWindowUserPointer(m_window, this);
 	glfwSetFramebufferSizeCallback(m_window, texture_window_fb_resize);
@@ -68,6 +49,12 @@ void texture_window::threadfunc()
 	glfwMakeContextCurrent(m_window);
 	glfwSwapInterval(1);
 
+	{
+		GLuint v;
+		glGenVertexArrays(1, &v);
+		glBindVertexArray(v);
+	}
+
 	gl::shader vert("quad.vert");
 	gl::shader frag("texturewindow.frag");
 	gl::program shader(std::vector<std::reference_wrapper<const gl::shader>>({vert, frag}));