18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 07:24:57 +01:00
Files
maszyna/global_include/interfaces/ITexture.h
maj00r 8811ee5a76 fix(python): a screen uploaded by the worker goes into a texture of its own, put in place after a fence
With python.threadedupload (the default) the worker wrote the image into the texture the drawing thread
draws from, with glTexImage2D and glGenerateMipmap from its own context, and only a glFlush after. Nothing
ordered the two contexts: the drawing one could sample the texture while its storage was being made anew,
its level 0 half written or its mipmaps not made yet, and on a change of size the worker deleted the texture
and wrote a new name into `id` with no synchronisation.

The worker now uploads each image into a new texture, sets a fence after it and flushes. The drawing thread,
once per frame in python_taskqueue::update(), waits for that fence on the gpu (glWaitSync, the cpu goes on),
deletes the old texture and puts the new one in place. The worker no longer touches the texture drawn from,
nor `id`. An image the drawing thread didn't take yet is dropped by the next one. Without sync objects the
worker waits for the upload with glFinish.

The windows of python.displaywindows with python.sharectx bound the texture once; they now bind the name of
the last image put in place, which python_rt keeps for them.

Uploads on the drawing thread (python.threadedupload no, the Lua and WebAssembly screens, the editor) are
as they were.
2026-11-18 16:49:36 +01:00

86 lines
2.6 KiB
C++

#pragma once
using texture_handle = int;
#define null_handle (0)
struct ITexture
{
virtual bool create(bool Static = false) = 0;
virtual int get_width() const = 0;
virtual int get_height() const = 0;
virtual size_t get_id() const = 0;
virtual void release() = 0;
virtual void make_stub() = 0;
virtual std::string_view get_traits() const = 0;
virtual std::string_view get_name() const = 0;
virtual std::string_view get_type() const = 0;
virtual bool is_stub() const = 0;
virtual bool get_has_alpha() const = 0;
virtual bool get_is_ready() const = 0;
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
{
bool create(bool Static = false) override
{
return false;
}
bool is_stub() const override
{
return false;
}
int get_width() const override
{
return 1;
}
int get_height() const override
{
return 1;
}
size_t get_id() const override
{
return 0;
}
void release() override { /* null implementation, nothing to do */ }
void make_stub() override { /* null implementation, nothing to do */ }
std::string_view get_traits() const override
{
return "";
}
std::string_view get_name() const override
{
return "";
}
std::string_view get_type() const override
{
return "";
}
bool get_has_alpha() const override
{
return false;
}
bool get_is_ready() const override
{
return false;
}
void set_components_hint(int hint) override { /* null implementation, nothing to do */ }
void make_from_memory(size_t width, size_t height, const uint8_t *data) override { /* null implementation, nothing to do */ }
void update_from_memory(size_t width, size_t height, const uint8_t *data) override { /* null implementation, nothing to do */ }
};
static NullTexture null_texture{};
return &null_texture;
}
virtual ~ITexture() = default;
};