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 "cc/quads/list_container.h"
     16 #include "cc/quads/render_pass_id.h"
     17 #include "skia/ext/refptr.h"
     18 #include "ui/gfx/rect.h"
     19 #include "ui/gfx/rect_f.h"
     20 #include "ui/gfx/transform.h"
     21 
     22 namespace base {
     23 namespace debug {
     24 class TracedValue;
     25 }
     26 class Value;
     27 };
     28 
     29 namespace cc {
     30 
     31 class DrawQuad;
     32 class CopyOutputRequest;
     33 class RenderPassDrawQuad;
     34 class SharedQuadState;
     35 
     36 // A list of DrawQuad objects, sorted internally in front-to-back order.
     37 class QuadList : public ListContainer<DrawQuad> {
     38  public:
     39   explicit QuadList(size_t default_size_to_reserve);
     40 
     41   typedef QuadList::ReverseIterator BackToFrontIterator;
     42   typedef QuadList::ConstReverseIterator ConstBackToFrontIterator;
     43 
     44   inline BackToFrontIterator BackToFrontBegin() { return rbegin(); }
     45   inline BackToFrontIterator BackToFrontEnd() { return rend(); }
     46   inline ConstBackToFrontIterator BackToFrontBegin() const { return rbegin(); }
     47   inline ConstBackToFrontIterator BackToFrontEnd() const { return rend(); }
     48 };
     49 
     50 typedef ScopedPtrVector<SharedQuadState> SharedQuadStateList;
     51 
     52 class CC_EXPORT RenderPass {
     53  public:
     54   ~RenderPass();
     55 
     56   static scoped_ptr<RenderPass> Create();
     57   static scoped_ptr<RenderPass> Create(size_t num_layers);
     58 
     59   // A shallow copy of the render pass, which does not include its quads or copy
     60   // requests.
     61   scoped_ptr<RenderPass> Copy(RenderPassId new_id) const;
     62 
     63   // A deep copy of the render passes in the list including the quads.
     64   static void CopyAll(const ScopedPtrVector<RenderPass>& in,
     65                       ScopedPtrVector<RenderPass>* out);
     66 
     67   void SetNew(RenderPassId id,
     68               const gfx::Rect& output_rect,
     69               const gfx::Rect& damage_rect,
     70               const gfx::Transform& transform_to_root_target);
     71 
     72   void SetAll(RenderPassId id,
     73               const gfx::Rect& output_rect,
     74               const gfx::Rect& damage_rect,
     75               const gfx::Transform& transform_to_root_target,
     76               bool has_transparent_background);
     77 
     78   void AsValueInto(base::debug::TracedValue* dict) const;
     79 
     80   SharedQuadState* CreateAndAppendSharedQuadState();
     81 
     82   template <typename DrawQuadType>
     83   DrawQuadType* CreateAndAppendDrawQuad() {
     84     return quad_list.AllocateAndConstruct<DrawQuadType>();
     85   }
     86 
     87   RenderPassDrawQuad* CopyFromAndAppendRenderPassDrawQuad(
     88       const RenderPassDrawQuad* quad,
     89       const SharedQuadState* shared_quad_state,
     90       RenderPassId render_pass_id);
     91   DrawQuad* CopyFromAndAppendDrawQuad(const DrawQuad* quad,
     92                                       const SharedQuadState* shared_quad_state);
     93 
     94   // Uniquely identifies the render pass in the compositor's current frame.
     95   RenderPassId id;
     96 
     97   // These are in the space of the render pass' physical pixels.
     98   gfx::Rect output_rect;
     99   gfx::Rect damage_rect;
    100 
    101   // Transforms from the origin of the |output_rect| to the origin of the root
    102   // render pass' |output_rect|.
    103   gfx::Transform transform_to_root_target;
    104 
    105   // If false, the pixels in the render pass' texture are all opaque.
    106   bool has_transparent_background;
    107 
    108   // If non-empty, the renderer should produce a copy of the render pass'
    109   // contents as a bitmap, and give a copy of the bitmap to each callback in
    110   // this list. This property should not be serialized between compositors, as
    111   // it only makes sense in the root compositor.
    112   ScopedPtrVector<CopyOutputRequest> copy_requests;
    113 
    114   QuadList quad_list;
    115   SharedQuadStateList shared_quad_state_list;
    116 
    117  protected:
    118   explicit RenderPass(size_t num_layers);
    119   RenderPass();
    120 
    121  private:
    122   template <typename DrawQuadType>
    123   DrawQuadType* CopyFromAndAppendTypedDrawQuad(const DrawQuad* quad) {
    124     return quad_list.AllocateAndCopyFrom(DrawQuadType::MaterialCast(quad));
    125   }
    126 
    127   DISALLOW_COPY_AND_ASSIGN(RenderPass);
    128 };
    129 
    130 }  // namespace cc
    131 
    132 namespace BASE_HASH_NAMESPACE {
    133 #if defined(COMPILER_MSVC)
    134 inline size_t hash_value(const cc::RenderPassId& key) {
    135   return base::HashPair(key.layer_id, key.index);
    136 }
    137 #elif defined(COMPILER_GCC)
    138 template <>
    139 struct hash<cc::RenderPassId> {
    140   size_t operator()(cc::RenderPassId key) const {
    141     return base::HashPair(key.layer_id, key.index);
    142   }
    143 };
    144 #else
    145 #error define a hash function for your compiler
    146 #endif  // COMPILER
    147 }  // namespace BASE_HASH_NAMESPACE
    148 
    149 namespace cc {
    150 typedef ScopedPtrVector<RenderPass> RenderPassList;
    151 typedef base::hash_map<RenderPassId, RenderPass*> RenderPassIdHashMap;
    152 }  // namespace cc
    153 
    154 #endif  // CC_QUADS_RENDER_PASS_H_
    155