18
0
mirror of https://github.com/MaSzyna-EU07/maszyna.git synced 2026-11-19 21:34:58 +01:00

Script screens: led_post and resize of the Lua screens on the gpu

This commit is contained in:
2026-11-10 16:22:35 +01:00
parent c4924f756d
commit e433b43fef
20 changed files with 971 additions and 34 deletions

View File

@@ -344,6 +344,7 @@ if (WITH_OPENGL_MODERN)
"rendering/opengl33precipitation.cpp"
"rendering/opengl33particles.cpp"
"rendering/opengl33terrain.cpp"
"rendering/opengl33screenpost.cpp"
"rendering/opengl33renderer.cpp")
set(DEFINITIONS ${DEFINITIONS} "WITH_OPENGL_MODERN")
endif()

View File

@@ -430,6 +430,10 @@ int eu07_application::init(int Argc, char *Argv[])
if (Global.luascreens_enabled || Global.wasm_enabled)
{
m_screenqueue.init();
if (Global.screens_gpupost)
{
m_screenqueue.set_post_processor(GfxRenderer->Screen_post_processor());
}
}
if ((result = init_modes()) != 0)
{
@@ -727,6 +731,8 @@ void eu07_application::exit()
mode.reset();
step("the renderer");
// the screens' post-processing goes with the renderer
m_screenqueue.set_post_processor(nullptr);
GfxRenderer->Shutdown();
m_network.reset();

View File

@@ -416,6 +416,21 @@ bool opengl33_renderer::Init(GLFWwindow *Window)
void opengl33_renderer::Shutdown()
{
vr.reset();
m_screen_post.reset();
}
script_screens::post_processor *opengl33_renderer::Screen_post_processor()
{
// GLES converts what's written into an sRGB texture, and the passes give the bytes as they are: the cpu does it there
if (Global.gfx_usegles)
{
return nullptr;
}
if (m_screen_post == nullptr)
{
m_screen_post = std::make_unique<opengl33_screen_post>();
}
return m_screen_post.get();
}
bool opengl33_renderer::AddViewport(const global_settings::extraviewport_config &conf)

View File

@@ -30,6 +30,7 @@ http://mozilla.org/MPL/2.0/.
#include "gl/pbo.h"
#include "gl/query.h"
#include "rendering/opengl33terrain.h"
#include "rendering/opengl33screenpost.h"
// bare-bones render controller, in lack of anything better yet
class opengl33_renderer : public gfx_renderer {
@@ -145,6 +146,7 @@ class opengl33_renderer : public gfx_renderer {
info_stats() const override;
void MakeScreenshot() override;
bool Render_Preview( TAnimModel *Instance, int const Size, int const Margin, bool const Shadows, std::vector<std::uint8_t> &Image ) override;
script_screens::post_processor *Screen_post_processor() override;
@@ -515,6 +517,7 @@ class opengl33_renderer : public gfx_renderer {
std::unique_ptr<gl::program> m_celestial_shader;
std::unique_ptr<gl::program> m_hiddenarea_shader;
std::unique_ptr<gl::program> m_copy_shader;
std::unique_ptr<opengl33_screen_post> m_screen_post; // made on the first request
std::unique_ptr<gl::vao> m_empty_vao;

View File

@@ -0,0 +1,250 @@
/*
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/.
*/
#include "stdafx.h"
#include "rendering/opengl33screenpost.h"
#include "model/Texture.h"
#include "utilities/Logs.h"
#include <format>
#include <functional>
namespace
{
// the state of the context the passes change, put back after them
class saved_state
{
public:
saved_state()
{
glGetIntegerv(GL_VIEWPORT, m_viewport.data());
glGetBooleanv(GL_COLOR_WRITEMASK, m_colormask.data());
glGetBooleanv(GL_DEPTH_WRITEMASK, &m_depthmask);
for (std::size_t idx = 0; idx < m_capabilities.size(); ++idx)
{
m_enabled[idx] = glIsEnabled(m_capabilities[idx]);
glDisable(m_capabilities[idx]);
}
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
glDepthMask(GL_FALSE);
}
~saved_state()
{
for (std::size_t idx = 0; idx < m_capabilities.size(); ++idx)
{
if (m_enabled[idx] == GL_TRUE)
{
glEnable(m_capabilities[idx]);
}
}
glColorMask(m_colormask[0], m_colormask[1], m_colormask[2], m_colormask[3]);
glDepthMask(m_depthmask);
glViewport(m_viewport[0], m_viewport[1], m_viewport[2], m_viewport[3]);
}
saved_state(saved_state const &) = delete;
saved_state &operator=(saved_state const &) = delete;
private:
// GL_FRAMEBUFFER_SRGB off: the passes write the bytes of the image into the screen's sRGB texture as they are, as
// update_from_memory puts them there
static constexpr std::array<GLenum, 6> m_capabilities{GL_DEPTH_TEST, GL_BLEND, GL_CULL_FACE, GL_SCISSOR_TEST, GL_STENCIL_TEST, GL_FRAMEBUFFER_SRGB};
std::array<GLboolean, 6> m_enabled{};
std::array<GLint, 4> m_viewport{};
std::array<GLboolean, 4> m_colormask{};
GLboolean m_depthmask{GL_TRUE};
};
void unbind_all()
{
gl::framebuffer::unbind();
gl::program::unbind();
gl::vao::unbind();
}
// the screen's texture made the size of the result, in the format update_from_memory gives it
void prepare_target(opengl_texture &Target, int const Width, int const Height)
{
if (Target.id != opengl_texture::invalid_id && Target.data_width == static_cast<unsigned int>(Width) && Target.data_height == static_cast<unsigned int>(Height) &&
Target.data_format == GL_SRGB8_ALPHA8 && Target.data_components == GL_RGBA)
{
return;
}
Target.update_from_memory(Width, Height, nullptr);
}
} // namespace
opengl33_screen_post::~opengl33_screen_post()
{
for (auto const *owned : {&m_source, &m_between[0], &m_between[1]})
{
if (owned->texture != 0)
{
glDeleteTextures(1, &owned->texture);
}
}
}
opengl33_screen_post::stage opengl33_screen_post::make_stage(gl::shader const &Vertex, std::string const &Fragment)
{
gl::shader const fragment{Fragment};
stage result;
result.program = std::make_unique<gl::program>(std::vector<std::reference_wrapper<gl::shader const>>{Vertex, fragment});
auto const program{static_cast<GLuint>(*result.program)};
result.source_size = glGetUniformLocation(program, "source_size");
result.target_size = glGetUniformLocation(program, "target_size");
result.flip = glGetUniformLocation(program, "flip");
result.mode = glGetUniformLocation(program, "mode");
result.program->bind();
glUniform1i(glGetUniformLocation(program, "source"), 0);
return result;
}
bool opengl33_screen_post::setup()
{
if (m_failed)
{
return false;
}
if (m_led.program != nullptr)
{
return true;
}
try
{
gl::shader const vertex{"quad.vert"};
m_led = make_stage(vertex, "screen_led.frag");
m_resize = make_stage(vertex, "screen_resize.frag");
}
catch (gl::shader_exception const &Error)
{
ErrorLog(std::format("Script screens: the shaders of the post-processing failed: {}", Error.what()));
m_failed = true;
return false;
}
m_vao = std::make_unique<gl::vao>();
m_framebuffer = std::make_unique<gl::framebuffer>();
WriteLog("Script screens: the post-processing of the images runs on the gpu");
return true;
}
void opengl33_screen_post::store(surface &Surface, int const Width, int const Height, std::uint8_t const *Pixels)
{
if (Surface.texture == 0)
{
glGenTextures(1, &Surface.texture);
glBindTexture(GL_TEXTURE_2D, Surface.texture);
// read with texelFetch: no mipmaps, nothing filtered
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
}
else
{
glBindTexture(GL_TEXTURE_2D, Surface.texture);
}
if (Surface.width != Width || Surface.height != Height)
{
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, Width, Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, Pixels);
Surface.width = Width;
Surface.height = Height;
}
else if (Pixels != nullptr)
{
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, Width, Height, GL_RGBA, GL_UNSIGNED_BYTE, Pixels);
}
}
std::vector<opengl33_screen_post::pass> opengl33_screen_post::passes_of(std::span<script_screens::post_step const> const Steps, int Width, int Height) const
{
std::vector<pass> result;
for (auto const &step : Steps)
{
if (step.type == script_screens::post_step::kind::led)
{
Width = Width * 2 + 2;
Height = Height * 2 + 2;
result.emplace_back(&m_led, Width, Height, step.bloom ? 1 : 0);
continue;
}
result.emplace_back(&m_resize, step.width, Height, 0);
result.emplace_back(&m_resize, step.width, step.height, 1);
Width = step.width;
Height = step.height;
}
return result;
}
bool opengl33_screen_post::draw(pass const &Pass, surface const &Source, GLuint const Target, bool const Last) const
{
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, Target, 0);
if (auto const status{glCheckFramebufferStatus(GL_FRAMEBUFFER)}; status != GL_FRAMEBUFFER_COMPLETE)
{
ErrorLog(std::format("Script screens: the post-processing can't draw into a texture, framebuffer status {:#x}", status));
return false;
}
glViewport(0, 0, Pass.width, Pass.height);
Pass.shader->program->bind();
glUniform2i(Pass.shader->source_size, Source.width, Source.height);
glUniform2i(Pass.shader->target_size, Pass.width, Pass.height);
glUniform1i(Pass.shader->flip, Last ? 1 : 0);
glUniform1i(Pass.shader->mode, Pass.mode);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, Source.texture);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
return true;
}
bool opengl33_screen_post::apply(ITexture &Target, std::span<std::uint8_t const> const Pixels, int const Width, int const Height,
std::span<script_screens::post_step const> const Steps)
{
auto *target{dynamic_cast<opengl_texture *>(&Target)};
if (target == nullptr || Steps.empty() || Pixels.size() < script_screens::image_size(Width, Height) || false == setup())
{
return false;
}
auto const passes{passes_of(Steps, Width, Height)};
prepare_target(*target, passes.back().width, passes.back().height);
auto succeeded{true};
{
saved_state const saved;
// what the binding caches of gl:: hold may not be what's bound now: bound anew, and left unbound after the passes
unbind_all();
m_framebuffer->bind();
m_vao->bind();
store(m_source, Width, Height, Pixels.data());
auto const *source{&m_source};
for (std::size_t idx = 0; idx < passes.size() && succeeded; ++idx)
{
auto const last{idx + 1 == passes.size()};
auto &between{m_between[idx % 2]};
if (false == last)
{
store(between, passes[idx].width, passes[idx].height, nullptr);
}
succeeded = draw(passes[idx], *source, last ? target->id : between.texture, last);
source = &between;
}
// the screen's texture isn't held by the framebuffer when it's made anew
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
unbind_all();
}
if (succeeded)
{
glBindTexture(GL_TEXTURE_2D, target->id);
glGenerateMipmap(GL_TEXTURE_2D);
}
// the textures bound here went past the unit cache
opengl_texture::reset_unit_cache();
return succeeded;
}

