Home | History | Annotate | Download | only in quads 
      1 // Copyright 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef CC_QUADS_RENDER_PASS_H_
      6 #define CC_QUADS_RENDER_PASS_H_
      7 
      8 #include <utility>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/callback.h"
     12 #include "base/containers/hash_tables.h"
     13 #include "cc/base/cc_export.h"
     14 #include "cc/base/scoped_ptr_vector.h"
     15 #include "skia/ext/refptr.h"
     16 #include "ui/gfx/rect.h"
     17 #include "ui/gfx/rect_f.h"
     18 #include "ui/gfx/transform.h"
     19 
     20 namespace base {
     21 class Value;
     22 };
     23 
     24 namespace cc {
     25 
     26 class DrawQuad;
     27 class CopyOutputRequest;
     28 class SharedQuadState;
     29 
     30 // A list of DrawQuad objects, sorted internally in front-to-back order.
     31 class QuadList : public ScopedPtrVector<DrawQuad> {
     32  public:
     33   typedef reverse_iterator BackToFrontIterator;
     34   typedef const_reverse_iterator ConstBackToFrontIterator;
     35 
     36   inline BackToFrontIterator BackToFrontBegin() { return rbegin(); }
     37   inline BackToFrontIterator BackToFrontEnd() { return rend(); }
     38   inline ConstBackToFrontIterator BackToFrontBegin() const { return rbegin(); }
     39   inline ConstBackToFrontIterator BackToFrontEnd() const { return rend(); }
     40 };
     41 
     42 typedef ScopedPtrVector<SharedQuadState> SharedQuadStateList;
     43 
     44 class CC_EXPORT RenderPass {
     45  public:
     46   struct Id {
     47     int layer_id;
     48     int index;
     49 
     50     Id(int layer_id, int index) : layer_id(layer_id), index(index) {}
     51     void* AsTracingId() const;
     52 
     53     bool operator==(const Id& other) const {
     54       return layer_id == other.layer_id && index == other.index;
     55     }
     56     bool operator!=(const Id& other) const {
     57       return !(*this == other);
     58     }
     59     bool operator<(const Id& other) const {
     60       return layer_id < other.layer_id ||
     61           (layer_id == other.layer_id && index < other.index);
     62     }
     63   };
     64 
     65   ~RenderPass();
     66 
     67   static scoped_ptr<RenderPass> Create();
     68   static scoped_ptr<RenderPass> Create(size_t num_layers);
     69 
     70   // A shallow copy of the render pass, which does not include its quads or copy
     71   // requests.
     72   scoped_ptr<RenderPass> Copy(Id new_id) const;
     73 
     74   // A deep copy of the render passes in the list including the quads.
     75   static void CopyAll(const ScopedPtrVector<RenderPass>& in,
     76                       ScopedPtrVector<RenderPass>* out);
     77 
     78   void SetNew(Id id,
     79               gfx::Rect output_rect,
     80               gfx::RectF damage_rect,
     81               const gfx::Transform& transform_to_root_target);
     82 
     83   void SetAll(Id id,
     84               gfx::Rect output_rect,
     85               gfx::RectF damage_rect,
     86               const gfx::Transform& transform_to_root_target,
     87               bool has_transparent_background);
     88 
     89   scoped_ptr<base::Value> AsValue() const;
     90 
     91   // Uniquely identifies the render pass in the compositor's current frame.
     92   Id id;
     93 
     94   // These are in the space of the render pass' physical pixels.
     95   gfx::Rect output_rect;
     96   gfx::RectF damage_rect;
     97 
     98   // Transforms from the origin of the |output_rect| to the origin of the root
     99   // render pass' |output_rect|.
    100   gfx::Transform transform_to_root_target;
    101 
    102   // If false, the pixels in the render pass' texture are all opaque.
    103   bool has_transparent_background;
    104 
    105   // If non-empty, the renderer should produce a copy of the render pass'
    106   // contents as a bitmap, and give a copy of the bitmap to each callback in
    107   // this list. This property should not be serialized between compositors, as
    108   // it only makes sense in the root compositor.
    109   ScopedPtrVector<CopyOutputRequest> copy_requests;
    110 
    111   QuadList quad_list;
    112   SharedQuadStateList shared_quad_state_list;
    113 
    114  protected:
    115   explicit RenderPass(size_t num_layers);
    116   RenderPass();
    117 
    118  private:
    119   DISALLOW_COPY_AND_ASSIGN(RenderPass);
    120 };
    121 
    122 }  // namespace cc
    123 
    124 namespace BASE_HASH_NAMESPACE {
    125 #if defined(COMPILER_MSVC)
    126 inline size_t hash_value(const cc::RenderPass::Id& key) {
    127   return base::HashPair(key.layer_id, key.index);
    128 }
    129 #elif defined(COMPILER_GCC)
    130 template<>
    131 struct hash<cc::RenderPass::Id> {
    132   size_t operator()(cc::RenderPass::Id key) const {
    133     return base::HashPair(key.layer_id, key.index);
    134   }
    135 };
    136 #else
    137 #error define a hash function for your compiler
    138 #endif  // COMPILER
    139 }  // namespace BASE_HASH_NAMESPACE
    140 
    141 namespace cc {
    142 typedef ScopedPtrVector<RenderPass> RenderPassList;
    143 typedef base::hash_map<RenderPass::Id, RenderPass*> RenderPassIdHashMap;
    144 }  // namespace cc
    145 
    146 #endif  // CC_QUADS_RENDER_PASS_H_
    147