From Fedora Project Wiki

Demo plans

What do we want people to take out of the demo

  • Composite isn't about drop shadows, nor is using a 3D

hardware to do desktop graphics about rotating CD trays.

  • A mental understanding of our entire block diagram.
  • Doing work on infrastructure issues like

EXT_framebuffer_object and accelerated indirect rendering will pay off in cool results.

  • The coherency of the bits of the Fedora Rendering project

What do we want to cover

  • Cairo as a common rendering layer, screen and printing.
  • Compositing manager / toolkit interactions
  • Using Cairo within GTK+
  • Using GL in a compositing manager
  • Using the technologies to do new UI techniques.


Here's a somewhat ambitious idea for what our presentation / demo should be.

  • Intro
  • Start off with nice SVG based slides, full screen.
  • Describe the "problem".
  • Show some mockups of effects we'd like to achieve.
  • Rendering
  • Describe how Cairo is the universal rendering library
  • Unminimize, reveal that the SVG slides are showing in

a simple GTK+ application with an interesting Cairo-base theme.

  • Show the *same* slides showing in evince rendering

a PDF via Cairo. (Maybe have printed version for handouts as well?)

  • Run a demo app showing off more of Cairo, including Pango features
  • Compositing manager
  • So far, window management has been straightforward X.

Demonstrate some flaws:

  • Flash on map
  • Resizing lag
  • Restart metacity as a compositing manager drop shadows appear,
  • redemonstrate absence of flaws.
  • GL
  • Hit a key combination that that unfullscreens the server we

are running, and shows that we've been running everything so far in a full-screen Xnest/Xvnc style nested session.

  • Close that app.
  • Start luminocity, comes up looking approximately like

the Metacity CM we demo'ed earlier, but with live thumbnailing pagers, maybe a few other things.

luminocity comes up as small scaled down window. When we full-screen it, it smoothly zooms to fullscreen scaling out as it goes.

  • Show off the thumbnailing pagers.
  • Show off some smooth interactive scaling effect...

such as a window smoothly shrinking and docking.

  • Turn on some more spectacular effect, such as

lighting, depth-of-field, or reflections that would be hard or impossible to do using RENDER.

  • What needs work
  • Describe why the GL-based CM should be an indirect client.

(See RenderingProject/CMArchitecture)

Describe other missing bits of GL briefly

Demo hardware

I don't think we'll be able to run the demo above on a laptop. The laptops we have are either R100 or Savage, which are both a bit marginal in performance for doing cool demos.

(If someone has a R200 laptop, that might be an option, but the recent thinkpads we have are still R100, right?)

So, we'll probably need to bring in a desktop. There we have our choice of:

  • Intel 910
  • R200
  • R300 plus fglrx
  • nVidia closeds-source

We'll probably be doing development on a mix of such systems, so we can see how things work. All we need from the server with the above script is:

  • Decent GL implementation for luminocity
  • Fast way of pushing pixels to the card for the nested server

Software bits

So, what parts of the above demo need writing?

  • An efficient solution for running a server and either

displaying the server in a window or using it as a source for luminocity. Xfake+lightpipe is a possible solution, but we could do better if Xfake could map it's framebuffer shared via shm or mmap.

Another possiblity is Xephyr If it can be made to have little overhead over Xfake when minimized, it's pretty much exactly what we want.

When we start running a compositing manager, we might want to add synchronizations hooks between the display agent and the CM, so that we can redisplay entire frames at once rather than redrawing little bits.

  • Work on the PDF backend to make it handle our slides

OK. (I think we'll mostly be over text and polygons, so we should be pretty close to fine.)

  • A GTK+ frontend to Carl's SVG slide stuff. (Just hooking

together a list-of-slides treeview and a menu, really.)

I'm withdrawing my ooimpress objection... I think demoing Cairo is more important than doing complicated slides.

  • A Cairo-based GTK+ theme that looks good. To get this

going quickly, we probably want to go flat, vectorial, and geometric, even if that's considerd "been done already".

  • Luminocity work:
  • Picking it back up out of cold storage
  • Making sure it works on everybody's machines.
  • Fixing the title bars to look less like FVWM
  • Cool effects
  • Misc work. Consult with Diana/Seth/Bryan to find one cool

thing to implement involving things like:

  • Breaking the rectangular window border (tabs sticking

out the side?)

  • Objects that rescale as they are dragged

In other words, a UI gadget that needs COMPOSITE.


Some intermediate milestones

Jan 27:: Initial crude GTK+ theme, initial slide app, revive luminocity, do a bit of work on it. xpdf-cairo integrated into evince.

Feb 3:: "cool" luminocity feature, GTK+ theme basically there,

Feb 10:: dress-rehearsal of our complete presentation.