View File

@@ -0,0 +1,77 @@
/*
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 "scripting/scriptscreens.h"
#include "gl/framebuffer.h"
#include "gl/shader.h"
#include "gl/vao.h"
#include <array>
#include <cstdint>
#include <memory>
#include <span>
#include <string>
#include <vector>
// the post-processing of the script screens (image:led_post, image:resize) on the gpu, for the OpenGL 3.3 renderer: a
// pass for a led_post and two for a resize (along the rows, then along the columns), the last pass into the screen's
// texture. shaders/screen_led.frag and shaders/screen_resize.frag give the pixels of scripting/scriptscreenkernels.cpp
class opengl33_screen_post final : public script_screens::post_processor
{
public:
opengl33_screen_post() = default;
~opengl33_screen_post() override;
bool apply(ITexture &Target, std::span<std::uint8_t const> Pixels, int Width, int Height, std::span<script_screens::post_step const> Steps) override;
private:
// a shader of the passes, with the places of its uniforms
struct stage
{
std::unique_ptr<gl::program> program;
GLint source_size{-1};
GLint target_size{-1};
GLint flip{-1};
GLint mode{-1};
};
// a texture the passes read
struct surface
{
GLuint texture{0};
int width{0};
int height{0};
};
struct pass
{
stage const *shader;
int width;
int height;
int mode; // led: 1 with the glow; resize: 0 along the rows, 1 along the columns
};
// makes the shaders on the first use. false when they failed, then and from then on
bool setup();
std::vector<pass> passes_of(std::span<script_screens::post_step const> Steps, int Width, int Height) const;
// draws a pass from the source into the texture; Last: the rows go bottom row first, as the screen's texture takes them
bool draw(pass const &Pass, surface const &Source, GLuint Target, bool Last) const;
static stage make_stage(gl::shader const &Vertex, std::string const &Fragment);
// sizes the texture, and fills it when there are pixels
static void store(surface &Surface, int Width, int Height, std::uint8_t const *Pixels);
bool m_failed{false};
stage m_led;
stage m_resize;
std::unique_ptr<gl::vao> m_vao;
std::unique_ptr<gl::framebuffer> m_framebuffer;
surface m_source; // the image as drawn
std::array<surface, 2> m_between; // what the passes before the last one give, in turn
};

View File

@@ -21,6 +21,11 @@ namespace gl
class program;
}
namespace script_screens
{
class post_processor;
}
namespace gfx
{
// material painted over the heightmap terrain, and the size (metres) its textures are repeated at; 0: the size given by the material, or 8 m
@@ -130,6 +135,9 @@ public:
// seen in perspective from the front, side and above and filling the image less Margin pixels at each edge.
// Image receives rgb rows, top row first. returns false if the backend can't make previews or there's nothing to draw
virtual auto Render_Preview( TAnimModel *Instance, int const Size, int const Margin, bool const Shadows, std::vector<std::uint8_t> &Image ) -> bool { return false; }
// runs the post-processing of the script screens (image:led_post, image:resize) on the gpu. nullptr when the backend
// can't; the screens then do it on the cpu
virtual auto Screen_post_processor() -> script_screens::post_processor * { return nullptr; }
};
class gfx_renderer_factory

View File

@@ -23,6 +23,7 @@ the reason goes to the log.
| `wasm.enabled` | 1 | 0: no WebAssembly screens; the vehicles show what they did before |
| `screens.cabframes` | 4 | a screen in the cab is refreshed every so many frames (1-1000) |
| `screens.externalframes` | 30 | a screen outside the cab (destination sign) is refreshed every so many frames |
| `screens.gpupost` | 1 | 0: `led_post` and `resize` of the Lua screens always run on the cpu, as they did before |
`wasm.cabframes` and `wasm.externalframes`, the first names of the last two, are read as well.
@@ -118,14 +119,24 @@ glyph (`led_util` picks a random one).
| `image:draw_text_right(...)`, `image:draw_text_centered(...)` | the same, ending at `x` or centred on it (`draw_strl`, `draw_strc`) |
| `image:draw_sprite(sprite, x, y, color)` | the lit pixels of the sprite (`draw_spr`) |
| `image:draw_image(image, x, y)` | another image, clipped |
| `image:led_post([bloom])` | `led_util.render_post()`: a new image, each pixel a 2x2 diode with a darker grid, glowing (`bloom`, on by default), in a 1 pixel black frame |
| `image:resize(width, height)` | a new image, scaled as Pillow's `resize(..., Image.LANCZOS)`, with the same pixels |
| `image:led_post([bloom])` | `led_util.render_post()`: a new image, each pixel a 2x2 diode with a darker grid, glowing (`bloom`, on by default), in a 1 pixel black frame. see below for when it runs |
| `image:resize(width, height)` | a new image, scaled as Pillow's `resize(..., Image.LANCZOS)`, with the same pixels. see below for when it runs |
| `image:copy()` | a new image, the same |
| `font:height()`, `font:text_width(text [, spacing])` | the height, the width of a text (`get_str_len`) |
| `sprite:width()`, `sprite:height()` | the size |
The drawing, `led_post` and `resize` run natively in the game, so a script only says what goes where.
`led_post` and `resize` only note what is to be done; the image's size is known right away. They run when the image is
used:
- on the image `render` returns, on the gpu, into the screen's texture. Only the screens that ask for them pay for
them, and the texture gets the small image as drawn rather than the large one. The gpu gives the pixels of the cpu,
give or take one step of brightness here and there, from rounding in single precision.
- on the cpu, as soon as the script reads the image (`get`), draws on it, or draws it on another image.
- on the cpu, in the screens' worker, when the renderer can't do it on the gpu (the NVRHI renderer, OpenGL ES, a
shader that failed to load) or `screens.gpupost` is 0. A shader that fails is logged once, and the cpu takes over.
## WebAssembly modules
A module exports:

View File

@@ -145,9 +145,63 @@ template <typename Type_> Type_ &check_object(lua_State *L, int const Index, cha
return *object;
}
// an image of a script: what was drawn on it, and the post-processing (image:led_post, image:resize) asked for and not
// run yet. the steps of the image render returns run in the queue, on the gpu when the renderer can; the steps of an
// image the script goes on to read or draw on (or with) run here, on the cpu, when it does
struct lua_image
{
canvas drawn;
std::vector<post_step> steps;
int width() const
{
auto result{drawn.width()};
for (auto const &step : steps)
{
result = width_after(step, result);
}
return result;
}
int height() const
{
auto result{drawn.height()};
for (auto const &step : steps)
{
result = height_after(step, result);
}
return result;
}
// the image with its post-processing done
canvas &done()
{
if (false == steps.empty())
{
post_image image{drawn.pixels(), drawn.width(), drawn.height()};
// the sizes were checked when the steps were asked for
apply_post(image, steps);
drawn = canvas{image.width, image.height, std::move(image.pixels)};
steps.clear();
}
return drawn;
}
// the image, a step further
lua_image then(post_step const &Step) const
{
lua_image result{drawn, steps};
result.steps.push_back(Step);
return result;
}
};
lua_image &check_lua_image(lua_State *L, int const Index)
{
return check_object<lua_image>(L, Index, image_metatable);
}
// the image, to read or draw on: its post-processing is done first
canvas &check_image(lua_State *L, int const Index)
{
return check_object<canvas>(L, Index, image_metatable);
return check_lua_image(L, Index).done();
}
int check_int(lua_State *L, int const Index)
@@ -226,7 +280,7 @@ int api_image(lua_State *L)
luaL_argcheck(L, valid_image_side(width), 1, "between 1 and 4096");
luaL_argcheck(L, valid_image_side(height), 2, "between 1 and 4096");
auto const color{lua_isnoneornil(L, 3) ? rgb{0, 0, 0} : check_color(L, 3)};
push_object(L, canvas{width, height, color}, image_metatable);
push_object(L, lua_image{canvas{width, height, color}, {}}, image_metatable);
return 1;
}
@@ -388,13 +442,13 @@ int api_include(lua_State *L)
int image_width(lua_State *L)
{
lua_pushinteger(L, check_image(L, 1).width());
lua_pushinteger(L, check_lua_image(L, 1).width());
return 1;
}
int image_height(lua_State *L)
{
lua_pushinteger(L, check_image(L, 1).height());
lua_pushinteger(L, check_lua_image(L, 1).height());
return 1;
}
@@ -498,36 +552,39 @@ int image_draw_image(lua_State *L)
return 0;
}
// image:led_post([bloom]): led_util's render_post, a new image (2w + 2) x (2h + 2)
// image:led_post([bloom]): led_util's render_post, a new image (2w + 2) x (2h + 2). done when the image is shown or used
int image_led_post(lua_State *L)
{
auto const &image{check_image(L, 1)};
auto const &image{check_lua_image(L, 1)};
auto const bloom{lua_isnoneornil(L, 2) || lua_toboolean(L, 2) != 0};
luaL_argcheck(L, valid_image_side(image.width() * 2 + 2) && valid_image_side(image.height() * 2 + 2), 1, "too large");
std::vector<std::uint8_t> pixels(image_size(image.width() * 2 + 2, image.height() * 2 + 2));
led_post(image.pixels(), image.width(), image.height(), pixels, bloom);
push_object(L, canvas{image.width() * 2 + 2, image.height() * 2 + 2, std::move(pixels)}, image_metatable);
post_step step;
step.type = post_step::kind::led;
step.bloom = bloom;
push_object(L, image.then(step), image_metatable);
return 1;
}
// image:resize(width, height): scaled as Pillow's resize(..., LANCZOS), a new image
// image:resize(width, height): scaled as Pillow's resize(..., LANCZOS), a new image. done when the image is shown or used
int image_resize(lua_State *L)
{
auto const &image{check_image(L, 1)};
auto const &image{check_lua_image(L, 1)};
auto const width{check_int(L, 2)};
auto const height{check_int(L, 3)};
luaL_argcheck(L, valid_image_side(width), 2, "between 1 and 4096");
luaL_argcheck(L, valid_image_side(height), 3, "between 1 and 4096");
std::vector<std::uint8_t> pixels(image_size(width, height));
resize_lanczos(image.pixels(), image.width(), image.height(), pixels, width, height);
push_object(L, canvas{width, height, std::move(pixels)}, image_metatable);
post_step step;
step.type = post_step::kind::resize;
step.width = width;
step.height = height;
push_object(L, image.then(step), image_metatable);
return 1;
}
int image_copy(lua_State *L)
{
auto const &image{check_image(L, 1)};
push_object(L, canvas{image}, image_metatable);
auto const &image{check_lua_image(L, 1)};
push_object(L, lua_image{image}, image_metatable);
return 1;
}
@@ -695,7 +752,7 @@ void lua_program::register_api()
lua_pushlightuserdata(L, this);
lua_rawset(L, LUA_REGISTRYINDEX);
make_metatable(L, image_metatable, image_methods, collect<canvas>);
make_metatable(L, image_metatable, image_methods, collect<lua_image>);
make_metatable(L, font_metatable, font_methods, collect<bitmap_font>);
make_metatable(L, sprite_metatable, sprite_methods, collect<glyph>);
@@ -806,11 +863,12 @@ bool lua_program::render(render_call &Call)
}
// nil: the screen didn't change, keep the image there is
auto succeeded{true};
if (auto const *image{test_object<canvas>(m_state, -1, image_metatable)}; image != nullptr)
if (auto const *image{test_object<lua_image>(m_state, -1, image_metatable)}; image != nullptr)
{
Call.pixels = image->pixels();
Call.width = image->width();
Call.height = image->height();
Call.pixels = image->drawn.pixels();
Call.width = image->drawn.width();
Call.height = image->drawn.height();
Call.post = image->steps;
}
else if (false == lua_isnil(m_state, -1))
{

View File

@@ -14,6 +14,7 @@ http://mozilla.org/MPL/2.0/.
#include <array>
#include <cmath>
#include <numbers>
#include <utility>
#include <vector>
namespace script_screens
@@ -239,4 +240,42 @@ bool resize_lanczos(std::span<std::uint8_t const> const Source, int const Width,
return true;
}
int width_after(post_step const &Step, int const Width)
{
return Step.type == post_step::kind::led ? Width * 2 + 2 : Step.width;
}
int height_after(post_step const &Step, int const Height)
{
return Step.type == post_step::kind::led ? Height * 2 + 2 : Step.height;
}
bool apply_post(post_image &Image, std::span<post_step const> const Steps)
{
if (Steps.empty())
{
return true;
}
auto result{Image};
for (auto const &step : Steps)
{
auto const width{width_after(step, result.width)};
auto const height{height_after(step, result.height)};
if (width <= 0 || height <= 0)
{
return false;
}
std::vector<std::uint8_t> pixels(image_size(width, height));
auto const done{step.type == post_step::kind::led ? led_post(result.pixels, result.width, result.height, pixels, step.bloom)
: resize_lanczos(result.pixels, result.width, result.height, pixels, width, height)};
if (false == done)
{
return false;
}
result = post_image{std::move(pixels), width, height};
}
Image = std::move(result);
return true;
}
} // namespace script_screens

View File

@@ -9,8 +9,10 @@ http://mozilla.org/MPL/2.0/.
#pragma once
#include <cstddef>
#include <cstdint>
#include <span>
#include <vector>
// image filters the script screens call through the host (led_post, resize_lanczos), run natively rather than
// in the interpreter. they give the very pixels of the Python screens: led_util.render_post() and Pillow's
@@ -33,4 +35,32 @@ bool led_post(std::span<std::uint8_t const> Source, int Width, int Height, std::
// for sizes that don't fit the spans
bool resize_lanczos(std::span<std::uint8_t const> Source, int Width, int Height, std::span<std::uint8_t> Target, int TargetWidth, int TargetHeight);
// one step of the post-processing a script asks for on its image (image:led_post, image:resize). the steps of the image
// render returns run on the gpu when the renderer can (script_screens::post_processor), otherwise on the cpu
struct post_step
{
enum class kind
{
led, // led_post
resize // resize_lanczos
};
kind type{kind::led};
bool bloom{true}; // led: with the glow
int width{0}; // resize: the size it gives
int height{0};
};
struct post_image
{
std::vector<std::uint8_t> pixels; // RGBA, from the top row down
int width{0};
int height{0};
};
// the size of an image Width wide, or Height high, after the step
int width_after(post_step const &Step, int Width);
int height_after(post_step const &Step, int Height);
// runs the steps on the cpu, one after another. false for sizes the kernels refuse; the image is then as it was
bool apply_post(post_image &Image, std::span<post_step const> Steps);
} // namespace script_screens

View File

@@ -47,6 +47,8 @@ struct render_call
std::vector<std::uint8_t> pixels;
int width{0};
int height{0};
// the post-processing still to run on the image (image:led_post, image:resize of the Lua screens)
std::vector<post_step> post;
};
// a running script: a Lua state, a WebAssembly instance. made, called and destroyed on the worker thread, or by the

View File

@@ -31,6 +31,7 @@ http://mozilla.org/MPL/2.0/.
#include <iterator>
#include <limits>
#include <mutex>
#include <span>
#include <stop_token>
#include <string_view>
#include <thread>
@@ -129,6 +130,32 @@ std::string_view language_name(script_language const Language)
return Language == script_language::lua ? "Lua" : "WASM";
}
// the rows of the image the other way round. the script draws from the top row down; the texture takes the bottom row
// first, as the python screens give it (abstractscreenrenderer flips the image before handing it over)
std::vector<std::uint8_t> flipped(std::span<std::uint8_t const> const Pixels, int const Width, int const Height)
{
auto const row{static_cast<std::size_t>(Width) * 4};
auto const height{static_cast<std::size_t>(Height)};
std::vector<std::uint8_t> result(Pixels.size());
for (std::size_t y = 0; y < height; ++y)
{
std::memcpy(result.data() + (height - 1 - y) * row, Pixels.data() + y * row, row);
}
return result;
}
// the post-processing of the image done on the cpu. false when the kernels refused a size
bool post_on_cpu(std::vector<std::uint8_t> &Pixels, int &Width, int &Height, std::vector<script_screens::post_step> &Steps)
{
script_screens::post_image image{std::move(Pixels), Width, Height};
auto const done{script_screens::apply_post(image, Steps)};
Pixels = std::move(image.pixels);
Width = image.width;
Height = image.height;
Steps.clear();
return done;
}
} // namespace
class script_screen
@@ -159,11 +186,13 @@ class script_screen
// the worker's, and the queue's once the worker stopped
std::unique_ptr<script_screens::program> program;
// the image, handed from the worker to the main thread, bottom row first as the texture takes it
// the image, handed from the worker to the main thread: bottom row first as the texture takes it, or, while it has
// post-processing to run on the gpu, from the top row down as the script drew it
std::mutex image_mutex;
std::vector<std::uint8_t> image;
int image_width{0};
int image_height{0};
std::vector<script_screens::post_step> post;
bool image_pending{false}; // drawn and not yet uploaded
std::size_t uploaded_texture{no_texture}; // the gl texture the image went to, to upload it again when it's made anew
@@ -188,7 +217,9 @@ struct script_screen_queue::implementation
return Language == script_language::lua ? lua.get() : wasm.get();
}
static void present(script_screen &Screen, script_screens::render_call &Call);
static void upload(script_screen &Screen);
void upload(script_screen &Screen);
// the post-processing of the image the gpu couldn't do, done on the cpu. false when it failed too
static bool finish_on_cpu(script_screen &Screen);
static void execute(script_screens::pending_command const &Command);
std::unique_ptr<script_screens::runtime> lua;
@@ -196,6 +227,11 @@ struct script_screen_queue::implementation
bool initialized{false};
std::atomic<std::uint64_t> frame{0};
// the main thread's: the gpu post-processing, none when the renderer has none, or it failed
script_screens::post_processor *post_processor{nullptr};
// read by the worker: the post-processing is left to the main thread, for the gpu
std::atomic<bool> post_on_gpu{false};
std::mutex screens_mutex;
std::unordered_map<std::string, std::weak_ptr<script_screen>> screens;
@@ -273,6 +309,12 @@ void script_screen_queue::implementation::process(task const &Task)
screen.failed = true;
return;
}
if (false == call.post.empty() && false == post_on_gpu && false == post_on_cpu(call.pixels, call.width, call.height, call.post))
{
ErrorLog(std::format("{} screen \"{}\": the post-processing of the image failed", language_name(screen.language), screen.script));
screen.failed = true;
return;
}
present(screen, call);
}
if (false == call.commands.empty())
@@ -282,23 +324,37 @@ void script_screen_queue::implementation::process(task const &Task)
}
}
// keeps the image the screen drew. the script draws from the top row down; the texture takes the bottom row first, as
// the python screens give it (abstractscreenrenderer flips the image before handing it over)
// keeps the image the screen drew, turned bottom row first for the texture; with post-processing left for the gpu, as
// it was drawn
void script_screen_queue::implementation::present(script_screen &Screen, script_screens::render_call &Call)
{
auto const row{static_cast<std::size_t>(Call.width) * 4};
auto const height{static_cast<std::size_t>(Call.height)};
std::scoped_lock lock{Screen.image_mutex};
Screen.image.resize(Call.pixels.size());
for (std::size_t y = 0; y < height; ++y)
if (Call.post.empty())
{
std::memcpy(Screen.image.data() + (height - 1 - y) * row, Call.pixels.data() + y * row, row);
Screen.image = flipped(Call.pixels, Call.width, Call.height);
}
else
{
Screen.image = std::move(Call.pixels);
}
Screen.post = std::move(Call.post);
Screen.image_width = Call.width;
Screen.image_height = Call.height;
Screen.image_pending = true;
}
bool script_screen_queue::implementation::finish_on_cpu(script_screen &Screen)
{
if (false == post_on_cpu(Screen.image, Screen.image_width, Screen.image_height, Screen.post))
{
ErrorLog(std::format("{} screen \"{}\": the post-processing of the image failed", language_name(Screen.language), Screen.script));
Screen.image.clear();
return false;
}
Screen.image = flipped(Screen.image, Screen.image_width, Screen.image_height);
return true;
}
void script_screen_queue::implementation::upload(script_screen &Screen)
{
if (Screen.texture == nullptr)
@@ -315,7 +371,26 @@ void script_screen_queue::implementation::upload(script_screen &Screen)
{
return;
}
Screen.texture->update_from_memory(Screen.image_width, Screen.image_height, Screen.image.data());
auto const on_gpu{false == Screen.post.empty() && post_processor != nullptr &&
post_processor->apply(*Screen.texture, Screen.image, Screen.image_width, Screen.image_height, Screen.post)};
if (false == on_gpu)
{
if (false == Screen.post.empty())
{
// the gpu can't do it: the cpu does, here this time, and on the worker from now on
if (post_processor != nullptr)
{
WriteLog("Script screens: the post-processing of the images goes to the cpu");
}
post_processor = nullptr;
post_on_gpu = false;
if (false == finish_on_cpu(Screen))
{
return;
}
}
Screen.texture->update_from_memory(Screen.image_width, Screen.image_height, Screen.image.data());
}
Screen.uploaded_texture = Screen.texture->get_id();
Screen.image_pending = false;
}
@@ -481,7 +556,7 @@ void script_screen_queue::update()
{
if (auto const live{screen.lock()}; live != nullptr)
{
implementation::upload(*live);
m_impl->upload(*live);
}
}
}
@@ -496,6 +571,12 @@ void script_screen_queue::update()
}
}
void script_screen_queue::set_post_processor(script_screens::post_processor *Processor)
{
m_impl->post_processor = Processor;
m_impl->post_on_gpu = Processor != nullptr;
}
#ifndef WITH_LUA
std::unique_ptr<script_screens::runtime> script_screens::make_lua_runtime()
{

View File

@@ -10,16 +10,37 @@ http://mozilla.org/MPL/2.0/.
#pragma once
#include "scripting/scriptscreenrules.h"
#include "scripting/scriptscreenkernels.h"
#include <cstdint>
#include <memory>
#include <optional>
#include <span>
#include <string>
#include <string_view>
struct ITexture;
struct dictionary_source;
namespace script_screens
{
// runs the post-processing of a screen's image (image:led_post, image:resize) on the gpu, into the screen's texture.
// given by the renderer that can (gfx_renderer::Screen_post_processor); used on the main thread
class post_processor
{
public:
post_processor() = default;
virtual ~post_processor() = default;
post_processor(post_processor const &) = delete;
post_processor &operator=(post_processor const &) = delete;
// Pixels: the image drawn, Width x Height, RGBA from the top row down. the texture gets the result bottom row first,
// as update_from_memory takes it, with its mipmaps. false when it can't; the screen then does the steps on the cpu
virtual bool apply(ITexture &Target, std::span<std::uint8_t const> Pixels, int Width, int Height, std::span<post_step const> Steps) = 0;
};
} // namespace script_screens
// screens drawn by scripts, the counterpart of the python screens (scripting/PyInt.h): Lua scripts run by LuaJIT
// (luascreen:, luadestinationsign:) and WebAssembly modules run by WAMR (wasmscreen:, wasmdestinationsign:). a script
// gets the state a python screen gets, returns an RGBA image and, in the cab, may send commands. the interface is
@@ -91,6 +112,9 @@ class script_screen_queue
// main thread, once per rendered frame: uploads the finished images, runs the commands the screens sent and
// counts the frame
void update();
// main thread: the post-processing of the images goes to the gpu through the processor; with none (the default) it
// runs on the worker, on the cpu
void set_post_processor(script_screens::post_processor *Processor);
private:
struct implementation;

76
shaders/screen_led.frag Normal file
View File

@@ -0,0 +1,76 @@
// image:led_post of the script screens on the gpu (rendering/opengl33screenpost.cpp), the pixels of led_post in
// scripting/scriptscreenkernels.cpp (led_util.render_post): each diode becomes 2x2 pixels with a darker grid between
// them, glowing into its neighbours, in a 1 pixel black frame
uniform sampler2D source; // the image, from the top row down
uniform ivec2 source_size;
uniform ivec2 target_size;
uniform int flip; // 1: the rows are written bottom row first, as the screen's texture takes them
uniform int mode; // 1: with the glow
layout(location = 0) out vec4 out_color;
const int glow_radius = 6;
const float glow_factor = 0.08;
ivec3 diode(ivec2 at)
{
return ivec3(round(texelFetch(source, at, 0).rgb * 255.0));
}
// the light gathered from the diodes around, weighted 1 / (0.08 + distance squared)
ivec3 glow(ivec2 at)
{
vec3 sum = vec3(0.0);
int left = max(at.x - glow_radius, 0);
int right = min(at.x + glow_radius + 1, source_size.x);
int top = max(at.y - glow_radius, 0);
int bottom = min(at.y + glow_radius + 1, source_size.y);
for (int i = left; i < right; ++i)
{
float m = glow_factor + float((i - at.x) * (i - at.x));
if (m > 20.0)
continue;
for (int j = top; j < bottom; ++j)
{
float s = m + float((j - at.y) * (j - at.y));
if (s > 20.0)
continue;
sum += vec3(diode(ivec2(i, j))) / s;
}
}
return ivec3(sum * glow_factor);
}
// the light through the grid, rounded down as led_util gets it in double precision. there 1 - 0.15 gives the exact
// result, but 1 - 2 * 0.15 is a little below 0.7, which takes these lights one lower (above 360 the result is clamped
// to 255 anyway)
int shaded(int light, int grid)
{
if (grid == 0)
return light;
if (grid == 1)
return light * 85 / 100;
int result = light * 70 / 100;
if (light == 90 || light == 170 || light == 180 || (light >= 330 && light <= 360 && light % 10 == 0))
result -= 1;
return result;
}
void main()
{
ivec2 at = ivec2(gl_FragCoord.xy);
if (flip != 0)
at.y = target_size.y - 1 - at.y;
if (at.x == 0 || at.y == 0 || at.x == target_size.x - 1 || at.y == target_size.y - 1)
{
out_color = vec4(0.0, 0.0, 0.0, 1.0);
return;
}
ivec2 pixel = at - 1;
ivec2 lit = pixel / 2;
ivec3 light = (mode != 0) ? glow(lit) : diode(lit);
int grid = pixel.x % 2 + pixel.y % 2;
ivec3 result = ivec3(shaded(light.r, grid), shaded(light.g, grid), shaded(light.b, grid));
out_color = vec4(vec3(clamp(result, 0, 255)) / 255.0, 1.0);
}

View File

@@ -0,0 +1,62 @@
// image:resize of the script screens on the gpu (rendering/opengl33screenpost.cpp): one pass of Pillow's resize with
// the Lanczos filter, along the rows (mode 0) or along the columns (mode 1), rounded to 8 bits, as resize_lanczos in
// scripting/scriptscreenkernels.cpp does it
uniform sampler2D source; // the image, from the top row down
uniform ivec2 source_size;
uniform ivec2 target_size;
uniform int flip; // 1: the rows are written bottom row first, as the screen's texture takes them
uniform int mode;
layout(location = 0) out vec4 out_color;
const float pi = 3.14159265358979;
float sinc(float x)
{
if (x == 0.0)
return 1.0;
x *= pi;
return sin(x) / x;
}
float lanczos(float x)
{
if (x >= -3.0 && x < 3.0)
return sinc(x) * sinc(x / 3.0);
return 0.0;
}
void main()
{
ivec2 at = ivec2(gl_FragCoord.xy);
if (flip != 0)
at.y = target_size.y - 1 - at.y;
bool vertical = mode != 0;
int index = vertical ? at.y : at.x;
int from_size = vertical ? source_size.y : source_size.x;
int to_size = vertical ? target_size.y : target_size.x;
float scale = float(from_size) / float(to_size);
float filterscale = max(scale, 1.0);
float support = 3.0 * filterscale;
float center = (float(index) + 0.5) * scale;
float ss = 1.0 / filterscale;
int first = max(int(center - support + 0.5), 0);
int count = min(int(center + support + 0.5), from_size) - first;
float total = 0.0;
for (int x = 0; x < count; ++x)
total += lanczos((float(x + first) - center + 0.5) * ss);
vec3 sum = vec3(0.0);
for (int x = 0; x < count; ++x)
{
float weight = lanczos((float(x + first) - center + 0.5) * ss);
if (total != 0.0)
weight /= total;
ivec2 tap = vertical ? ivec2(at.x, first + x) : ivec2(first + x, at.y);
sum += round(texelFetch(source, tap, 0).rgb * 255.0) * weight;
}
out_color = vec4(clamp(floor(sum + 0.5), 0.0, 255.0) / 255.0, 1.0);
}

View File

@@ -593,4 +593,157 @@ TEST_CASE("lua screens: a script includes another and reads a font of the python
queue.exit();
}
namespace {
// 2x1, red and green, shown through led_post without the glow and a resize to 4x3
constexpr std::string_view posted_script{R"(
return {
render = function(state)
local image = eu07.image(2, 1, { 255, 0, 0 })
image:set(1, 0, { 0, 255, 0 })
return image:led_post(false):resize(4, 3)
end
}
)"};
// reads an image after led_post: its size, a pixel of the frame and one of a diode
constexpr std::string_view read_posted_script{R"(
return {
render = function(state)
local posted = eu07.image(2, 1, { 255, 255, 255 }):led_post(false)
local width, height = posted:width(), posted:height()
local frame = posted:get(0, 0)
local diode = posted:get(1, 1)
return eu07.image(1, 1, { width * 10 + height, frame, diode })
end
}
)"};
// a gpu that keeps what it was given, or one that can't do it
struct recording_processor : script_screens::post_processor {
bool apply(ITexture & /*Target*/, std::span<std::uint8_t const> const Pixels, int const Width, int const Height,
std::span<script_screens::post_step const> const Steps) override {
++calls;
pixels.assign(Pixels.begin(), Pixels.end());
width = Width;
height = Height;
steps.assign(Steps.begin(), Steps.end());
return works;
}
bool works{true};
int calls{0};
std::vector<std::uint8_t> pixels;
int width{0};
int height{0};
std::vector<script_screens::post_step> steps;
};
// what posted_script shows, done on the cpu, bottom row first
std::vector<std::uint8_t> posted_on_cpu() {
script_screens::post_step led;
led.type = script_screens::post_step::kind::led;
led.bloom = false;
script_screens::post_step resize;
resize.type = script_screens::post_step::kind::resize;
resize.width = 4;
resize.height = 3;
std::array const steps{led, resize};
script_screens::post_image image{{255, 0, 0, 255, 0, 255, 0, 255}, 2, 1};
REQUIRE(script_screens::apply_post(image, steps));
std::vector<std::uint8_t> result;
for (auto row = image.height - 1; row >= 0; --row) {
auto const first{image.pixels.begin() + static_cast<std::ptrdiff_t>(script_screens::image_size(image.width, row))};
result.insert(result.end(), first, first + image.width * 4);
}
return result;
}
} // namespace
TEST_CASE("lua screens: led_post and resize of the image shown go to the gpu, with the image as drawn") {
script_folder const folder{"lua_post_gpu"};
auto const script{folder.write("posted.lua", posted_script)};
script_screen_queue queue;
REQUIRE(queue.init());
recording_processor gpu;
queue.set_post_processor(&gpu);
recording_texture texture;
auto const screen{queue.acquire(request(script_language::lua, script, "posted", &texture, script_screen_kind::external))};
refresh(queue, screen, speed(0.0), 1);
REQUIRE(run_until(queue, [&gpu] { return gpu.calls > 0; }));
CHECK(texture.uploads == 0);
CHECK(gpu.width == 2);
CHECK(gpu.height == 1);
CHECK(gpu.pixels == std::vector<std::uint8_t>{255, 0, 0, 255, 0, 255, 0, 255});
REQUIRE(gpu.steps.size() == 2);
CHECK(gpu.steps[0].type == script_screens::post_step::kind::led);
CHECK_FALSE(gpu.steps[0].bloom);
CHECK(gpu.steps[1].type == script_screens::post_step::kind::resize);
CHECK(gpu.steps[1].width == 4);
CHECK(gpu.steps[1].height == 3);
queue.exit();
}
TEST_CASE("lua screens: without a gpu, led_post and resize run on the cpu") {
script_folder const folder{"lua_post_cpu"};
auto const script{folder.write("posted.lua", posted_script)};
script_screen_queue queue;
REQUIRE(queue.init());
recording_texture texture;
auto const screen{queue.acquire(request(script_language::lua, script, "posted", &texture, script_screen_kind::external))};
refresh(queue, screen, speed(0.0), 1);
REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
CHECK(texture.width == 4);
CHECK(texture.height == 3);
CHECK(texture.pixels == posted_on_cpu());
queue.exit();
}
TEST_CASE("lua screens: when the gpu can't do the post-processing, the cpu does it from then on") {
script_folder const folder{"lua_post_fallback"};
auto const script{folder.write("posted.lua", posted_script)};
script_screen_queue queue;
REQUIRE(queue.init());
recording_processor gpu;
gpu.works = false;
queue.set_post_processor(&gpu);
recording_texture texture;
auto const screen{queue.acquire(request(script_language::lua, script, "posted", &texture, script_screen_kind::external))};
refresh(queue, screen, speed(0.0), 1);
REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
CHECK(gpu.calls == 1);
CHECK(texture.width == 4);
CHECK(texture.pixels == posted_on_cpu());
refresh(queue, screen, speed(0.0), 1);
REQUIRE(run_until(queue, [&texture] { return texture.uploads > 1; }));
CHECK(gpu.calls == 1);
CHECK(texture.pixels == posted_on_cpu());
queue.exit();
}
TEST_CASE("lua screens: an image read after led_post has its post-processing done first") {
script_folder const folder{"lua_post_read"};
auto const script{folder.write("read.lua", read_posted_script)};
script_screen_queue queue;
REQUIRE(queue.init());
recording_processor gpu;
queue.set_post_processor(&gpu);
recording_texture texture;
auto const screen{queue.acquire(request(script_language::lua, script, "read", &texture, script_screen_kind::external))};
refresh(queue, screen, speed(0.0), 1);
REQUIRE(run_until(queue, [&texture] { return texture.uploads > 0; }));
CHECK(gpu.calls == 0);
REQUIRE(texture.pixels.size() == 4);
CHECK(texture.pixels[0] == 64); // 6 x 4
CHECK(texture.pixels[1] == 0);
CHECK(texture.pixels[2] == 255);
queue.exit();
}
#endif

