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 20namespace base { 21class Value; 22}; 23 24namespace cc { 25 26class DrawQuad; 27class CopyOutputRequest; 28class SharedQuadState; 29 30// A list of DrawQuad objects, sorted internally in front-to-back order. 31class 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 42typedef ScopedPtrVector<SharedQuadState> SharedQuadStateList; 43 44class 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 const gfx::Rect& output_rect, 80 const gfx::Rect& damage_rect, 81 const gfx::Transform& transform_to_root_target); 82 83 void SetAll(Id id, 84 const gfx::Rect& output_rect, 85 const gfx::Rect& 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 SharedQuadState* CreateAndAppendSharedQuadState(); 92 void AppendDrawQuad(scoped_ptr<DrawQuad> draw_quad); 93 94 // Uniquely identifies the render pass in the compositor's current frame. 95 Id 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 DISALLOW_COPY_AND_ASSIGN(RenderPass); 123}; 124 125} // namespace cc 126 127namespace BASE_HASH_NAMESPACE { 128#if defined(COMPILER_MSVC) 129inline size_t hash_value(const cc::RenderPass::Id& key) { 130 return base::HashPair(key.layer_id, key.index); 131} 132#elif defined(COMPILER_GCC) 133template<> 134struct hash<cc::RenderPass::Id> { 135 size_t operator()(cc::RenderPass::Id key) const { 136 return base::HashPair(key.layer_id, key.index); 137 } 138}; 139#else 140#error define a hash function for your compiler 141#endif // COMPILER 142} // namespace BASE_HASH_NAMESPACE 143 144namespace cc { 145typedef ScopedPtrVector<RenderPass> RenderPassList; 146typedef base::hash_map<RenderPass::Id, RenderPass*> RenderPassIdHashMap; 147} // namespace cc 148 149#endif // CC_QUADS_RENDER_PASS_H_ 150