1 // Copyright 2012 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_OUTPUT_DIRECT_RENDERER_H_ 6 #define CC_OUTPUT_DIRECT_RENDERER_H_ 7 8 #include "base/basictypes.h" 9 #include "base/callback.h" 10 #include "base/containers/scoped_ptr_hash_map.h" 11 #include "cc/base/cc_export.h" 12 #include "cc/output/overlay_processor.h" 13 #include "cc/output/renderer.h" 14 #include "cc/resources/resource_provider.h" 15 #include "cc/resources/scoped_resource.h" 16 17 namespace cc { 18 19 class ResourceProvider; 20 21 // This is the base class for code shared between the GL and software 22 // renderer implementations. "Direct" refers to the fact that it does not 23 // delegate rendering to another compositor. 24 class CC_EXPORT DirectRenderer : public Renderer { 25 public: 26 virtual ~DirectRenderer(); 27 28 virtual void DecideRenderPassAllocationsForFrame( 29 const RenderPassList& render_passes_in_draw_order) OVERRIDE; 30 virtual bool HasAllocatedResourcesForTesting(RenderPassId id) const OVERRIDE; 31 virtual void DrawFrame(RenderPassList* render_passes_in_draw_order, 32 float device_scale_factor, 33 const gfx::Rect& device_viewport_rect, 34 const gfx::Rect& device_clip_rect, 35 bool disable_picture_quad_image_filtering) OVERRIDE; 36 37 struct CC_EXPORT DrawingFrame { 38 DrawingFrame(); 39 ~DrawingFrame(); 40 41 const RenderPassList* render_passes_in_draw_order; 42 const RenderPass* root_render_pass; 43 const RenderPass* current_render_pass; 44 const ScopedResource* current_texture; 45 46 gfx::Rect root_damage_rect; 47 gfx::Rect device_viewport_rect; 48 gfx::Rect device_clip_rect; 49 50 gfx::Transform projection_matrix; 51 gfx::Transform window_matrix; 52 53 bool disable_picture_quad_image_filtering; 54 55 OverlayCandidateList overlay_list; 56 }; 57 58 void SetEnlargePassTextureAmountForTesting(const gfx::Vector2d& amount); 59 60 protected: 61 DirectRenderer(RendererClient* client, 62 const LayerTreeSettings* settings, 63 OutputSurface* output_surface, 64 ResourceProvider* resource_provider); 65 66 static gfx::RectF QuadVertexRect(); 67 static void QuadRectTransform(gfx::Transform* quad_rect_transform, 68 const gfx::Transform& quad_transform, 69 const gfx::RectF& quad_rect); 70 void InitializeViewport(DrawingFrame* frame, 71 const gfx::Rect& draw_rect, 72 const gfx::Rect& viewport_rect, 73 const gfx::Size& surface_size); 74 gfx::Rect MoveFromDrawToWindowSpace(const gfx::Rect& draw_rect) const; 75 76 bool NeedDeviceClip(const DrawingFrame* frame) const; 77 gfx::Rect DeviceClipRectInWindowSpace(const DrawingFrame* frame) const; 78 static gfx::Rect ComputeScissorRectForRenderPass(const DrawingFrame* frame); 79 void SetScissorStateForQuad(const DrawingFrame* frame, const DrawQuad& quad); 80 void SetScissorStateForQuadWithRenderPassScissor( 81 const DrawingFrame* frame, 82 const DrawQuad& quad, 83 const gfx::Rect& render_pass_scissor, 84 bool* should_skip_quad); 85 void SetScissorTestRectInDrawSpace(const DrawingFrame* frame, 86 const gfx::Rect& draw_space_rect); 87 88 static gfx::Size RenderPassTextureSize(const RenderPass* render_pass); 89 90 void DrawRenderPass(DrawingFrame* frame, const RenderPass* render_pass); 91 bool UseRenderPass(DrawingFrame* frame, const RenderPass* render_pass); 92 93 virtual void BindFramebufferToOutputSurface(DrawingFrame* frame) = 0; 94 virtual bool BindFramebufferToTexture(DrawingFrame* frame, 95 const ScopedResource* resource, 96 const gfx::Rect& target_rect) = 0; 97 virtual void SetDrawViewport(const gfx::Rect& window_space_viewport) = 0; 98 virtual void SetScissorTestRect(const gfx::Rect& scissor_rect) = 0; 99 virtual void DiscardPixels(bool has_external_stencil_test, 100 bool draw_rect_covers_full_surface) = 0; 101 virtual void ClearFramebuffer(DrawingFrame* frame, 102 bool has_external_stencil_test) = 0; 103 virtual void DoDrawQuad(DrawingFrame* frame, const DrawQuad* quad) = 0; 104 virtual void BeginDrawingFrame(DrawingFrame* frame) = 0; 105 virtual void FinishDrawingFrame(DrawingFrame* frame) = 0; 106 virtual void FinishDrawingQuadList(); 107 virtual bool FlippedFramebuffer() const = 0; 108 virtual void EnsureScissorTestEnabled() = 0; 109 virtual void EnsureScissorTestDisabled() = 0; 110 virtual void DiscardBackbuffer() {} 111 virtual void EnsureBackbuffer() {} 112 113 virtual void CopyCurrentRenderPassToBitmap( 114 DrawingFrame* frame, 115 scoped_ptr<CopyOutputRequest> request) = 0; 116 117 base::ScopedPtrHashMap<RenderPassId, ScopedResource> render_pass_textures_; 118 OutputSurface* output_surface_; 119 ResourceProvider* resource_provider_; 120 scoped_ptr<OverlayProcessor> overlay_processor_; 121 122 // For use in coordinate conversion, this stores the output rect, viewport 123 // rect (= unflipped version of glViewport rect), and the size of target 124 // framebuffer. During a draw, this stores the values for the current render 125 // pass; in between draws, they retain the values for the root render pass of 126 // the last draw. 127 gfx::Rect current_draw_rect_; 128 gfx::Rect current_viewport_rect_; 129 gfx::Size current_surface_size_; 130 131 private: 132 gfx::Vector2d enlarge_pass_texture_amount_; 133 134 DISALLOW_COPY_AND_ASSIGN(DirectRenderer); 135 }; 136 137 } // namespace cc 138 139 #endif // CC_OUTPUT_DIRECT_RENDERER_H_ 140
