Loufe
commented
2 months ago Great idea and thanks for the high quality write-up @caiquesassis. I've hit a point in my game where I've been looking for a means to make transitions smoother between my different presets and have been wondering how to achieve it.
Your point about floats being required is absolutely true. I wonder how many individual shaders will refuse to play nicely even after some tweaking. In any case, I'm 100% for it, but I think we'll need to do a breaking update to support this.
As for the weight system, it's decent, but I think that approach presents some trouble trying to blend from one "post" state to another gracefully. For instance, if I wanted to go from "night" to "dawn" filter, I would have to maybe:
- Fade out (decreasing weight) the night filter while
- Fading in (increasing weight) the day filter.
My original thinking was to implement a function which "transitioned" between two presets. You'd select target preset, a transition time, and a transition function (i.e. linear / quadratic / etc.). In the game loop we'd follow the change in the transition function from one preset to the next, just based on the different. That way we wouldn't see weird dips etc. I think this would be preferable as we could easily implement a way to set target as the default values.
However, if you wanted to dynamically play with different levels of your existing preset, this would present some challenges. Most of the underlying code would be similar for our approaches, and I suppose they could live in parallel.
Anyways just some thoughts of mine. What do you think?
I'm on a work trip for another week still but I would be happy to work with you on implemting this when I'm back.
On a side note, if there is a problem with using multiple Post-Processing nodes together, could you submit another issue?
caiquesassis
Hello! I recently started making the switch from Unity to Godot, and the lack of Post Processing options on Godot made me look for options, and that's how I ended up finding this plugin. First of all, thanks for making it! As a former Unity dev, this is really useful and I'm glad it's being worked on.
So, one of the things the Post Processing volumes offered in Unity was a property called "Weight". Basically, it's a multiplier that ranges from 0 to 1 that you can use to control all the Post Processing options of a given volume at once without changing them individually, like this:
Volume Weight at 0
Volume Weight at 0.5
Volume Weight at 1
Such property is really useful when you want to quickly apply a given effect when something happens, for instance...quickly applying and fading a bloom effect when picking up an item, instead of dealing with the bloom parameters directly, you could just have a separate Volume with a profile that has bloom enabled with the settings you want it to have, but set the Volume Weight to 0, and when the item is picked up, set the Weight to 1 and lerp it back to 0. (I'm not sure if this plugin supports multiple PostProcess nodes at the same time with different configurations...haven't properly tested it but from the quick tests I made it seems to behave in a weird manner so I'm not sure if this is supported or not possible to do - perhaps the Priority property, similar to Unity's one, would also need to be added).
I did try quickly hacking the script to see if it could work, and I think in a basic level it does work, at least with the basic float parameters (I was not sure if such weight property should also be applied to things that deal with Vector2 components or the like, such as "Ascii Size" on the ASCII effect...I guess this is up for debate). What I did was basically going into the post_process.gd script and in lines where _material.set_shader_parameter("name", configuration.Parameter) were written setting a float parameter, I just multiplied the configuration.Parameter by weight (which I @export_range(0, 1) as a variable at the top of the script). Of course, I also had to go to the post_processing_configuration.gd script to explicitly set the type of many of those parameters to float, as otherwise Godot's compiler would complain about multiplying a float by Nil. In any case, the weight approach did work, at least with a single PostProcess node (as I mentioned, weird results with two or more nodes).
Here's how it ended up:
So, basically, I'm bringing the request up (and how I quickly tested to check its overall viability) to see if it would be possible for it to be properly integrated according to the standards that are being used by the maintainers, of course, as there are some design decisions (such as which parameters to ignore when applying weight) that would need to be discussed upon.
Thanks once again for the amazing work on the plugin!