RenderingProject/DemoPlans

= Demo plans =

What do we want people to take out of the demo
hardware to do desktop graphics about rotating CD trays.
 * Composite isn't about drop shadows, nor is using a 3D


 * A mental understanding of our entire block diagram.

EXT_framebuffer_object and accelerated indirect rendering will pay off in cool results.
 * Doing work on infrastructure issues like


 * 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.

Script
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

a simple GTK+ application with an interesting Cairo-base theme.
 * Unminimize, reveal that the SVG slides are showing in

a PDF via Cairo. (Maybe have printed version for handouts as well?)
 * Show the *same* slides showing in evince rendering


 * Run a demo app showing off more of Cairo, including Pango features


 * Compositing manager

Demonstrate some flaws:
 * So far, window management has been straightforward X.


 * Flash on map
 * Resizing lag


 * Restart metacity as a compositing manager drop shadows appear,
 * redemonstrate absence of flaws.


 * GL

are running, and shows that we've been running everything so far in a full-screen Xnest/Xvnc style nested session.
 * Hit a key combination that that unfullscreens the server we


 * Close that app.

the Metacity CM we demo'ed earlier, but with live thumbnailing pagers, maybe a few other things.
 * Start luminocity, comes up looking approximately like

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.

such as a window smoothly shrinking and docking.
 * Show off some smooth interactive scaling effect...

lighting, depth-of-field, or reflections that would be hard or impossible to do using RENDER.
 * Turn on some more spectacular effect, such as


 * What needs work

(See RenderingProject/CMArchitecture)
 * Describe why the GL-based CM should be an indirect client.

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?

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.
 * An efficient solution for running a server and either

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.

OK. (I think we'll mostly be over text and polygons, so we should be pretty close to fine.)
 * Work on the PDF backend to make it handle our slides

together a list-of-slides treeview and a menu, really.)
 * A GTK+ frontend to Carl's SVG slide stuff. (Just hooking

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

going quickly, we probably want to go flat, vectorial, and geometric, even if that's considerd "been done already".
 * A Cairo-based GTK+ theme that looks good. To get this


 * 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

thing to implement involving things like:
 * Misc work. Consult with Diana/Seth/Bryan to find one cool

out the side?)
 * Breaking the rectangular window border (tabs sticking
 * Objects that rescale as they are dragged

In other words, a UI gadget that needs COMPOSITE.

Scheduling
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.