View File

@@ -119,3 +119,36 @@ TEST_CASE("script screen kernels: images that don't fit their buffers are refuse
CHECK_FALSE(script_screens::resize_lanczos(input, 5, 3, output, 12, 8));
CHECK_FALSE(script_screens::resize_lanczos(input, 6, 3, output, 2, 2));
}
TEST_CASE("script screen kernels: the post-processing steps of an image run one after another") {
script_screens::post_step led;
led.type = script_screens::post_step::kind::led;
led.bloom = true;
script_screens::post_step resize;
resize.type = script_screens::post_step::kind::resize;
resize.width = 17;
resize.height = 11;
std::array const steps{led, resize};
CHECK(script_screens::width_after(led, 5) == 12);
CHECK(script_screens::height_after(led, 3) == 8);
CHECK(script_screens::width_after(resize, 12) == 17);
CHECK(script_screens::height_after(resize, 8) == 11);
script_screens::post_image image{rgba(source), 5, 3};
REQUIRE(script_screens::apply_post(image, steps));
CHECK(image.width == 17);
CHECK(image.height == 11);
CHECK(image.pixels == rgba(enlarged));
// nothing to do, nothing done
script_screens::post_image unchanged{rgba(source), 5, 3};
REQUIRE(script_screens::apply_post(unchanged, {}));
CHECK(unchanged.pixels == rgba(source));
// a size the kernels refuse leaves the image as it was
script_screens::post_image tooshort{std::vector<std::uint8_t>(10), 5, 3};
CHECK_FALSE(script_screens::apply_post(tooshort, steps));
CHECK(tooshort.width == 5);
CHECK(tooshort.pixels.size() == 10);
}

