hi Plinkr, I discovered something you may be interested on. Shaders do work perfectly well on Arm as they are, the problem is with sailfish os which may use an older version of opengl? I don't know the reason but the game works with all shaders on Postmarket Os (althoug performance suffers a lot).
I added a video showcasing the optimizations I added for mobile phones. I fundamentally reduced resolution to 20% and this way it render fast and with all effects on mobile phones.
Hey!
I've been very busy with my day job and haven't been able to spend time on FLASH-BLIP. I have a half finished rewrite of the text generator so it's resolution independent, hopefully I'll have a bit of time this weekend to finish it.
I haven't been able to dig into the shader issue yet, I want to first make sure the game renders correctly on any mobile resolution, and then look into the shaders.
In the video you shared, is the game running at 60 FPS?
Hi, no problem! To answer your question: before optimization, the game couldn’t even reach 60 FPS—it had very poor performance. After optimizing, it’s still probably not hitting 60 FPS, but I think it’s pretty close. I didn’t measure it precisely, though.
In my opinion, there’s not much more room to improve performance through shaders without compromising their quality. I’ve already reduced values like effects.glow.min_luma, glow.strength, etc. The biggest performance gain came from rendering at a much lower resolution. However, rendering below 20% resolution would make it look bad, so I think I’ve found a good balance.
The game is now much more playable with all shaders enabled on phones. Feel free to test it yourself and let me know your thoughts!
I was able to test the game on my Raspberry Pi 4B with the shaders enabled, and it runs very slowly. Although it's not as slow as on a mobile phone, it's still very slow and breaks the gameplay.
It's possible that the Moonshine project's shaders have some incompatibility with ARM or a specific OpenGL version, those shaders haven't been updated in about six years, but we need to experiment. We should look for other LOVE2D games that use shaders and are available for ARM to see how their performance compares.
Raspberry pi 4B is very weak specially on the GPU where the heavy load is, the only thing you can do is disable shaders, I would start with the CRT effect, if that's not enough or you are not happy with the results try reducing resolution even more. If you want to see other love2d games that use shaders for ARM you can download plenty of them from my repository for sailfish os. I optimized many games and most of the gain always come from reducing resolution (you do not need to reduce the resolution of the whole games, you can internally render elements at different resolution, background elements should have less priority).
Here is my final version of the fork of your game, you can read what I added on the description of the video. Feel free to take what you want and leave what you don't want if you think it's worth sharing and feel free to your feedback. I hope you like it!
https://video.gamerstavern.online/w/uSboK9uZ8egZqYvoo9XjP7
I found a fork of the game for Aurora Os: https://github.com/NightEugene/aurora-flash-blip
So now your game runs on: Android, Sailfish Os, Aurora Os, Postmarket Os and probably any phone that runs löve2d. The game seems to be loved for phones! Congratulations!
Hey! I watched the video and it looks really nice. I liked the new menu, it seems useful for mobiles and touchscreens.
I've been testing shader performance on a 2013 Chromebook C710 running a custom Linux. I'm testing there because it's the absolutely worst hardware I could find. Its CPU architecture is x86, and the shaders work fine on that poor hardware. The only requirement is lowering the glow shader strength from 20 to 3, with that change it hits 60 FPS with all shaders active.
On Android the same applies. On my phone, which also has poor hardware (although higher-end than the C710), I hit 60 FPS by lowering the glow shader strength to <= 3 and disabling the gaussian blur shader.
I'll try to clean up the code with the new Android changes, including a rewrite of the text generator so it adapts to any resolution, and see if I can optimize the glow shader for OpenGL ES. Those changes would make it possible to release an Android binary. I'll try to upload some changes today.
I saw the fork for Aurora OS yesterday too, that's nice!
Thanks for the work you put into your fork!
You are welcome and thanks for taking your time in testing it. As you know, optimizing is a trade game in which you can not win everything and you need to make compromises and there's no "right" or perfect solution. I tested your solution over mine and disabled gaussian (the upscaling from 20% already make edges unsharp due it's antialising) and reduced glow to 2. The result combined with my reduction of resolution is amazing: I hit 60 fps (not constant but most of the time) with shaders on!
After many experiments I made up a decision: To keep options simple and high framerate and resolution the following shaders are disabled:
- Gaussian blur and glow
This is the only way I can achieve 60fps with shaders on at full resolution.
Don't do the same if you have other preferences, it may not look as beautiful but I think this kind of game should prioritize framerate to graphics when the hardware can not have both.
Feel free to take may parameters if you like them! and thanks for making this game wonderful on phones!
Hey!
It doesn't look as nice without the glow shader, but at least it runs very fast.
I need to dig deeper to see if there's any OpenGL ES shader that can achieve a soft light effect efficiently. Maybe combining it with scanlines and CRT effects in a single shader could make it look closer to the desktop version.
If I find a good optimization, I'll let you know, your port might benefit from it too. Likewise, if you discover anything useful for implementing an optimized glow (soft light) shader, please share it.
Also, with the version I uploaded today, resolution handling on mobile devices is much better now, taking High DPI into account, that might be useful for you as well.
Cheers.
Thanks. I commented it: IS_MOBILE = love.system.getOS() == "Android" or love.system.getOS() == "iOS". As long as I know you can not retrieve with getOs if a system is Sailfish, Aurora or Postmarket Os, it always return "linux". I hope it helps.
https://video.gamerstavern.online/w/7NT8ZXQdQAn9sjDgKxfjoW
This is my definitive version, I gave up on too much glow and added a performant nebula instead in which I worked hard on optimizing for phones. The result speaks for itself: 60fps most of the time and amazing graphics! Feel free to add whatever you like of my work if you like it, if you prefer something else that's fine!
I'll definitely try the nebula shader for the parallax background, I liked that effect a lot!
Regarding detecting mobile, you could try:
IS_MOBILE = love.system.getOS() == "Linux"
and (require("ffi").arch == "arm" or require("ffi").arch == "arm64")
`jit.arch` (or `ffi.arch`) returns the architecture: https://luajit.org/ext_jit.html#jit_arch
You can assume Linux on ARM likely indicates a mobile platform, and also check for OpenGL ES to be safer:
local gl_vendor, gl_version = love.graphics.getRendererInfo()
if gl_version then
is_es = string.find(gl_version:lower(), "es", 1, true) ~= nil
end
IS_MOBILE = love.system.getOS() == "Linux" and (require("ffi").arch == "arm" or require("ffi").arch == "arm64")
and is_es
Have a nice one!