Texture Draw Calls Coalescing

cc/direct_renderer.cc

 // Copyright 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/direct_renderer.h"
 
 #include <vector>
 
 #include "base/debug/trace_event.h"
 #include "cc/math_util.h"
@@ skipping 189 matching lines @@
 
     if (quadScissorRect.IsEmpty()) {
         *shouldSkipQuad = true;
         return;
     }
 
     *shouldSkipQuad = false;
     setScissorTestRect(moveScissorToWindowSpace(frame, quadScissorRect));
 }
 
+void DirectRenderer::finishDrawingQuadList()

[shawnsingh, 2012/11/28 19:44:16]

I know I was the one who suggested doing it this way, but now I changed my
mind...  since the rest of the drawing-related API is only pure virtual, perhaps
we should also make this pure virtual to be consistent. 

[whunt, 2012/11/28 22:01:15]

DirectRenderer isn't a virtual interface, it's already got tons of
functionality.  I don't see any real logic as to which parts are pure virtual
and which aren't.  This function can certainly be made pure virtual but I don't
see a strong reason to change it.  Is there some convention?

On 2012/11/28 19:44:16, shawnsingh wrote:

[danakj, 2012/11/28 22:03:16]

Things that would be useful for GLRenderer and SoftwareRenderer live in
DirectRenderer. Things that are GL-specific live in the subclass.

Generally the DirectRenderer has the logic to draw a frame, and abstract methods
filled in by GLRenderer or SoftwareRenderer to make it happen.

+{
+}
+
 void DirectRenderer::drawRenderPass(DrawingFrame& frame, const RenderPass* renderPass)
 {
     TRACE_EVENT0("cc", "DirectRenderer::drawRenderPass");
     if (!useRenderPass(frame, renderPass))
         return;
 
     bool usingScissorAsOptimization = capabilities().usingPartialSwap;
     gfx::RectF renderPassScissor;
 
     if (usingScissorAsOptimization) {
         renderPassScissor = computeScissorRectForRenderPass(frame);
         setScissorTestRect(moveScissorToWindowSpace(frame, renderPassScissor));
     }
 
     clearFramebuffer(frame);
 
     const QuadList& quadList = renderPass->quad_list;
     for (QuadList::constBackToFrontIterator it = quadList.backToFrontBegin(); it != quadList.backToFrontEnd(); ++it) {
         const DrawQuad& quad = *(*it);
         bool shouldSkipQuad = false;
 
         if (usingScissorAsOptimization)
             setScissorStateForQuadWithRenderPassScissor(frame, quad, renderPassScissor, &shouldSkipQuad);
         else
             setScissorStateForQuad(frame, quad);
 
         if (!shouldSkipQuad)
             drawQuad(frame, *it);
     }
+    finishDrawingQuadList();
 
     CachedResource* texture = m_renderPassTextures.get(renderPass->id);
     if (texture)
         texture->setIsComplete(!renderPass->has_occlusion_from_outside_target_surface);
 }
 
 bool DirectRenderer::useRenderPass(DrawingFrame& frame, const RenderPass* renderPass)
 {
     frame.currentRenderPass = renderPass;
     frame.currentTexture = 0;
@@ skipping 25 matching lines @@
     return pass->output_rect.size();
 }
 
 // static
 GLenum DirectRenderer::renderPassTextureFormat(const RenderPass*)
 {
     return GL_RGBA;
 }
 
 }  // namespace cc