[WPF] 4K window size op een 1080p monitor: Height > 1100?

[NickThissen]

In mijn WPF applicatie heb ik een transparent / borderless Window waar ik graphics op toon. Ik wil graag eens proberen of ik deze graphics ook in 4K resolutie (specifiek: 3840x2160) kan laten zien zonder al te veel performance verlies. Helaas heb ik geen 4K monitor, enkel 2x 1080p monitors naast elkaar.

Toch lijkt het me in principe geen probleem om een Window van 3840x2160 op een 1080p monitor te gooien? Ook al kan ik dan maar een kwart van het window zien, dan zou ik alsnog kunnen testen of het uberhaupt werkt en of de performance goed is denk ik?

Helaas krijg ik het niet voor elkaar. Zelfs in een compleet vers WPF project (.NET 4.7.2) lijkt het niet mogelijk om de Height van een window meer dan 1100 te krijgen. Ik zet gewoon de Height property naar 2160, maar zodra ik de applicatie start wordt de height vanzelf 1100. Dit kan ik zien in de Live Explorer, maar ook door het window omhoog te schuiven - na een paar pixels wordt de onderkant al zichtbaar en het is dus inderdaad echt geen 2160 pixels hoog.



Is dit iets wat Windows niet toelaat op een of andere manier?

Is er een andere manier waarop ik toch een 4K window kan testen op een 1080p monitor?

Is mijn test uberhaupt relevant qua performance - aangezien ik altijd maar maximaal een kwart van de content op het beeld kan zien? Ik zou verwachten dat alle content buiten beeld nog steeds een rol speelt in performance.

[RobIII]

Een 4K scherm heb je voor €120 (weliswaar een matig tot slecht, but still), en voor een €250 euro begint het een beetje ergens op te lijken. Ondanks dat dit niet het antwoord op je vraag is en je vraag an sich vanuit programmeertechnisch interresant is om te beantwoorden: ik denk ook dat we als programmeurs soms even een stapje terug moeten doen en de situatie even buiten onze IDE moeten bekijken. Als je hier meer dan een middag mee bezig bent (geweest) is een 4K scherm aanschaffen (hoe karig ook) al gauw goedkoper én beter (als in: realistischer) om op te testen dan maar proberen de situatie op je 1080p schermpje proberen nabootsen. Al helemáál als straks blijkt dat de performance op 4K alsnog ruk is omdat een groot deel van de pixels niet gerenderd hoeven worden op je 1080p en op een 4k wel.
Ik zou, to be honest, het zekere voor het onzekere nemen voor, wat zakelijk gezien, een investering van een verwaarloosbaar bedrag is.

Having said that; ik ben niet súper into WPF maar heb je niet gewoon een schaalfactor? Laat het op 4K intern renderen en neem dan de éxtra stap het terug te schalen naar 1080P. Als dat performt dan zal het op 4K ook performen omdat dan alleen maar minder procesing nodig is (want je hoeft niet terug te schalen). Ik vind het alleen een beetje een risico van een aantal aannames die je doet; zolang de pixels niet daadwerkelijk naar het scherm hoeven weet je natuurlijk nooit zéker wat het in die situatie zou doen en welke "shortcuts" je GPU neemt / kan nemen omdat je tóch die pixels nooit zult zien.

[ Voor 24% gewijzigd door RobIII op 13-12-2020 14:31 ]

[NickThissen]

Ik vind het nogal overdreven om voor zoiets meteen een scherm te gaan kopen, vooral als ik vantevoren al verwacht dat het niet gaat werken en ik het dus ook niet wil ondersteunen (en het scherm dan dus ook niet meer nodig heb). Ik wil het wel graag een keer proberen om te kijken of mijn aanname klopt, en als ik dat kan doen met de hardware die ik heb dan is dat toch niet zo raar? Als dan de conclusie is: het werkt nu al niet, dan kan ik het vergeten en hoef ik het scherm ook niet. Als de conclusie is dat het wellicht toch kan lukken, dan kan ik later altijd alsnog een scherm kopen als ik het echt wil ondersteunen.

