On 7/28/08, Souichi TAKASHIGE <[EMAIL PROTECTED]> wrote:
>> No, it's only destructive if we have no way of regenerating the cache as
>> With GEGL, we can cache just at the newest node in the graph. Stroke
>> information can be fully stored in the node.
> From my understanding, if stroke information is stored in the node,
> then the stroke can be regenerated, and that operation will be
> non-destructive since the cache can be regenerated. I think David says
> about "non-destructive" brush operation.
> I saw source code of gegl-paint. It seems that gegl_vector stores the
> information of the path, so I think it is also about non-destructive
> brush tool.
It is, right now that test program is destructive in that it forces a
save/merge-down of the stroke as a temporary workaround until cache management
in GEGL becomes better.
> On the other hand, Øyvind says that we can implement "destructive"
> brush. I think being "destructive" implies that there's no way to
> regenerate the stroke since being able to regenerate the stroke means
> that the cache is regeneratable, so the operation must not have any
> path information.
The task of the painting operation is to provide the rendered result for a
series of input events/coordinates, as well as a configuration for how it
should be rendered. The code is written in a manner that makes it possible to
append to the path and recompute a minimal region (semi working, but has some
visual artifacts). All the things GIMP currently do can
be expressed using this. It can also be easily extended to store line width and
opacity varying along the stroke.
When it comes to implementing more destructive like buffer access for
performance reasons one could implement an operation that operates on a
GeglBuffer in-place. It would still be possible to replay it from history, but
there wouldn't be valid caches for each operation, and the replay would be much
more expensive. We could add a smaller undo stack for the buffer though adding
support for undo tiles for GeglBuffers has existed in the past and could be
resurrected. Such a smaller undo stack might be useful, but that is probably
something to keep in mind later after purging of caches, and copy on write
I am not actively pursuing experimenting with this at the moment, but there is
enough proof of concept code that it should be possible to start porting the
current GIMP tools to such an infrastructure. This would also be the moment
that the GIMP tools gain higher bitdepth retouching capabilities, initially it
would make sense to port it in such a manner that it works, but is perhaps
slow. Then to optimize as needed. How it makes sense to store this in a graph
in GIMP probably should wait until the projection of the layer stack in GIMP
has been ported, then it would be possible to add the strokes as a layer group
«The future is already here. It's just not very evenly distributed»
-- William Gibson
Gimp-developer mailing list