Vertices Engine Optimizations – Encapsulating Post Processors

Currently most of the Post Processors are handled loosely and internally by the vxRenderer class. This is great for keeping everything in one place, but it causes a lot of redundant information to be sent to the GPU each call. A perfect illustration of this is in this excerpt from the Edge Detection Post Processor code:

[gist https://gist.github.com/ea6b627f4d69ffb197fe2c2222717419/]

As you can see above, there’s a number of redundant calls to items which wouldn’t had changed from the last loop. A more efficient way would be to add these into get/set Properties and to manage the effects from within their own class.

[gist https://gist.github.com/fae303a3582dde7cfa09616d7b055f19/]

I could’ve put each of these get/set Properties within the vxRenderer class, but then that would only add lines of code to an already very full *.cs file and makes debugging any post processor issues even more complicated.

I decided a cleaner and better way to implement this would be to encapsulate each post processor into it’s own class which inherited from a base Post Processor class and Interface.

[gist https://gist.github.com/b1b94d7aef2131eae422454d8f2cd1eb/]

As you can see above from the interface, There’s a ‘SetResolution()‘ method which holds any and all code that’s required to update everytime the resolution changes. This makes updating Viewport bounds that are required for most post processors to be easily reset.

There’s also a ‘LoadContent()’ method which is essentially for setting up any code outside of the Constructor.

Finally is the ‘Apply()‘ method, where the magic happens. This is a generic method where the actual effect is applied to the scene.

Further to all of this, All of the Post Processors are added to an Effects list in the Renderer.  This makes any batch changes very easy to perform by simply just looping through the collection when needed and calling the required method.

In the end, this creates for a very structured way in which to handle all of the post processing effects, allowing not only a more efficient rendering loop by lessening the amount of information sent to the GPU each loop, as well as minimizes on lines of code.