O2D:...

core/cross/cairo/renderer_cairo.cc

 /*
  * Copyright 2010, Google Inc.

[fbarchard, 2011/01/19 18:51:20]

update to 2011

[Tristan Schmelcher 2, 2011/01/20 00:26:16]

Done.

  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
  * copyright notice, this list of conditions and the following disclaimer
@@ skipping 75 matching lines @@
   // Sort layers by z value.
   // TODO(tschmelcher): Only sort when changes are made.
   layer_list_.sort(LayerZValueLessThan);
 
   // Paint the background.
   PaintBackground(current_drawing);
 
   // Core process of painting.
   for (LayerList::iterator i = layer_list_.begin();
        i != layer_list_.end(); i++) {
-    // Put the state with no mask to the stack.
+    Layer* cur = *i;
+    if (!cur->ShouldPaint()) continue;
+
+    Pattern* pattern = cur->pattern();
+
+    // Save the current drawing state.
     cairo_save(current_drawing);
 
-    // Preparing and updating the Layer.
-    Layer* cur = *i;
-    Pattern* pattern = cur->pattern();
-    if (!pattern) {
-      // Skip layers with no pattern assigned.
-      continue;
+    // Clip areas that will be obscured anyway.
+    LayerList::iterator start_mask_it = i;
+    start_mask_it++;
+    ClipArea(current_drawing, start_mask_it);
+
+    // Define the region to fill.
+    cairo_rectangle(current_drawing,
+                    cur->x(),
+                    cur->y(),
+                    cur->width(),
+                    cur->height());
+
+    // Transform the pattern to fit into the fill region.
+    cairo_translate(current_drawing, cur->x(), cur->y());
+    cairo_scale(current_drawing, cur->scale_x(), cur->scale_y());
+
+    // Set source pattern.
+    cairo_set_source(current_drawing, pattern->pattern());
+
+    // Paint the pattern to the off-screen surface.
+    switch (cur->paint_operator()) {
+      case Layer::BLEND:
+        cairo_fill(current_drawing);
+        break;
+
+      case Layer::BLEND_WITH_TRANSPARENCY:
+        {
+          cairo_pattern_t* mask = cairo_pattern_create_rgba(0.0,
+                                                            0.0,
+                                                            0.0,
+                                                            cur->alpha());

[fbarchard, 2011/01/19 18:51:20]

Can transparency be done with flat shading?
provide an ARGB to shade the texture with, supplying the alpha, and render with
transparency?

[Tristan Schmelcher 2, 2011/01/20 00:26:16]

That's basically what this is. The "mask" is an ARGB value whose colour content
is ignored and cairo_mask renders the source using the alpha component of the
mask as the transparency. I don't know whether it uses a shader internally or
not, but that doesn't matter--Cairo doesn't support user-defined shaders, so
this is the best option AFAICT.

[fbarchard, 2011/01/20 18:06:05]

shading, not shaders.
flat shading is like Gouraud, but uses the same color value for all pixels.
Its unclear if you've implemented this correctly.

[Tristan Schmelcher 2, 2011/01/20 20:43:32]

I'm pretty sure it's right. You can look up the documentation on
cairo_mask()--it sounds like exactly what we want. And it looks correct on
screen.

+          cairo_mask(current_drawing, mask);
+          cairo_pattern_destroy(mask);
+        }
+        break;
+
+      case Layer::COPY:
+      case Layer::COPY_WITH_FADING:  // Not implemented yet; treat as COPY

[fbarchard, 2011/01/19 18:51:20]

mark as todo?
Can also be done with shading?
or attenuate the source.  But changing the source will hurt upload speed

[Tristan Schmelcher 2, 2011/01/20 00:26:16]

Done.
No user-defined shader support.
The best option I've found so far is to first paint opaque black and then do
BLEND_WITH_TRANSPARENCY on top of that. I'm hoping to find something better in
the Cairo API though. But this paint operator is only used when fading in feeds,
which isn't the "steady-state" behaviour, so the speed of it isn't critical.

+        // Set Cairo to copy the pattern's alpha content instead of blending.
+        cairo_set_operator(current_drawing, CAIRO_OPERATOR_SOURCE);
+        cairo_fill(current_drawing);
+        break;
     }
 
-    // Masking areas for other scene.
-    LayerList::iterator start_mask_it = i;
-    start_mask_it++;
-    MaskArea(current_drawing, start_mask_it);
-
-    cairo_translate(current_drawing, cur->x(), cur->y());
-
-    cairo_scale(current_drawing, cur->scale_x(), cur->scale_y());
-
-    // Painting the image to the surface.
-    cairo_set_source(current_drawing, pattern->pattern());
-
-    cairo_paint_with_alpha(current_drawing, cur->alpha());
-
-    // Restore to the state with no mask.
+    // Restore to a clean state.
     cairo_restore(current_drawing);
   }
 
   // Finish off-screen drawing and make the off-screen surface the source for
   // paints to the screen.
   cairo_pop_group_to_source(current_drawing);
 
   // Paint the off-screen surface to the screen.
   cairo_paint(current_drawing);
 
   cairo_destroy(current_drawing);
 }
 
 void RendererCairo::PaintBackground(cairo_t* cr) {
   cairo_save(cr);
-  MaskArea(cr, layer_list_.begin());
+  ClipArea(cr, layer_list_.begin());
 
   cairo_rectangle(cr, 0, 0, display_width(), display_height());
   cairo_set_source_rgb(cr, 0.0, 0.0, 0.0);
   cairo_fill(cr);
   cairo_restore(cr);
 }
 
-void RendererCairo::MaskArea(cairo_t* cr,  LayerList::iterator it) {
+void RendererCairo::ClipArea(cairo_t* cr,  LayerList::iterator it) {
   cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
 
   for (LayerList::iterator i = it; i != layer_list_.end(); i++) {
     // Preparing and updating the Layer.
-    Layer* cur_mask = *i;
+    Layer* cur = *i;
+    if (!cur->ShouldClip()) continue;
 
     cairo_rectangle(cr, 0, 0, display_width(), display_height());
     cairo_rectangle(cr,
-                    cur_mask->x(),
-                    cur_mask->y(),
-                    cur_mask->width(),
-                    cur_mask->height());
+                    cur->x(),
+                    cur->y(),
+                    cur->width(),
+                    cur->height());
     cairo_clip(cr);
   }
 }
 
 void RendererCairo::AddLayer(Layer* image) {
   layer_list_.push_front(image);
 }
 
 void RendererCairo::RemoveLayer(Layer* image) {
   layer_list_.remove(image);
@@ skipping 262 matching lines @@
   NOTIMPLEMENTED();
 }
 
 void RendererCairo::PopRenderStates() {
   NOTIMPLEMENTED();
 }
 
 }  // namespace o2d
 
 }  // namespace o3d