Een nieuw project starten en even '2160' intypen is natuurlijk ook geen uren werk. Met 15 min googlen heb ik niks relevants gevonden en ging ik er dus van uit dat het niet een bekend iets is, of mijn google termen kloppen niet. Dan leek het me dus interessant om hier eens te vragen, wellicht dat er iemand langs 'loopt' die het toevallig weet.

Toch bedankt voor de info. Inderdaad is het terugschalen wat ik nu doe: een view van 4K die ik render in een window van 1080p. Echter weet ik niet of ik je aanname meteen kan volgen: ik gok dat WPF slim genoeg is om niet alles op 4K te renderen en daarna terug te schalen, maar juist eerder al een optimizatie doet waardoor (even een extreem voorbeeld) de performance op een 10x10 pixel window veel hoger zal zijn dan een 4K window. Dit is ook wat mijn eerste snelle test laat zijn, al is dat puur 'cosmetisch' (kijkend naar hoe vloeiend animaties zijn etc) en niet nauwkeurig gemeten.

Om die aanname nog even snel te checken dacht ik dus om het even daadwerkelijk op een 4K window te zetten, en in die stap werkt WPF me dus nu tegen. Als er geen triviale oplossing is om dit te checken dan kan ik altijd nog een groter scherm kopen.


Edit
Daarnaast weet ik ook nog helemaal niet dat deze limiet door mijn scherm komt. Het lijkt me aannemelijk maar ook daar kan ik geen info over vinden. Ik heb nooit geweten of gehoord dat window size gelimiteerd is door resolutie?

[ Voor 6% gewijzigd door NickThissen op 13-12-2020 16:51 ]

[Mr. HTTP]

Ik denk dat er ergens een denkfout wordt gemaakt. Misschien gebruik je de verkeerde oplossing voor je probleem of is het antwoord simpeler dan je denkt maar heb je nog geen bewijs gevonden in de documentatie.

Heb je een overzicht van de APIs die je gebruikt en wat je daarmee probeert te doen.
Heb je de officiële documentatie gevonden en gekeken of wat je wilt ook mogelijk is en op die wijze zou moeten worden toegepast?

Windows in WPF Applications
https://docs.microsoft.co...w=netframeworkdesktop-4.8
Order of Precedence for Sizing Properties
https://docs.microsoft.co...nce-for-sizing-properties
Github repo met WPF code examples
https://github.com/microsoft/WPF-Samples

Ik heb geen specifieke WPF kennis maar wel veel programmeerkennis en iets in mij zegt dat de WindowManager van Windows een setting zou kunnen overrulen waardoor een Window iig aanspreekbaar blijft. Een Window met een resolutie van 4K op een 1080 scherm is natuurlijke een usability hell.

[RobIII]

Het kan wel degelijk, of het elegant of de moeite is is vers 2 Iets als dit kan wellicht ook uitkomst bieden, maar ik ken het niet en zit mobiel te frotten dus kan ook weinig proberen

[ Voor 40% gewijzigd door RobIII op 14-12-2020 18:09 ]

[Mr. HTTP]

Ik geloof ook wel dat het kan met de juiste settings of flags, maar omdat het meer een hack is (dus niet iets doorgaans) zul je diep moeten graven en dan kan Windows versie en .NET versie allemaal een rol spelen.

En ik zeg ook hack omdat de Windows WindowManager waarschijnlijk WPF applicaties overrulet/instrueert omdat het aantal schermen, resolutie per scherm en Windows versie allemaal zaken zijn die meespelen en niet iedereen dat volledig zal inprogrammeren voor elke WPF applicatie (m.a.w.; low level APIs VS high level APIs)

Anyway.
Ik kwam een gelijke probleemstelling tegen op de devpages van MS:
https://docs.microsoft.co...ndow-size-limitation.html
Dus als ik TS was zou ik daar eens meepraten, wellicht heeft de TS daar inmiddels iets ondekt...

Update:
Zie deze reactie die wat kaders schets waar TS wellicht op kan inhaken;
https://stackoverflow.com...ndowstate/1956339#1956339

[ Voor 10% gewijzigd door Mr. HTTP op 14-12-2020 19:21 ]