View File

@@ -912,6 +912,12 @@ bool global_settings::ConfigParseScriptScreens(cParser& Parser, std::string_view
return true;
}
if (token == "screens.gpupost")
{
ParseOne(Parser, screens_gpupost, 1);
return true;
}
return false;
}
@@ -1885,6 +1891,7 @@ global_settings::export_as_text( std::ostream &Output ) const {
export_as_text( Output, "wasm.enabled", wasm_enabled );
export_as_text( Output, "screens.cabframes", screens_cabframes );
export_as_text( Output, "screens.externalframes", screens_externalframes );
export_as_text( Output, "screens.gpupost", screens_gpupost );
export_as_text( Output, "async.trainThreads", trainThreads );
for( auto const &server : network_servers ) {
Output

View File

@@ -300,6 +300,7 @@ struct global_settings {
bool wasm_enabled{true}; // screens drawn by WebAssembly modules (wasmscreen:, wasmdestinationsign: in the .mmd)
int screens_cabframes{4}; // the script screens in the cab are refreshed every so many rendered frames
int screens_externalframes{30}; // the script screens outside the cab (destination signs) are refreshed every so many rendered frames
bool screens_gpupost{true}; // the post-processing of the script screens (image:led_post, image:resize) on the gpu, when the renderer can
bool gfx_skiprendering = false;
int gfx_framebuffer_width = -1;