18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-21 21:24:58 +01:00
Files
maszyna/model/Texture.h
maj00r 79c88c1793 Python screens: the worker's image goes in place only after its fence, not a bare glFlush (#411)
* 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.

* fix(python): the image of the worker goes in place once its fence is signalled, the viewer binds it each frame

From the review of 8811ee5a:

- glWaitSync ordered only the context of the main window. The extra viewports and the windows of
  python.displaywindows draw in contexts of their own and could bind the new texture before the upload
  was done. commit_thread_upload() now asks the fence without waiting (glClientWaitSync, timeout 0) and
  puts the image in place only once it is signalled, so every context binding it afterwards has it whole.
  Until then the task stays in the upload queue and is asked again the next frame.
- The drawing thread chose between upload and commit by python.threadedupload, the worker by whether it
  got a context. With python.threadedupload on and no context made for the worker, the screens were no
  longer updated. The task now records that a worker uploaded it.
- The viewer of python.displaywindows told a new image by its texture name, but a deleted name comes back
  for a later texture. It binds the name of the last image each frame, read under the lock of the render
  target, and the name it starts with is read on the drawing thread when it is made.

* fix(python): the old texture deleted under the lock the viewers bind under, a fence not made waited for with glFinish

From the review of #411:

- finish_upload() deleted the old texture before it took the lock of the render target, and the
  windows of python.displaywindows read the name under that lock but bound it after letting go of it.
  A window could bind a name already deleted, or already given to the next upload. In a compatibility
  context (the legacy renderer) that makes a new empty texture: a black frame and a texture never
  deleted. The commit and the publishing of the new name now go under the lock, and the viewer binds
  under it too. A name bound before the deletion stays alive in that window's context while bound.
- A glFenceSync that returns no fence was taken for a signalled one: the image went in place at once,
  with nothing ordering the contexts. The worker now waits for its upload with glFinish then, as
  without sync objects.

* fix(python): the worker waits for the lock of the screen without the gil, no flush after a finish

From the review of 939514ea:

- The drawing thread now holds the lock of the render target for a whole upload with
  python.threadedupload off. The worker, copying the next image under that lock, waited for it holding
  the gil. It now lets the gil go around the lock and the copy: the bytes it copies stay valid, the
  object is immutable and held by the reference the worker has.
- glFlush after glFinish did nothing; the worker flushes only when it made a fence.

---------

Co-authored-by: maj00r <maj00r@host>
2026-11-20 03:39:42 +01:00

310 lines
11 KiB
C++

