From 867a8144e83e8242ee32def41c7c859008dcc190 Mon Sep 17 00:00:00 2001 From: jcm Date: Mon, 1 Jul 2024 15:33:05 -0500 Subject: [PATCH] Allow ruby to implement `screen` software rendering functions --- ares/ares/node/video/screen.cpp | 29 ++++++++- ares/ares/node/video/screen.hpp | 1 + ares/ares/platform.hpp | 23 ++++++- desktop-ui/program/platform.cpp | 4 -- desktop-ui/program/program.cpp | 1 + desktop-ui/program/program.hpp | 22 ++++++- desktop-ui/program/video.cpp | 83 +++++++++++++++++++++++++ ruby/ruby.hpp | 1 + ruby/video/metal/metal.cpp | 2 +- ruby/video/metal/metal.hpp | 2 +- ruby/video/video.cpp | 104 +++++++++++++++++++++++++++++++- ruby/video/video.hpp | 48 ++++++++++++++- 12 files changed, 306 insertions(+), 14 deletions(-) create mode 100644 desktop-ui/program/video.cpp diff --git a/ares/ares/node/video/screen.cpp b/ares/ares/node/video/screen.cpp index 2fe73a2de5..13e39a5dbb 100644 --- a/ares/ares/node/video/screen.cpp +++ b/ares/ares/node/video/screen.cpp @@ -60,11 +60,13 @@ auto Screen::pixels(bool frame) -> array_span { auto Screen::resetPalette() -> void { lock_guard lock(_mutex); _palette.reset(); + platform->resetPalette(shared()); } auto Screen::resetSprites() -> void { lock_guard lock(_mutex); _sprites.reset(); + platform->resetSprites(shared()); } auto Screen::setRefresh(function refresh) -> void { @@ -78,7 +80,7 @@ auto Screen::refreshRateHint(double pixelFrequency, int dotsPerLine, int linesPe auto Screen::refreshRateHint(double refreshRate) -> void { lock_guard lock(_mutex); - platform->refreshRateHint(refreshRate); + platform->refreshRateHint(shared(), refreshRate); } auto Screen::setViewport(u32 x, u32 y, u32 width, u32 height) -> void { @@ -87,72 +89,85 @@ auto Screen::setViewport(u32 x, u32 y, u32 width, u32 height) -> void { _viewportY = y; _viewportWidth = width; _viewportHeight = height; + platform->setViewport(shared(), x, y, width, height); } auto Screen::setOverscan(bool overscan) -> void { lock_guard lock(_mutex); _overscan = overscan; + platform->setOverscan(shared(), overscan); } auto Screen::setSize(u32 width, u32 height) -> void { lock_guard lock(_mutex); _width = width; _height = height; + platform->setSize(shared(), width, height); } auto Screen::setScale(f64 scaleX, f64 scaleY) -> void { lock_guard lock(_mutex); _scaleX = scaleX; _scaleY = scaleY; + platform->setScale(shared(), scaleX, scaleY); } auto Screen::setAspect(f64 aspectX, f64 aspectY) -> void { lock_guard lock(_mutex); _aspectX = aspectX; _aspectY = aspectY; + platform->setAspect(shared(), aspectX, aspectY); } auto Screen::setSaturation(f64 saturation) -> void { lock_guard lock(_mutex); _saturation = saturation; _palette.reset(); + platform->setSaturation(shared(), saturation); } auto Screen::setGamma(f64 gamma) -> void { lock_guard lock(_mutex); _gamma = gamma; _palette.reset(); + platform->setGamma(shared(), gamma); } auto Screen::setLuminance(f64 luminance) -> void { lock_guard lock(_mutex); _luminance = luminance; _palette.reset(); + platform->setLuminance(shared(), luminance); } auto Screen::setFillColor(u32 fillColor) -> void { lock_guard lock(_mutex); _fillColor = fillColor; + platform->setFillColor(shared(), fillColor); } auto Screen::setColorBleed(bool colorBleed) -> void { lock_guard lock(_mutex); _colorBleed = colorBleed; + platform->setColorBleed(shared(), colorBleed); } auto Screen::setColorBleedWidth(u32 width) -> void { lock_guard lock(_mutex); _colorBleedWidth = width; + platform->setColorBleedWidth(shared(), width); } auto Screen::setInterframeBlending(bool interframeBlending) -> void { lock_guard lock(_mutex); _interframeBlending = interframeBlending; + platform->setInterframeBlending(shared(), interframeBlending); } auto Screen::setRotation(u32 rotation) -> void { lock_guard lock(_mutex); _rotation = rotation; + platform->setRotation(shared(), rotation); } auto Screen::setProgressive(bool progressiveDouble) -> void { @@ -160,6 +175,7 @@ auto Screen::setProgressive(bool progressiveDouble) -> void { _interlace = false; _progressive = true; _progressiveDouble = progressiveDouble; + platform->setProgressive(shared(), progressiveDouble); } auto Screen::setInterlace(bool interlaceField) -> void { @@ -167,18 +183,21 @@ auto Screen::setInterlace(bool interlaceField) -> void { _progressive = false; _interlace = true; _interlaceField = interlaceField; + platform->setInterlace(shared(), interlaceField); } auto Screen::attach(Node::Video::Sprite sprite) -> void { lock_guard lock(_mutex); if(_sprites.find(sprite)) return; _sprites.append(sprite); + platform->attachSprite(shared(), sprite); } auto Screen::detach(Node::Video::Sprite sprite) -> void { lock_guard lock(_mutex); if(!_sprites.find(sprite)) return; _sprites.removeByValue(sprite); + platform->detachSprite(shared(), sprite); } auto Screen::colors(u32 colors, function color) -> void { @@ -186,6 +205,7 @@ auto Screen::colors(u32 colors, function color) -> void { _colors = colors; _color = color; _palette.reset(); + platform->colors(shared(), colors, color); } auto Screen::frame() -> void { @@ -219,6 +239,13 @@ auto Screen::refresh() -> void { auto width = _canvasWidth; auto height = _canvasHeight; auto input = _inputB.data(); + + if (!_usesSoftwareRendering) { + platform->video(shared(), input + viewX + viewY * width, width * sizeof(u32), viewWidth, viewHeight); + memory::fill(_inputB.data(), width * height, _fillColor); + return; + } + auto output = _output.data(); for(u32 y : range(height)) { diff --git a/ares/ares/node/video/screen.hpp b/ares/ares/node/video/screen.hpp index 11e8e985ea..71a704c57b 100644 --- a/ares/ares/node/video/screen.hpp +++ b/ares/ares/node/video/screen.hpp @@ -69,6 +69,7 @@ struct Screen : Video { auto refreshPalette() -> void; protected: + bool _usesSoftwareRendering = true; //todo: add setting for this u32 _canvasWidth = 0; u32 _canvasHeight = 0; u32 _width = 0; diff --git a/ares/ares/platform.hpp b/ares/ares/platform.hpp index 527a105831..18e6f2d4f6 100644 --- a/ares/ares/platform.hpp +++ b/ares/ares/platform.hpp @@ -18,7 +18,28 @@ struct Platform { virtual auto log(Node::Debugger::Tracer::Tracer, string_view message) -> void {} virtual auto status(string_view message) -> void {} virtual auto video(Node::Video::Screen, const u32* data, u32 pitch, u32 width, u32 height) -> void {} - virtual auto refreshRateHint(double refreshRate) -> void {} + virtual auto refreshRateHint(Node::Video::Screen, double refreshRate) -> void {} + virtual auto resetPalette(ares::Node::Video::Screen node) -> void {} + virtual auto resetSprites(ares::Node::Video::Screen node) -> void {} + virtual auto setViewport(ares::Node::Video::Screen node, u32 x, u32 y, u32 width, u32 height) -> void {} + virtual auto setOverscan(ares::Node::Video::Screen node, bool overscan) -> void {} + virtual auto setSize(ares::Node::Video::Screen node, u32 width, u32 height) -> void {} + virtual auto setScale(ares::Node::Video::Screen node, f64 scaleX, f64 scaleY) -> void {} + virtual auto setAspect(ares::Node::Video::Screen node, f64 aspectX, f64 aspectY) -> void {} + virtual auto setSaturation(ares::Node::Video::Screen node, f64 saturation) -> void {} + virtual auto setGamma(ares::Node::Video::Screen node, f64 gamma) -> void {} + virtual auto setLuminance(ares::Node::Video::Screen node, f64 luminance) -> void {} + virtual auto setFillColor(ares::Node::Video::Screen node, u32 fillColor) -> void {} + virtual auto setColorBleed(ares::Node::Video::Screen node, bool colorBleed) -> void {} + virtual auto setColorBleedWidth(ares::Node::Video::Screen node, u32 width) -> void {} + virtual auto setInterframeBlending(ares::Node::Video::Screen node, bool interframeBlending) -> void {} + virtual auto setRotation(ares::Node::Video::Screen node, u32 rotation) -> void {} + virtual auto setProgressive(ares::Node::Video::Screen node, bool progressiveDouble) -> void {} + virtual auto setInterlace(ares::Node::Video::Screen node, bool interlaceField) -> void {} + virtual auto attachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void {} + virtual auto detachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void {} + virtual auto colors(ares::Node::Video::Screen node, u32 colors, function color) -> void {} + virtual auto audio(Node::Audio::Stream) -> void {} virtual auto input(Node::Input::Input) -> void {} virtual auto cheat(u32 addr) -> maybe { return nothing; } diff --git a/desktop-ui/program/platform.cpp b/desktop-ui/program/platform.cpp index 06e7db8d28..5c1ee1cce1 100644 --- a/desktop-ui/program/platform.cpp +++ b/desktop-ui/program/platform.cpp @@ -132,10 +132,6 @@ auto Program::video(ares::Node::Video::Screen node, const u32* data, u32 pitch, } } -auto Program::refreshRateHint(double refreshRate) -> void { - ruby::video.refreshRateHint(refreshRate); -} - auto Program::audio(ares::Node::Audio::Stream node) -> void { if(!streams) return; diff --git a/desktop-ui/program/program.cpp b/desktop-ui/program/program.cpp index 8977abeb25..92ef18aef1 100644 --- a/desktop-ui/program/program.cpp +++ b/desktop-ui/program/program.cpp @@ -6,6 +6,7 @@ #include "status.cpp" #include "utility.cpp" #include "drivers.cpp" +#include "video.cpp" Program program; diff --git a/desktop-ui/program/program.hpp b/desktop-ui/program/program.hpp index 98280fdf7e..a820068565 100644 --- a/desktop-ui/program/program.hpp +++ b/desktop-ui/program/program.hpp @@ -11,7 +11,27 @@ struct Program : ares::Platform { auto log(ares::Node::Debugger::Tracer::Tracer tracer, string_view message) -> void override; auto status(string_view message) -> void override; auto video(ares::Node::Video::Screen, const u32* data, u32 pitch, u32 width, u32 height) -> void override; - auto refreshRateHint(double refreshRate) -> void override; + auto refreshRateHint(ares::Node::Video::Screen node, double refreshRate) -> void override; + auto resetPalette(ares::Node::Video::Screen node) -> void override; + auto resetSprites(ares::Node::Video::Screen node) -> void override; + auto setViewport(ares::Node::Video::Screen node, u32 x, u32 y, u32 width, u32 height) -> void override; + auto setOverscan(ares::Node::Video::Screen node, bool overscan) -> void override; + auto setSize(ares::Node::Video::Screen node, u32 width, u32 height) -> void override; + auto setScale(ares::Node::Video::Screen node, f64 scaleX, f64 scaleY) -> void override; + auto setAspect(ares::Node::Video::Screen node, f64 aspectX, f64 aspectY) -> void override; + auto setSaturation(ares::Node::Video::Screen node, f64 saturation) -> void override; + auto setGamma(ares::Node::Video::Screen node, f64 gamma) -> void override; + auto setLuminance(ares::Node::Video::Screen node, f64 luminance) -> void override; + auto setFillColor(ares::Node::Video::Screen node, u32 fillColor) -> void override; + auto setColorBleed(ares::Node::Video::Screen node, bool colorBleed) -> void override; + auto setColorBleedWidth(ares::Node::Video::Screen node, u32 width) -> void override; + auto setInterframeBlending(ares::Node::Video::Screen node, bool interframeBlending) -> void override; + auto setRotation(ares::Node::Video::Screen node, u32 rotation) -> void override; + auto setProgressive(ares::Node::Video::Screen node, bool progressiveDouble) -> void override; + auto setInterlace(ares::Node::Video::Screen node, bool interlaceField) -> void override; + auto attachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void override; + auto detachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void override; + auto colors(ares::Node::Video::Screen node, u32 colors, function color) -> void override; auto audio(ares::Node::Audio::Stream) -> void override; auto input(ares::Node::Input::Input) -> void override; auto cheat(u32 address) -> maybe override; diff --git a/desktop-ui/program/video.cpp b/desktop-ui/program/video.cpp new file mode 100644 index 0000000000..b2b3d87891 --- /dev/null +++ b/desktop-ui/program/video.cpp @@ -0,0 +1,83 @@ +auto Program::refreshRateHint(ares::Node::Video::Screen node, double refreshRate) -> void { + ruby::video.refreshRateHint(node, refreshRate); +} + +auto Program::resetPalette(ares::Node::Video::Screen node) -> void { + ruby::video.resetPalette(node); +} + +auto Program::resetSprites(ares::Node::Video::Screen node) -> void { + ruby::video.resetSprites(node); +} + +auto Program::setViewport(ares::Node::Video::Screen node, u32 x, u32 y, u32 width, u32 height) -> void { + ruby::video.setViewport(node, x, y, width, height); +} + +auto Program::setOverscan(ares::Node::Video::Screen node, bool overscan) -> void { + ruby::video.setOverscan(node, overscan); +} + +auto Program::setSize(ares::Node::Video::Screen node, u32 width, u32 height) -> void { + ruby::video.setSize(node, width, height); +} + +auto Program::setScale(ares::Node::Video::Screen node, f64 scaleX, f64 scaleY) -> void { + ruby::video.setScale(node, scaleX, scaleY); +} + +auto Program::setAspect(ares::Node::Video::Screen node, f64 aspectX, f64 aspectY) -> void { + ruby::video.setAspect(node, aspectX, aspectY); +} + +auto Program::setSaturation(ares::Node::Video::Screen node, f64 saturation) -> void { + ruby::video.setSaturation(node, saturation); +} + +auto Program::setGamma(ares::Node::Video::Screen node, f64 gamma) -> void { + ruby::video.setGamma(node, gamma); +} + +auto Program::setLuminance(ares::Node::Video::Screen node, f64 luminance) -> void { + ruby::video.setLuminance(node, luminance); +} + +auto Program::setFillColor(ares::Node::Video::Screen node, u32 fillColor) -> void { + ruby::video.setFillColor(node, fillColor); +} + +auto Program::setColorBleed(ares::Node::Video::Screen node, bool colorBleed) -> void { + ruby::video.setColorBleed(node, colorBleed); +} + +auto Program::setColorBleedWidth(ares::Node::Video::Screen node, u32 width) -> void { + ruby::video.setColorBleedWidth(node, width); +} + +auto Program::setInterframeBlending(ares::Node::Video::Screen node, bool interframeBlending) -> void { + ruby::video.setInterframeBlending(node, interframeBlending); +} + +auto Program::setRotation(ares::Node::Video::Screen node, u32 rotation) -> void { + ruby::video.setRotation(node, rotation); +} + +auto Program::setProgressive(ares::Node::Video::Screen node, bool progressiveDouble) -> void { + ruby::video.setProgressive(node, progressiveDouble); +} + +auto Program::setInterlace(ares::Node::Video::Screen node, bool interlaceField) -> void { + ruby::video.setInterlace(node, interlaceField); +} + +auto Program::attachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void { + ruby::video.attachSprite(node, sprite); +} + +auto Program::detachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void { + ruby::video.detachSprite(node, sprite); +} + +auto Program::colors(ares::Node::Video::Screen node, u32 colors, function color) -> void { + ruby::video.colors(node, colors, color); +} diff --git a/ruby/ruby.hpp b/ruby/ruby.hpp index 797ab868b3..35ff6b812f 100644 --- a/ruby/ruby.hpp +++ b/ruby/ruby.hpp @@ -19,6 +19,7 @@ #include #include #include +#include using nall::atomic; using nall::function; diff --git a/ruby/video/metal/metal.cpp b/ruby/video/metal/metal.cpp index eb3d9cf49f..db71848a30 100644 --- a/ruby/video/metal/metal.cpp +++ b/ruby/video/metal/metal.cpp @@ -115,7 +115,7 @@ struct VideoMetal : VideoDriver, Metal { return true; } - auto refreshRateHint(double refreshRate) -> void override { + auto refreshRateHint(ares::Node::Video::Screen node, double refreshRate) -> void override { if (refreshRate == _refreshRateHint) return; _refreshRateHint = refreshRate; updatePresentInterval(); diff --git a/ruby/video/metal/metal.hpp b/ruby/video/metal/metal.hpp index 37d46e4552..7fec18bf3b 100644 --- a/ruby/video/metal/metal.hpp +++ b/ruby/video/metal/metal.hpp @@ -44,7 +44,7 @@ struct Metal { auto output() -> void; auto initialize(const string& shader) -> bool; auto terminate() -> void; - auto refreshRateHint(double refreshRate) -> void; + auto refreshRateHint(ares::Node::Video::Screen node, double refreshRate) -> void; auto size(u32 width, u32 height) -> void; auto release() -> void; diff --git a/ruby/video/video.cpp b/ruby/video/video.cpp index 2c24fdde81..15b2c25b0b 100644 --- a/ruby/video/video.cpp +++ b/ruby/video/video.cpp @@ -108,9 +108,109 @@ auto Video::setShader(string shader) -> bool { return true; } -auto Video::refreshRateHint(double refreshRate) -> void { +auto Video::refreshRateHint(ares::Node::Video::Screen node, double refreshRate) -> void { lock_guard lock(mutex); - instance->refreshRateHint(refreshRate); + instance->refreshRateHint(node, refreshRate); +} + +auto Video::resetPalette(ares::Node::Video::Screen node) -> void { + lock_guard lock(mutex); + instance->resetPalette(node); +} + +auto Video::resetSprites(ares::Node::Video::Screen node) -> void { + lock_guard lock(mutex); + instance->resetSprites(node); +} + +auto Video::setViewport(ares::Node::Video::Screen node, u32 x, u32 y, u32 width, u32 height) -> void { + lock_guard lock(mutex); + instance->setViewport(node, x, y, width, height); +} + +auto Video::setOverscan(ares::Node::Video::Screen node, bool overscan) -> void { + lock_guard lock(mutex); + instance->setOverscan(node, overscan); +} + +auto Video::setSize(ares::Node::Video::Screen node, u32 width, u32 height) -> void { + lock_guard lock(mutex); + instance->setSize(node, width, height); +} + +auto Video::setScale(ares::Node::Video::Screen node, f64 scaleX, f64 scaleY) -> void { + lock_guard lock(mutex); + instance->setScale(node, scaleX, scaleY); +} + +auto Video::setAspect(ares::Node::Video::Screen node, f64 aspectX, f64 aspectY) -> void { + lock_guard lock(mutex); + instance->setAspect(node, aspectX, aspectY); +} + +auto Video::setSaturation(ares::Node::Video::Screen node, f64 saturation) -> void { + lock_guard lock(mutex); + instance->setSaturation(node, saturation); +} + +auto Video::setGamma(ares::Node::Video::Screen node, f64 gamma) -> void { + lock_guard lock(mutex); + instance->setGamma(node, gamma); +} + +auto Video::setLuminance(ares::Node::Video::Screen node, f64 luminance) -> void { + lock_guard lock(mutex); + instance->setLuminance(node, luminance); +} + +auto Video::setFillColor(ares::Node::Video::Screen node, u32 fillColor) -> void { + lock_guard lock(mutex); + instance->setFillColor(node, fillColor); +} + +auto Video::setColorBleed(ares::Node::Video::Screen node, bool colorBleed) -> void { + lock_guard lock(mutex); + instance->setColorBleed(node, colorBleed); +} + +auto Video::setColorBleedWidth(ares::Node::Video::Screen node, u32 width) -> void { + lock_guard lock(mutex); + instance->setColorBleedWidth(node, width); +} + +auto Video::setInterframeBlending(ares::Node::Video::Screen node, bool interframeBlending) -> void { + lock_guard lock(mutex); + instance->setInterframeBlending(node, interframeBlending); +} + +auto Video::setRotation(ares::Node::Video::Screen node, u32 rotation) -> void { + lock_guard lock(mutex); + instance->setRotation(node, rotation); +} + +auto Video::setProgressive(ares::Node::Video::Screen node, bool progressiveDouble) -> void { + lock_guard lock(mutex); + instance->setProgressive(node, progressiveDouble); +} + +auto Video::setInterlace(ares::Node::Video::Screen node, bool interlaceField) -> void { + lock_guard lock(mutex); + instance->setInterlace(node, interlaceField); +} + +auto Video::attachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void { + lock_guard lock(mutex); + instance->attachSprite(node, sprite); +} + +auto Video::detachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void { + lock_guard lock(mutex); + instance->detachSprite(node, sprite); +} + +auto Video::colors(ares::Node::Video::Screen node, u32 colors, function color) -> void { + lock_guard lock(mutex); + instance->colors(node, colors, color); } // diff --git a/ruby/video/video.hpp b/ruby/video/video.hpp index 73e9228838..032bc565a0 100644 --- a/ruby/video/video.hpp +++ b/ruby/video/video.hpp @@ -33,8 +33,29 @@ struct VideoDriver { virtual auto setFlush(bool flush) -> bool { return true; } virtual auto setFormat(string format) -> bool { return true; } virtual auto setShader(string shader) -> bool { return true; } - virtual auto refreshRateHint(double refreshRate) -> void {} - + + virtual auto refreshRateHint(ares::Node::Video::Screen node, double refreshRate) -> void {} + virtual auto resetPalette(ares::Node::Video::Screen node) -> void {} + virtual auto resetSprites(ares::Node::Video::Screen node) -> void {} + virtual auto setViewport(ares::Node::Video::Screen node, u32 x, u32 y, u32 width, u32 height) -> void {} + virtual auto setOverscan(ares::Node::Video::Screen node, bool overscan) -> void {} + virtual auto setSize(ares::Node::Video::Screen node, u32 width, u32 height) -> void {} + virtual auto setScale(ares::Node::Video::Screen node, f64 scaleX, f64 scaleY) -> void {} + virtual auto setAspect(ares::Node::Video::Screen node, f64 aspectX, f64 aspectY) -> void {} + virtual auto setSaturation(ares::Node::Video::Screen node, f64 saturation) -> void {} + virtual auto setGamma(ares::Node::Video::Screen node, f64 gamma) -> void {} + virtual auto setLuminance(ares::Node::Video::Screen node, f64 luminance) -> void {} + virtual auto setFillColor(ares::Node::Video::Screen node, u32 fillColor) -> void {} + virtual auto setColorBleed(ares::Node::Video::Screen node, bool colorBleed) -> void {} + virtual auto setColorBleedWidth(ares::Node::Video::Screen node, u32 width) -> void {} + virtual auto setInterframeBlending(ares::Node::Video::Screen node, bool interframeBlending) -> void {} + virtual auto setRotation(ares::Node::Video::Screen node, u32 rotation) -> void {} + virtual auto setProgressive(ares::Node::Video::Screen node, bool progressiveDouble) -> void {} + virtual auto setInterlace(ares::Node::Video::Screen node, bool interlaceField) -> void {} + virtual auto attachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void {} + virtual auto detachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void {} + virtual auto colors(ares::Node::Video::Screen node, u32 colors, function color) -> void {} + virtual auto focused() -> bool { return true; } virtual auto clear() -> void {} virtual auto size(u32& width, u32& height) -> void {} @@ -128,7 +149,28 @@ struct Video { auto setFlush(bool flush) -> bool; auto setFormat(string format) -> bool; auto setShader(string shader) -> bool; - auto refreshRateHint(double refreshRate) -> void; + + auto refreshRateHint(ares::Node::Video::Screen node, double refreshRate) -> void; + auto resetPalette(ares::Node::Video::Screen node) -> void; + auto resetSprites(ares::Node::Video::Screen node) -> void; + auto setViewport(ares::Node::Video::Screen node, u32 x, u32 y, u32 width, u32 height) -> void; + auto setOverscan(ares::Node::Video::Screen node, bool overscan) -> void; + auto setSize(ares::Node::Video::Screen node, u32 width, u32 height) -> void; + auto setScale(ares::Node::Video::Screen node, f64 scaleX, f64 scaleY) -> void; + auto setAspect(ares::Node::Video::Screen node, f64 aspectX, f64 aspectY) -> void; + auto setSaturation(ares::Node::Video::Screen node, f64 saturation) -> void; + auto setGamma(ares::Node::Video::Screen node, f64 gamma) -> void; + auto setLuminance(ares::Node::Video::Screen node, f64 luminance) -> void; + auto setFillColor(ares::Node::Video::Screen node, u32 fillColor) -> void; + auto setColorBleed(ares::Node::Video::Screen node, bool colorBleed) -> void; + auto setColorBleedWidth(ares::Node::Video::Screen node, u32 width) -> void; + auto setInterframeBlending(ares::Node::Video::Screen node, bool interframeBlending) -> void; + auto setRotation(ares::Node::Video::Screen node, u32 rotation) -> void; + auto setProgressive(ares::Node::Video::Screen node, bool progressiveDouble) -> void; + auto setInterlace(ares::Node::Video::Screen node, bool interlaceField) -> void; + auto attachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void; + auto detachSprite(ares::Node::Video::Screen node, ares::Node::Video::Sprite sprite) -> void; + auto colors(ares::Node::Video::Screen node, u32 colors, function color) -> void; auto focused() -> bool; auto clear() -> void;