[Gnash-commit] [SCM] Gnash branch, openvg, updated. 6db62f2e7dfba6268fc7949c47756fde9b573170

[Rob Savoye]

This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "Gnash".

The branch, openvg has been updated
       via  6db62f2e7dfba6268fc7949c47756fde9b573170 (commit)
       via  ebf37343b5d88ef89a164de554cdaf55d1d0a4cf (commit)
      from  7504021cd0d1968354c456a4fd3243f66b85e627 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
http://git.savannah.gnu.org/cgit//commit/?id=6db62f2e7dfba6268fc7949c47756fde9b573170


commit 6db62f2e7dfba6268fc7949c47756fde9b573170
Author: Rob Savoye <address@hidden>
Date:   Fri Dec 3 09:58:00 2010 -0700

    add more explanation of devices.

diff --git a/librender/README b/librender/README
index b8f23a0..6efad11 100644
--- a/librender/README
+++ b/librender/README
@@ -21,8 +21,38 @@ The main difference between how the Gnash renderers used to 
work and
 the way they work now is they have gained device knowledge. In the
 embedded world, all GPUs have varying levels of accleration
 support. This functionality is probed at runtime now, and the optimal
-acceleration support selected automatically.
+acceleration support selected automatically. For the features without
+hardware accleration available, they will be renderered in software.
 
 This allows us Gnash to take advantage of each GPUs support where it
-best makes sense.
+best makes sense. Until recently, Gnash just depended on whatever the
+X11 desktop supplied. To run properly without X11 though, requires the
+ability in Gnash to supply the missing support.
 
+Currently 3 devices are supported, as these are the most portable. The
+primary default device is EGL, as it's used by OpenVG, OpenGLES1, and
+OpenGLES2, on both embedded and desktop platforms. When using Gallium
+drivers under libMesa, EGL supports hardware acceleration for the
+higher level libraries.
+
+The DirectFB device is a bit of a special case, as it's both an
+accleration library and a GUI toolkit. So this one has support in both
+librender and gui libraries. For rendering, only the device specific
+parts of DirectFB are used.
+
+The X11 device is primarily for testing and for running EGL on
+X11. This makes X11 follow the same API as the other devices, and
+allows simple window creation via xlib for testing renderers.
+
+GnashDevice
+       > EglDevice
+       > X11Device
+       > DirectFBDevice
+
+Renderer
+       > Renderer_base_agg
+         > Renderer_agg
+       > Renderer_ogl
+       > Renderer_gles1
+       > Renderer_gles2
+       > Renderer_ovg

http://git.savannah.gnu.org/cgit//commit/?id=ebf37343b5d88ef89a164de554cdaf55d1d0a4cf


commit ebf37343b5d88ef89a164de554cdaf55d1d0a4cf
Author: Rob Savoye <address@hidden>
Date:   Fri Dec 3 09:46:40 2010 -0700

    start documentation on how rendering works.

diff --git a/librender/README b/librender/README
new file mode 100644
index 0000000..b8f23a0
--- /dev/null
+++ b/librender/README
@@ -0,0 +1,28 @@
+There is a process here that has to happen in a specific order. The
+first step is to initialize the base hardware platform. Normally for
+X11 you can assume this has already happened. If using EGL from Mesa
+on X11, then we stil need to do this step, as EGL is out interface,
+not X11.
+
+After the device layer is initialized, then the renderer gets
+created. This is just the base initilization though, as the rest needs
+a window to draw into. So the next step after initilizing the renderer
+is to initialize the GUI. For a framebuffer, either EGL or DirectFB
+are used on the bare device.
+
+Once the GUI is initilized, it can then pass the window for the
+renderer to draw into. The renderer initizlizes a surface using the
+window handle, and then make that surface the current context.
+
+Rendering always happens in a back buffer, and is merely swapped with
+the displayed one after rendering.
+
+The main difference between how the Gnash renderers used to work and
+the way they work now is they have gained device knowledge. In the
+embedded world, all GPUs have varying levels of accleration
+support. This functionality is probed at runtime now, and the optimal
+acceleration support selected automatically.
+
+This allows us Gnash to take advantage of each GPUs support where it
+best makes sense.
+

-----------------------------------------------------------------------

Summary of changes:
 librender/README |   58 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 files changed, 58 insertions(+), 0 deletions(-)
 create mode 100644 librender/README


hooks/post-receive
-- 
Gnash