eu07/maszyna
16
0
Fork 0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-07-17 23:39:18 +02:00
Code Issues 121 Wiki Activity

viewport changes

Browse Source
This commit is contained in:
milek7
2019-03-12 19:21:33 +01:00
parent e85d588851
commit dba2308997
8 changed files with 86 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
Globals.h
View File

@@ -204,13 +204,22 @@ struct global_settings {
struct extraviewport_config {
std::string monitor;
int width;
int height;
int width, 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;

45
application.cpp
View File

@@ -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]));
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)
if (describe_monitor(monitors[i]) == 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]));
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];
WriteLog(describe_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;
}

2
application.h
View File

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

6
gl/buffer.cpp
View File

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

1
gl/buffer.h
View File

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

48
renderer.cpp
View File

@@ -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) {
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;
std::cout << "ZXZ " << glm::to_string(vp.camera_transform) << std::endl;
}
for (auto &viewport : m_viewports) {
if (!init_viewport(*viewport.get()))
return false;
}
if (!init_viewport(default_viewport))
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::PIXEL_UNPACK_BUFFER);
gl::buffer::unbind(gl::buffer::ARRAY_BUFFER);
gl::buffer::unbind();
if (!m_picking_pbo->is_busy())
{

2
renderer.h
View File

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

41
texturewindow.cpp
View File

@@ -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;
{
int monitor_count;
GLFWmonitor **monitors = glfwGetMonitors(&monitor_count);
auto iter = Global.python_monitormap.find(surfacename);
if (iter != Global.python_monitormap.end())
monitor = Application.find_monitor((*iter).second);
for (size_t i = 0; i < monitor_count; i++) {
std::string name(glfwGetMonitorName(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);
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;
}
}
if (monitor) {
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
window_w = mode->width;
window_h = mode->height;
}
GLFWwindow *root = Application.window();
m_window = glfwCreateWindow(window_w, window_h, ("EU07: surface " + surfacename).c_str(), monitor, root);
m_window = Application.window(-1, true, window_w, window_h, monitor);
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}));