O2D:...

core/cross/cairo/renderer_cairo.cc

 /*
- * Copyright 2010, Google Inc.
+ * Copyright 2011, Google Inc.
  * 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());
+          cairo_mask(current_drawing, mask);
+          cairo_pattern_destroy(mask);
+        }
+        break;
+
+        // TODO(tschmelcher): COPY_WITH_FADING is not implemented yet. For now
+        // we treat it the same as COPY.
+      case Layer::COPY_WITH_FADING:
+      case Layer::COPY:
+        // 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;
+
+      default:
+        DCHECK(false);
     }
 
-    // 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