Hello!
Today, I’d like to share the process of dynamically rendering pixel art.
The reason for implementing this at first was for a newly added monster.
It needed to smash the ground around it freely with its head, which was hard to express with simple images.
So I used RenderTextures to draw pixels.
The initial implementation was heavily hardcoded, and the algorithm was unstable at times.
But I wrapped it up roughly for the first attempt.
Later, I came up with a new monster design.
This required using dynamic rendering again, and I decided to refine it for broader applications.
New Implementation
In the new method, I switched to mesh rendering.
It’s more stable in various situations.
To do this, I first implemented the ability to draw pixelated shapes onto a RenderTexture.
At first, I tried checking each pixel one by one. Implementation was simple but very slow.
I thought it might be due to computation cost, so I also tried ComputeShaders, but that was even slower.
The fastest method was the scanline algorithm I found through Google.
It splits a triangle into two parts and fills pixels using slopes.
Performance was fine, but when rendering meshes, gaps sometimes appeared.
I revised the algorithm until it stabilized across various cases.
Finally, I reached a stable version.
Here is the completed monster.
Various Applications
Thanks to modularization, I was able to apply it to other systems as well.
Shadowmap and background mapping calculations in the editor became faster.
The burning effect in the game was also replaced with the new module, improving performance.
Finally, I was also able to create a pixel rope effect based on the new module.
Thank you for reading!
