Brush spacing / rotate / scale

[Moritz Moeller]

Boudewijn Rempt wrote:
> Computers still aren't really fast enough :-(. Both gegl and krita have 
> performance problems. Nobody has yet been able to do a nice watercolor 
> simulation realtime at a resolution of more than 1024x1024, and most only 
> give 512x512, not even with gpu acceleration or with beowulf clusters. A 
> complicating issue is that screens are getting bigger, so we need to 
> calculate waymore display pixels.

That is simply not true.
It all comes down to implementation. Even if an apps's brushes are dead 
slow (which probably means the implementation approach should be 
re-visited anyway):
Who ever said you need to render a brush at the highest resolution while 
user is stroking?
Who ever said you even need to render it at the resolution required for 
the current view while the user is stroking?
If you have dynamic level of detail, you can just render the brush at 
the best resolution possible for the machine spec & zoom level at hand 
while the user is stroking. Once the user has released the pen, you 
render the currently required detail level. In the background you can 
start rendering the document's detail level (which might again be higher 
than the required detail level for the current view).

Do all this multi-threaded, and I there's you can get very high quality 
brushes with real time responsiveness on today's boxes.

I mean seriously: look at the level of detail today's games archive at 
60+ FPS. Imagine compressing this detail into a brush stroke.

Even the offline 3D high-end renderes we use in feature film VFX can 
render fully anti-aliased images at SD res, of several 100k 
micropolygons will a single lightsource and a plastic shader at full 
antialiasing at 3-4 fps on today's boxes.

With Krita we are talking 2D. So there's a all kinds of cheats possible. 
You could e.g. implement brushes on the GPU, render them into textures, 
then use high-quality downsampling to get the required quality b4 
rendering them into the image.

One of the (still) most expensive real time compositing systems, Flame, 
uses OpenGl to render almost everything (including final images), using 
this trick).
If the approach is good enough for a 250k Euro BMW commercial, it sure 
is good enough for Krita. ;)

Cheers,

Moritz