Initial version rendering 2D path for O3D. This will eventually allow O3D app...

core/cross/cairo/renderer_cairo.cc

 /*
  * Copyright 2010, 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.
@@ skipping 19 matching lines @@
  */
 
 // Renderer that is using 2D Library Cairo.
 
 #include "core/cross/cairo/renderer_cairo.h"
 #include <cairo-xlib.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include "core/cross/cairo/texture_cairo.h"
+#include "core/cross/cairo/image_2d.h"
 
 namespace o3d {
 
 Renderer* Renderer::CreateDefaultRenderer(ServiceLocator* service_locator) {
   return RendererCairo::CreateDefault(service_locator);
 }
 
 RendererCairo::RendererCairo(ServiceLocator* service_locator)
-    : Renderer(service_locator), display_(NULL), window_(0),
-      main_surface_(NULL), frame_src_data_(NULL), frame_src_width_(0),
-      frame_src_height_(0), frame_src_pitch_(0) {
+    : Renderer(service_locator), display_(NULL), main_surface_(NULL) {
   // Don't need to do anything.
 }
 
 RendererCairo::~RendererCairo() {
   Destroy();
 }
 
 RendererCairo* RendererCairo::CreateDefault(ServiceLocator* service_locator) {
   return new RendererCairo(service_locator);
 }
 
 // Released all hardware resources.
 void RendererCairo::Destroy() {
   DLOG(INFO) << "To Destroy";
 
   if (main_surface_ != NULL) {
     cairo_surface_destroy(main_surface_);
     main_surface_= NULL;
   }
 
   display_ = NULL;
-  frame_src_data_ = NULL;
-}
-
-void RendererCairo::SetNewFrame(const void* src_data, unsigned src_width,
-                                unsigned src_height, int src_pitch) {
-  DLOG(INFO) << "To Set New Frame";
-  if (src_data == NULL)
-    return;
-
-  frame_src_data_ = src_data;
-  frame_src_width_ = src_width;
-  frame_src_height_ = src_height;
-  frame_src_pitch_ = src_pitch;
 }
 
 // TODO(fransiskusx): Need to check if the shared memory data has been
 // unregistered. It will prevent errors when accessing unregistered
 // shared memory data to render the frame.
 void RendererCairo::Paint() {
   DLOG(INFO) << "To paint";
 
-  if (frame_src_data_ != NULL) {
-    DLOG(INFO) << "To paint new drawing";
+  cairo_t* current_drawing = cairo_create(main_surface_);
+  cairo_save(current_drawing);
 
-    // Preparing the image to render
+  int arr_size = static_cast<int>(image_2d_array_.size());
+
+  // Update resource.
+  for (int i = arr_size-1; i >= 0; i--) {
+    Image2D* cur = image_2d_array_.at(i);
+    cur->updateTextureResource();
+  }
+
+  // Paint the background.
+  PaintBackGround(current_drawing);
+
+  // Core process of painting
+  for (int i = arr_size-1; i >= 0 ; i--) {
+    // Preparing and updating the image2d.
+    Image2D* cur = image_2d_array_.at(i);
+
+    // Check if the pointer to data is null.
+    if (cur->src_data_ == NULL) {
+      continue;
+    }
+
+    DLOG(INFO) << "INDEX = "<< i;
+
+    DLOG(INFO) << cur->src_width_ << ", " <<
+    cur->src_height_<< ", " << cur->src_pitch_ << ", " << cur->scale_x_ <<
+    ", " << cur->scale_y_ << ", " << cur->translate_x_<< ", " <<
+    cur->translate_y_<< ", " << cur->dest_x_<< ", " <<
+    cur->dest_y_<< ", " << cur->alpha_ << "v3.5.7";
+
+    MaskArea(current_drawing, i);
+
+    // Preparing the image to render.
     cairo_surface_t* image = cairo_image_surface_create_for_data(
         const_cast<unsigned char*>(
-            static_cast<const unsigned char*>(frame_src_data_)),
-        CAIRO_FORMAT_ARGB32, frame_src_width_,
-        frame_src_height_, frame_src_pitch_);
-    cairo_t* current_drawing = cairo_create(main_surface_);
+            static_cast<const unsigned char*>(cur->src_data_)),
+        CAIRO_FORMAT_ARGB32, cur->src_width_,
+        cur->src_height_, cur->src_pitch_);
 
-    // Scaling the image
+    // Scale the image.
     double width_scaling =
-        (static_cast<double>(display_width())) / frame_src_width_;
+        (static_cast<double>(cur->scale_x_)) / cur->src_width_;
     double height_scaling =
-        (static_cast<double>(display_height())) / frame_src_height_;
+        (static_cast<double>(cur->scale_y_)) / cur->src_height_;
+
     cairo_scale(current_drawing, width_scaling, height_scaling);
 
-    // Painting the image to the surface
-    cairo_set_source_surface(current_drawing, image, 0, 0);
-    cairo_paint(current_drawing);
+    // Painting the image to the surface.
+    cairo_set_source_surface(current_drawing, image,
+                             (cur->dest_x_+cur->translate_x_)/width_scaling,
+                             (cur->dest_y_+cur->translate_y_)/height_scaling);
 
-    // Cleaning up the memory
-    cairo_destroy(current_drawing);
+    cairo_paint_with_alpha(current_drawing, cur->alpha_);
+
+    // Cleaning up the memory.
     cairo_surface_destroy(image);
+
+    // Restore to the state with no mask and put the state
+    // back in the save stack.
+    cairo_restore(current_drawing);
+    cairo_save(current_drawing);
   }
+  cairo_destroy(current_drawing);
+}
+
+void RendererCairo::PaintBackGround(cairo_t* cr) {
+  cairo_save(cr);
+  MaskArea(cr, static_cast<int>(image_2d_array_.size()));
+
+  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, int index) {
+  // Check if the given index is out of bound(too big) for the image2d array.
+  if (index > static_cast<int>(image_2d_array_.size())) {
+    return;
+  }
+
+  cairo_set_fill_rule(cr, CAIRO_FILL_RULE_EVEN_ODD);
+
+  for (int j = index-1; j >= 0; j--) {
+    // Preparing and updating the image2d.
+    Image2D* curMask = image_2d_array_.at(j);
+
+    DLOG(INFO) << curMask->dest_x_+curMask->translate_x_ << ", " <<
+    curMask->dest_y_+curMask->translate_y_<< ", " <<
+    static_cast<double>(curMask->scale_x_) << ", " <<
+    static_cast<double>(curMask->scale_y_) << "index = " << j;
+
+    cairo_rectangle(cr, 0, 0, display_width(), display_height());
+    cairo_rectangle(cr,
+                    curMask->dest_x_+curMask->translate_x_,
+                    curMask->dest_y_+curMask->translate_y_,
+                    static_cast<double>(curMask->scale_x_),
+                    static_cast<double>(curMask->scale_y_));
+    cairo_clip(cr);
+  }
+}
+
+void RendererCairo::AddImage2D(Image2D* image) {
+  image_2d_array_.push_back(image);
 }
 
 void RendererCairo::InitCommon() {
   main_surface_ = cairo_xlib_surface_create(display_, window_,
                                             XDefaultVisual(display_, 0),
                                             display_width(), display_height());
 }
 
 void RendererCairo::UninitCommon() {
   // Don't need to do anything.
 }
 
 Renderer::InitStatus RendererCairo::InitPlatformSpecific(
     const DisplayWindow& display_window,
     bool off_screen) {
   const DisplayWindowLinux &display_platform =
       static_cast<const DisplayWindowLinux&>(display_window);
   display_ = display_platform.display();
   window_ = display_platform.window();
 
   return SUCCESS;
 }
 
 // Handles the plugin resize event.
 void RendererCairo::Resize(int width, int height) {
   DLOG(INFO) << "To Resize " << width << " x " << height;
   SetClientSize(width, height);
 
-  // Resize the mainSurface
+  // Resize the mainSurface and buffer
   cairo_xlib_surface_set_size(main_surface_, width, height);
 }
 
 // The platform specific part of BeginDraw.
 bool RendererCairo::PlatformSpecificBeginDraw() {
   return true;
 }
 
 // Platform specific version of CreateTexture2D
 Texture2D::Ref RendererCairo::CreatePlatformSpecificTexture2D(
@@ skipping 24 matching lines @@
 void RendererCairo::PlatformSpecificFinishRendering() {
   Paint();
 }
 
 // The platform specific part of Present.
 void RendererCairo::PlatformSpecificPresent() {
   // Don't need to do anything.
 }
 
 // TODO(fransiskusx): DO need to implement before shipped.
+// Removes the Image2D from the array.
+void RendererCairo::RemoveImage2D(Image2D* image) {
+  NOTIMPLEMENTED();
+}
+
+// TODO(fransiskusx): DO need to implement before shipped.
 // Get a single fullscreen display mode by id.
 // Returns true on success, false on error.
 bool RendererCairo::GetDisplayMode(int id, DisplayMode* mode) {
   NOTIMPLEMENTED();
   return true;
 }
 
 // TODO(fransiskusx):  DO need to implement before shipped.
 // Get a vector of the available fullscreen display modes.
 // Clears *modes on error.
@@ skipping 172 matching lines @@
   NOTIMPLEMENTED();
   return RenderDepthStencilSurface::Ref();
 }
 
 // TODO(fransiskusx): This function is not applicable to 2D rendering.
 void RendererCairo::SetState(Renderer* renderer, Param* param) {
   // Don't need to do anything.
   NOTIMPLEMENTED();
 }
 
+void RendererCairo::PopRenderStates() {
+  NOTIMPLEMENTED();
+}
+
 }  // namespace o3d