/*
This Source Code Form is subject to the
terms of the Mozilla Public License, v.
2.0. If a copy of the MPL was not
distributed with this file, You can
obtain one at
http://mozilla.org/MPL/2.0/.
*/
#pragma once
#include <atomic>
#include <istream>
#include <limits>
#include <mutex>
#include <optional>
#include "winheaders.h"
#include <string>
#include "model/ResourceManager.h"
#include "gl/ubo.h"
#include "interfaces/ITexture.h"
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&);
static DDPIXELFORMAT deserialize_ddpf(std::istream&);
static DDSCAPS2 deserialize_ddscaps(std::istream&);
// constructors
opengl_texture() = default;
// methods
void
load();
bool
bind( size_t unit );
static void
unbind( size_t unit );
virtual bool
create( bool const Static = false ) override;
// releases resources allocated on the opengl end, storing local copy if requested
void
release() override;
void
make_stub() override;
void
alloc_rendertarget( GLint format, GLint components, int width, int height, int layers = 1, int samples = 1, GLint wrap = GL_CLAMP_TO_EDGE );
virtual void
set_components_hint( GLint hint ) override;
static void
reset_unit_cache();
// marks the unit cache as not to be trusted. safe to call from any thread: the cache itself is
// cleared by the thread drawing with it, the next time it binds textures (sync_unit_cache)
static void
invalidate_unit_cache();
// clears the unit cache if a thread marked it as not to be trusted since. called before the cache is read
static void
sync_unit_cache();
virtual int
get_width() const override {
return data_width; }
virtual
int
get_height() const override {
return data_height; }
virtual
size_t
get_id() const override {
return id; }
virtual
bool
is_stub() const override {
return is_texstub; }
virtual
bool
get_has_alpha() const override {
return has_alpha; }
virtual
bool
get_is_ready() const override {
return is_ready; }
virtual
std::string_view
get_traits() const override {
return traits; }
virtual
std::string_view
get_name() const override {
return name; }
virtual
std::string_view
get_type() const override {
return type; }
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;
bool commit_thread_upload() override;
// members
static constexpr GLuint invalid_id { std::numeric_limits<GLuint>::max() }; // id value of texture without GL resource
GLuint id{ invalid_id }; // associated GL resource
bool has_alpha{ false }; // indicates the texture has alpha channel
bool is_ready{ false }; // indicates the texture was processed and is ready for use
std::string traits; // requested texture attributes: wrapping modes etc
std::string name; // name of the texture source file
std::string type; // type of the texture source file
std::size_t size{ 0 }; // size of the texture data, in kb
GLint components_hint = 0; // components that material wants
GLenum target = GL_TEXTURE_2D;
static std::array<GLuint, gl::MAX_TEXTURES + gl::HELPER_TEXTURES> units;
static GLint m_activeunit;
// set by invalidate_unit_cache(), from the python upload thread too; the units themselves are touched only by the drawing thread
static std::atomic<bool> m_unitcachestale;
std::mutex m_threaduploadmutex;
std::optional<texture_thread_upload> m_threadupload; // guarded by m_threaduploadmutex
public:
// methods
void make_request();
void load_PNG();
void load_DDS();
void load_KTX();
void load_TEX();
void load_STBI();
void load_TGA();
void set_filtering() const;
void downsize( GLuint const Format );
void flip_vertical();
void gles_match_internalformat(GLuint format);
// takes over the data read by a worker thread, waiting for it if needed
void complete_data();
// with gfx.resource.move, copies the gl texture back into the data before it's released. requires the texture bound
bool read_back_compressed();
void read_back_uncompressed();
// members
std::shared_ptr<texture_request> request; // data being read by a worker thread
bool reload_on_use = false; // the data was dropped along with the gl texture of a far texture, it's read again when the texture is needed
bool is_static = false; // is excluded from garbage collection
bool is_rendertarget = false; // is used as postfx rendertarget, without loaded data
int samples = 1;
int layers = 1;
bool is_texstub = false; // for make_from_memory internal_src: functionality
std::vector<unsigned char> data; // texture data (stored GL-style, bottom-left origin)
resource_state data_state{ resource_state::none }; // current state of texture data
unsigned int data_width{ 0 },
data_height{ 0 },
data_mapcount{ 0 };
GLint data_format{ 0 },
data_components{ 0 };
GLint data_type = GL_UNSIGNED_BYTE;
GLint wrap_mode_s = GL_REPEAT;
GLint wrap_mode_t = GL_REPEAT;
/*
std::atomic<bool> is_loaded{ false }; // indicates the texture data was loaded and can be processed
std::atomic<bool> is_good{ false }; // indicates the texture data was retrieved without errors
*/
static std::unordered_map<GLint, int> precompressed_formats;
static std::unordered_map<GLint, GLint> drivercompressed_formats;
static std::unordered_map<GLint, std::unordered_map<GLint, GLint>> mapping;
};
class texture_manager {
public:
texture_manager();
~texture_manager() { delete_textures(); }
// activates specified texture unit
void
unit( GLint const Textureunit );
// creates texture object out of data stored in specified file
texture_handle
create( std::string Filename, bool const Loadnow = true, GLint Formathint = GL_SRGB_ALPHA );
// binds specified texture to specified texture unit
void
bind( std::size_t const Unit, texture_handle const Texture );
opengl_texture &
mark_as_used( texture_handle const Texture );
// provides direct access to specified texture object
opengl_texture &
texture( texture_handle const Texture ) const { return *m_textures[Texture].first; }
// performs a resource sweep
void
update();
// release of gl textures used only far away (gfx.textures.releasedistance). a scan is made of
// begin_release_scan(), mark_as_needed() for textures of each vehicle and release_unneeded()
void
begin_release_scan();
// marks texture of a vehicle as needed if the vehicle is near, otherwise only as one used by vehicles
void
mark_as_needed( texture_handle const Texture, bool const Near );
// releases gl textures of vehicles not needed nor drawn for a while
void
release_unneeded();
// takes a texture the scene has never drawn out of both the gfx card and the memory, e.g. the image of a picker scrolled
// past, or one read and not made yet; it's read again when it's used. textures the scene draws are left to the resource sweep
void
unload( texture_handle const Texture );
// debug performance string
std::string
info() const;
private:
// types:
typedef std::pair<
opengl_texture *,
resource_timestamp > texturetimepoint_pair;
typedef std::vector< texturetimepoint_pair > texturetimepointpair_sequence;
typedef std::unordered_map<std::string, std::size_t> index_map;
// methods:
// checks whether specified texture is in the texture bank. returns texture id, or npos.
texture_handle
find_in_databank( std::string const &Texturename ) const;
public:
// checks whether specified file exists. returns name of the located file, or empty string.
static std::pair<std::string, std::string>
find_on_disk( std::string const &Texturename );
private:
void
delete_textures();
// members:
texture_handle const npos { 0 }; // should be -1, but the rest of the code uses -1 for something else
texturetimepointpair_sequence m_textures;
index_map m_texturemappings;
std::vector<resource_timestamp> m_neededtimes; // last time a vehicle near enough needed the texture, blank for textures not used by vehicles
resource_timestamp m_releasescantime; // time of the current release scan
garbage_collector<texturetimepointpair_sequence> m_garbagecollector { m_textures, 600, 60, "texture" };
};
// reduces provided data image to half of original size, using basic 2x2 average
template <typename Colortype_>
void
downsample( std::size_t const Width, std::size_t const Height, unsigned char *Imagedata ) {
Colortype_ *destination = reinterpret_cast<Colortype_*>( Imagedata );
Colortype_ *sampler = reinterpret_cast<Colortype_*>( Imagedata );
Colortype_ accumulator, color;
/*
_Colortype color;
float component;
*/
for( std::size_t row = 0; row < Height; row += 2, sampler += Width ) { // column movement advances us down another row
for( std::size_t column = 0; column < Width; column += 2, sampler += 2 ) {
/*
// straightforward, but won't work with byte data
auto color = (
*sampler
+ *( sampler + 1 )
+ *( sampler + Width )
+ *( sampler + Width + 1 ) );
color /= 4;
*/
// manual version of the above, but drops colour resolution to 6 bits
accumulator = *sampler;
accumulator /= 4;
color = accumulator;
accumulator = *(sampler + 1);
accumulator /= 4;
color += accumulator;
accumulator = *(sampler + Width);
accumulator /= 4;
color += accumulator;
accumulator = *(sampler + Width + 1);
accumulator /= 4;
color += accumulator;
*destination++ = color;
/*
// "full" 8bit resolution
color = Colortype_(); component = 0;
for( int idx = 0; idx < sizeof( Colortype_ ); ++idx ) {
component = (
(*sampler)[idx]
+ ( *( sampler + 1 ) )[idx]
+ ( *( sampler + Width ) )[idx]
+ ( *( sampler + Width + 1 ))[idx] );
color[ idx ] = component /= 4;
}
*destination++ = color;
*/
}
}
}
//---------------------------------------------------------------------------