diff --git a/global_include/interfaces/ITexture.h b/global_include/interfaces/ITexture.h index ce123829f..ead1c6335 100644 --- a/global_include/interfaces/ITexture.h +++ b/global_include/interfaces/ITexture.h @@ -21,6 +21,14 @@ struct ITexture virtual void set_components_hint(int hint) = 0; virtual void make_from_memory(size_t width, size_t height, const uint8_t *data) = 0; virtual void update_from_memory(size_t width, size_t height, const uint8_t *data) = 0; + // uploads an image from a thread with a gl context of its own, sharing the objects with the drawing one. a texture that + // can keeps the image apart until commit_thread_upload(), called on the drawing thread, puts it in place + virtual void upload_from_thread(size_t width, size_t height, const uint8_t *data) + { + update_from_memory(width, height, data); + } + // puts in place the image of the last upload_from_thread(), once the gpu has it. called on the drawing thread + virtual void commit_thread_upload() { /* the image went in place right away */ } static ITexture *null_texture() { struct NullTexture : public ITexture diff --git a/model/Texture.cpp b/model/Texture.cpp index 9b428202b..779695fa9 100644 --- a/model/Texture.cpp +++ b/model/Texture.cpp @@ -29,6 +29,7 @@ http://mozilla.org/MPL/2.0/. #include "winheaders.h" #include +#include #define EU07_DEFERRED_TEXTURE_UPLOAD @@ -734,6 +735,92 @@ void opengl_texture::update_from_memory(size_t width, size_t height, const uint8 unit = -1; } +namespace +{ +// gl objects of an image uploaded by another thread that was never put in place +void delete_thread_upload(GLuint const Texture, GLsync const Fence) +{ + if (Fence != nullptr) + glDeleteSync(Fence); + glDeleteTextures(1, &Texture); +} +} // namespace + +void opengl_texture::upload_from_thread(size_t width, size_t height, const uint8_t *raw) +{ + // a texture of its own each time: the one drawn from may be in use by the gpu for the drawing context, and writing it from + // here, with nothing to order the two contexts, could leave it incomplete or half written for a frame + texture_thread_upload upload; + upload.width = width; + upload.height = height; + glGenTextures(1, &upload.id); + glBindTexture(target, upload.id); + set_filtering(); + glTexParameteri(target, GL_TEXTURE_WRAP_S, wrap_mode_s); + glTexParameteri(target, GL_TEXTURE_WRAP_T, wrap_mode_t); + if (!glGenerateMipmap) + glTexParameteri(target, GL_GENERATE_MIPMAP, GL_TRUE); + glTexImage2D(target, 0, GL_SRGB8_ALPHA8, static_cast(width), static_cast(height), 0, GL_RGBA, GL_UNSIGNED_BYTE, raw); + if (glGenerateMipmap) + glGenerateMipmap(target); + glBindTexture(target, 0); + if (glFenceSync) + { + upload.fence = glFenceSync(GL_SYNC_GPU_COMMANDS_COMPLETE, 0); + } + else + { + // no sync objects: the drawing context can only be sure of the image once the upload is done + glFinish(); + } + // the drawing context waits on the fence, which it can do only once the fence is on its way to the gpu + glFlush(); + + std::optional superseded; + { + std::scoped_lock lock{m_threaduploadmutex}; + superseded = std::exchange(m_threadupload, upload); + } + if (superseded.has_value()) + { + // the drawing thread didn't take it, so nothing drew from it + delete_thread_upload(superseded->id, superseded->fence); + } +} + +void opengl_texture::commit_thread_upload() +{ + std::optional upload; + { + std::scoped_lock lock{m_threaduploadmutex}; + upload = std::exchange(m_threadupload, std::nullopt); + } + if (false == upload.has_value()) + return; + + if (upload->fence != nullptr) + { + // the commands that follow wait on the gpu for the upload to be done, the cpu goes on + glWaitSync(upload->fence, 0, GL_TIMEOUT_IGNORED); + glDeleteSync(upload->fence); + } + if (id != invalid_id) + glDeleteTextures(1, &id); + id = upload->id; + data_width = static_cast(upload->width); + data_height = static_cast(upload->height); + data_format = GL_SRGB8_ALPHA8; + data_components = GL_RGBA; + if (type == "internalsrc:") + { + is_static = true; + is_ready = true; + } + // the name deleted may come back for another texture, and a deleted texture isn't bound any more + for (auto &unit : units) + unit = -1; +} + void opengl_texture::make_request() { diff --git a/model/Texture.h b/model/Texture.h index 20221fcea..0a86fe4bc 100644 --- a/model/Texture.h +++ b/model/Texture.h @@ -11,6 +11,8 @@ http://mozilla.org/MPL/2.0/. #include #include +#include +#include #include "winheaders.h" #include #include "model/ResourceManager.h" @@ -19,6 +21,14 @@ http://mozilla.org/MPL/2.0/. struct texture_request; // texture data read by a worker thread, with gfx.textures.streaming +// an image uploaded by another thread into a texture of its own, waiting for the drawing thread to put it in place +struct texture_thread_upload { + GLuint id { 0 }; + GLsync fence { nullptr }; // set after the upload in the uploading context; none where the driver has no sync objects + size_t width { 0 }; + size_t height { 0 }; +}; + struct opengl_texture : public ITexture { static DDSURFACEDESC2 deserialize_ddsd(std::istream&); static DDCOLORKEY deserialize_ddck(std::istream&); @@ -85,6 +95,10 @@ struct opengl_texture : public ITexture { virtual void make_from_memory(size_t width, size_t height, const uint8_t *data) override; virtual void update_from_memory(size_t width, size_t height, const uint8_t *data) override; + // the image goes into a texture of its own, and the drawing thread swaps it in after the gpu has it (commit_thread_upload). + // the texture drawn from is never written by the uploading thread + void upload_from_thread(size_t width, size_t height, const uint8_t *data) override; + void commit_thread_upload() override; // members static constexpr GLuint invalid_id { std::numeric_limits::max() }; // id value of texture without GL resource @@ -101,6 +115,9 @@ struct opengl_texture : public ITexture { static std::array units; static GLint m_activeunit; + std::mutex m_threaduploadmutex; + std::optional m_threadupload; // guarded by m_threaduploadmutex + public: // methods void make_request(); diff --git a/scripting/PyInt.cpp b/scripting/PyInt.cpp index fac540019..b82ff73ce 100644 --- a/scripting/PyInt.cpp +++ b/scripting/PyInt.cpp @@ -232,6 +232,24 @@ void render_task::upload() const } } +void render_task::upload_from_thread() const +{ + if (Global.python_uploadmain && m_target && m_target->shared_tex) + { + m_target->shared_tex->upload_from_thread(m_target->width, m_target->height, reinterpret_cast(m_target->image.data())); + } +} + +void render_task::commit_upload() const +{ + if (Global.python_uploadmain && m_target && m_target->shared_tex) + { + m_target->shared_tex->commit_thread_upload(); + std::scoped_lock lock(m_target->mutex); + m_target->texture_id = m_target->shared_tex->get_id(); + } +} + void render_task::cancel() const { /* nothing to do */ } // initializes the module. returns true on success @@ -569,9 +587,11 @@ void python_taskqueue::run(GLFWwindow *Context, rendertask_sequence &Tasks, uplo // execute python code task->run(); if (Context) - task->upload(); - else { + task->upload_from_thread(); + } + { + // the drawing thread uploads the image, or puts in place the one uploaded here std::scoped_lock lock(Upload_Tasks.mutex); Upload_Tasks.data.push_back(task); } @@ -610,7 +630,12 @@ void python_taskqueue::update() std::scoped_lock lock(m_uploadtasks.mutex); for (auto const &task : m_uploadtasks.data) - task->upload(); + { + if (Global.python_threadedupload) + task->commit_upload(); + else + task->upload(); + } m_uploadtasks.data.clear(); } diff --git a/scripting/PyInt.h b/scripting/PyInt.h index c8c410397..866368b07 100644 --- a/scripting/PyInt.h +++ b/scripting/PyInt.h @@ -67,6 +67,9 @@ struct python_rt int width; int height; std::string image; + // gl name of the texture with the last image put in place, for the windows of python.displaywindows (0: none yet). the image + // uploaded by a worker gets a texture of its own, so the name changes with each one + size_t texture_id{0}; std::chrono::high_resolution_clock::time_point timestamp; }; @@ -80,7 +83,12 @@ class render_task render_task(PyObject *Renderer, std::shared_ptr Input, std::shared_ptr Target) : m_renderer(Renderer), m_input(Input), m_target(Target) {} // methods void run(); + // uploads the image on the drawing thread void upload() const; + // uploads the image on a worker with a gl context of its own (python.threadedupload); commit_upload() puts it in place + void upload_from_thread() const; + // puts the image of upload_from_thread() in place, on the drawing thread + void commit_upload() const; void cancel() const; auto target() const -> std::shared_ptr { diff --git a/scripting/pythonscreenviewer.cpp b/scripting/pythonscreenviewer.cpp index 4da50151e..da461649e 100644 --- a/scripting/pythonscreenviewer.cpp +++ b/scripting/pythonscreenviewer.cpp @@ -90,7 +90,8 @@ void python_screen_viewer::threadfunc() glActiveTexture(GL_TEXTURE0); if (Global.python_sharectx) { - glBindTexture(GL_TEXTURE_2D, static_cast(m_rt->shared_tex->get_id())); + window->shared_texture = m_rt->shared_tex->get_id(); + glBindTexture(GL_TEXTURE_2D, static_cast(window->shared_texture)); } else { GLuint tex; @@ -146,6 +147,8 @@ void python_screen_viewer::threadfunc() } glfwMakeContextCurrent(window->window); + if (Global.python_sharectx) + bind_shared_texture(*window); gl::program::unbind(); gl::buffer::unbind(); @@ -188,6 +191,20 @@ void python_screen_viewer::threadfunc() } } +void python_screen_viewer::bind_shared_texture(window_state &Window) const +{ + size_t texture; + { + std::scoped_lock guard(m_rt->mutex); + texture = m_rt->texture_id; + } + // each image uploaded by a worker comes in a texture of its own + if (texture == 0 || texture == Window.shared_texture) + return; + Window.shared_texture = texture; + glBindTexture(GL_TEXTURE_2D, static_cast(texture)); +} + void python_screen_viewer::notify_window_fb_size(GLFWwindow const *window, int w, int h) const { for (auto const &conf : m_windows) { diff --git a/scripting/pythonscreenviewer.h b/scripting/pythonscreenviewer.h index ccd78f0ef..1d75d4d22 100644 --- a/scripting/pythonscreenviewer.h +++ b/scripting/pythonscreenviewer.h @@ -18,6 +18,7 @@ class python_screen_viewer std::unique_ptr shader; std::chrono::high_resolution_clock::time_point timestamp; + size_t shared_texture{0}; // with python.sharectx, the texture of the screen bound in this window's context window_state() = default; ~window_state(); @@ -33,6 +34,8 @@ class python_screen_viewer std::atomic_bool m_exit = false; void threadfunc(); + // with python.sharectx, binds the texture with the last image of the screen, in the context of the window made current + void bind_shared_texture(window_state &Window) const; public: python_screen_viewer(std::shared_ptr rt, std::shared_ptr> touchlist, std::string const &name);