cc/software_renderer_unittest.cc - chromium/src - Git at Google

 // 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/software_renderer.h"

 #include "cc/compositor_frame_metadata.h"
 #include "cc/quad_sink.h"
 #include "cc/render_pass.h"
 #include "cc/render_pass_draw_quad.h"
 #include "cc/solid_color_draw_quad.h"
 #include "cc/test/animation_test_common.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/test/fake_software_output_device.h"
 #include "cc/test/geometry_test_utils.h"
 #include "cc/test/render_pass_test_common.h"
 #include "cc/test/render_pass_test_utils.h"
 #include "cc/tile_draw_quad.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"

 using namespace WebKit;

 namespace cc {
 namespace {

 class SoftwareRendererTest : public testing::Test, public RendererClient {
 public:
     SoftwareRendererTest()
         : m_shouldClearRootRenderPass(true)
     {
     }

     void initializeRenderer() {
         m_outputSurface = FakeOutputSurface::CreateSoftware(scoped_ptr<SoftwareOutputDevice>(new FakeSoftwareOutputDevice));
         m_resourceProvider = ResourceProvider::create(m_outputSurface.get());
         m_renderer = SoftwareRenderer::create(this, resourceProvider(), softwareDevice());
     }

     SoftwareOutputDevice* softwareDevice() const { return m_outputSurface->SoftwareDevice(); }
     FakeOutputSurface* outputSurface() const { return m_outputSurface.get(); }
     ResourceProvider* resourceProvider() const { return m_resourceProvider.get(); }
     SoftwareRenderer* renderer() const { return m_renderer.get(); }
     void setViewportSize(const gfx::Size& viewportSize) { m_viewportSize = viewportSize; }
     void setShouldClearRootRenderPass(bool clearRootRenderPass) { m_shouldClearRootRenderPass = clearRootRenderPass; }

     // RendererClient implementation.
     virtual const gfx::Size& deviceViewportSize() const OVERRIDE { return m_viewportSize; }
     virtual const LayerTreeSettings& settings() const OVERRIDE { return m_settings; }
     virtual void didLoseOutputSurface() OVERRIDE { }
     virtual void onSwapBuffersComplete() OVERRIDE { }
     virtual void setFullRootLayerDamage() OVERRIDE { }
     virtual void setManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { };
     virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { };
     virtual bool hasImplThread() const OVERRIDE { return false; }
     virtual bool shouldClearRootRenderPass() const OVERRIDE { return m_shouldClearRootRenderPass; }
     virtual CompositorFrameMetadata makeCompositorFrameMetadata() const
         OVERRIDE { return CompositorFrameMetadata(); }

 protected:
     scoped_ptr<FakeOutputSurface> m_outputSurface;
     scoped_ptr<ResourceProvider> m_resourceProvider;
     scoped_ptr<SoftwareRenderer> m_renderer;
     gfx::Size m_viewportSize;
     LayerTreeSettings m_settings;
     bool m_shouldClearRootRenderPass;
 };

 TEST_F(SoftwareRendererTest, solidColorQuad)
 {
     gfx::Size outerSize(100, 100);
     int outerPixels = outerSize.width() * outerSize.height();
     gfx::Size innerSize(98, 98);
     gfx::Rect outerRect(gfx::Point(), outerSize);
     gfx::Rect innerRect(gfx::Point(1, 1), innerSize);
     setViewportSize(outerSize);

     initializeRenderer();

     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
     sharedQuadState->SetAll(gfx::Transform(), outerRect, outerRect, outerRect, false, 1.0);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
     scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::Create();
     rootRenderPass->SetNew(rootRenderPassId, outerRect, gfx::Rect(), gfx::Transform());
     scoped_ptr<SolidColorDrawQuad> outerQuad = SolidColorDrawQuad::Create();
     outerQuad->SetNew(sharedQuadState.get(), outerRect, SK_ColorYELLOW);
     scoped_ptr<SolidColorDrawQuad> innerQuad = SolidColorDrawQuad::Create();
     innerQuad->SetNew(sharedQuadState.get(), innerRect, SK_ColorCYAN);
     rootRenderPass->AppendQuad(innerQuad.PassAs<DrawQuad>());
     rootRenderPass->AppendQuad(outerQuad.PassAs<DrawQuad>());

     RenderPassList list;
     RenderPassIdHashMap hashmap;
     list.push_back(rootRenderPass.get());
     hashmap.add(rootRenderPassId, rootRenderPass.PassAs<RenderPass>());
     renderer()->drawFrame(list, hashmap);

     scoped_array<SkColor> pixels(new SkColor[deviceViewportSize().width() * deviceViewportSize().height()]);
     renderer()->getFramebufferPixels(pixels.get(), outerRect);

 // FIXME: This fails on Android. Endianness maybe?
 // Yellow: expects 0xFFFFFF00, was 0xFF00FFFF on android.
 // Cyan:   expects 0xFF00FFFF, was 0xFFFFFF00 on android.
 // http://crbug.com/154528
 #ifndef OS_ANDROID
     EXPECT_EQ(SK_ColorYELLOW, pixels[0]);
     EXPECT_EQ(SK_ColorYELLOW, pixels[outerPixels - 1]);
     EXPECT_EQ(SK_ColorCYAN, pixels[outerSize.width() + 1]);
     EXPECT_EQ(SK_ColorCYAN, pixels[outerPixels - outerSize.width() - 2]);
 #endif
 }

 TEST_F(SoftwareRendererTest, tileQuad)
 {
     gfx::Size outerSize(100, 100);
     int outerPixels = outerSize.width() * outerSize.height();
     gfx::Size innerSize(98, 98);
     int innerPixels = innerSize.width() * innerSize.height();
     gfx::Rect outerRect(gfx::Point(), outerSize);
     gfx::Rect innerRect(gfx::Point(1, 1), innerSize);
     setViewportSize(outerSize);
     initializeRenderer();

     ResourceProvider::ResourceId resourceYellow = resourceProvider()->createResource(outerSize, GL_RGBA, ResourceProvider::TextureUsageAny);
     ResourceProvider::ResourceId resourceCyan = resourceProvider()->createResource(innerSize, GL_RGBA, ResourceProvider::TextureUsageAny);

     SkColor yellow = SK_ColorYELLOW;
     SkColor cyan = SK_ColorCYAN;
     scoped_array<SkColor> yellowPixels(new SkColor[outerPixels]);
     scoped_array<SkColor> cyanPixels(new SkColor[innerPixels]);
     for (int i = 0; i < outerPixels; i++)
       yellowPixels[i] = yellow;
     for (int i = 0; i < innerPixels; i++)
       cyanPixels[i] = cyan;

     resourceProvider()->setPixels(resourceYellow, reinterpret_cast<uint8_t*>(yellowPixels.get()), gfx::Rect(gfx::Point(), outerSize), gfx::Rect(gfx::Point(), outerSize), gfx::Vector2d());
     resourceProvider()->setPixels(resourceCyan, reinterpret_cast<uint8_t*>(cyanPixels.get()), gfx::Rect(gfx::Point(), innerSize), gfx::Rect(gfx::Point(), innerSize), gfx::Vector2d());

     gfx::Rect rect = gfx::Rect(gfx::Point(), deviceViewportSize());

     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
     sharedQuadState->SetAll(gfx::Transform(), outerRect, outerRect, outerRect, false, 1.0);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
     scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::Create();
     rootRenderPass->SetNew(rootRenderPassId, gfx::Rect(gfx::Point(), deviceViewportSize()), gfx::Rect(), gfx::Transform());
     scoped_ptr<TileDrawQuad> outerQuad = TileDrawQuad::Create();
     outerQuad->SetNew(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false);
     scoped_ptr<TileDrawQuad> innerQuad = TileDrawQuad::Create();
     innerQuad->SetNew(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false);
     rootRenderPass->AppendQuad(innerQuad.PassAs<DrawQuad>());
     rootRenderPass->AppendQuad(outerQuad.PassAs<DrawQuad>());

     RenderPassList list;
     RenderPassIdHashMap hashmap;
     list.push_back(rootRenderPass.get());
     hashmap.add(rootRenderPassId, rootRenderPass.PassAs<RenderPass>());
     renderer()->drawFrame(list, hashmap);

     scoped_array<SkColor> pixels(new SkColor[deviceViewportSize().width() * deviceViewportSize().height()]);
     renderer()->getFramebufferPixels(pixels.get(), outerRect);

     EXPECT_EQ(SK_ColorYELLOW, pixels[0]);
     EXPECT_EQ(SK_ColorYELLOW, pixels[outerPixels - 1]);
     EXPECT_EQ(SK_ColorCYAN, pixels[outerSize.width() + 1]);
     EXPECT_EQ(SK_ColorCYAN, pixels[outerPixels - outerSize.width() - 2]);
 }

 TEST_F(SoftwareRendererTest, shouldClearRootRenderPass)
 {
     gfx::Rect viewportRect(gfx::Size(100, 100));
     size_t viewportPixels = viewportRect.width() * viewportRect.height();
     setViewportSize(viewportRect.size());
     setShouldClearRootRenderPass(false);
     initializeRenderer();

     RenderPassList list;
     RenderPassIdHashMap hashmap;
     ScopedPtrVector<RenderPass> renderPasses;
     scoped_array<SkColor> pixels(new SkColor[viewportPixels]);

     // Draw a fullscreen green quad in a first frame.
     RenderPass::Id rootClearPassId(1, 0);
     TestRenderPass* rootClearPass = addRenderPass(renderPasses, rootClearPassId, viewportRect, gfx::Transform());
     addQuad(rootClearPass, viewportRect, SK_ColorGREEN);

     list.push_back(rootClearPass);
     hashmap.set(rootClearPassId, renderPasses.take(0));

     renderer()->decideRenderPassAllocationsForFrame(list);
     renderer()->drawFrame(list, hashmap);
     renderer()->getFramebufferPixels(pixels.get(), viewportRect);

     EXPECT_EQ(SK_ColorGREEN, pixels[0]);
     EXPECT_EQ(SK_ColorGREEN, pixels[viewportPixels - 1]);

     renderPasses.clear();
     hashmap.clear();
     list.clear();

     // Draw a smaller magenta rect without filling the viewport in a separate frame.
     gfx::Rect smallerRect(20, 20, 60, 60);

     RenderPass::Id rootSmallerPassId(2, 0);
     TestRenderPass* rootSmallerPass = addRenderPass(renderPasses, rootSmallerPassId, viewportRect, gfx::Transform());
     addQuad(rootSmallerPass, smallerRect, SK_ColorMAGENTA);

     list.push_back(rootSmallerPass);
     hashmap.set(rootSmallerPassId, renderPasses.take(0));

     renderer()->decideRenderPassAllocationsForFrame(list);
     renderer()->drawFrame(list, hashmap);
     renderer()->getFramebufferPixels(pixels.get(), viewportRect);

     // If we didn't clear, the borders should still be green.
     EXPECT_EQ(SK_ColorGREEN, pixels[0]);
     EXPECT_EQ(SK_ColorGREEN, pixels[viewportPixels - 1]);

     EXPECT_EQ(SK_ColorMAGENTA, pixels[smallerRect.y() * viewportRect.width() + smallerRect.x()]);
     EXPECT_EQ(SK_ColorMAGENTA, pixels[(smallerRect.bottom() - 1) * viewportRect.width() + smallerRect.right() - 1]);
 }

 }  // namespace
 }  // namespace 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/software_renderer.h"

	#include "cc/compositor_frame_metadata.h"
	#include "cc/quad_sink.h"
	#include "cc/render_pass.h"
	#include "cc/render_pass_draw_quad.h"
	#include "cc/solid_color_draw_quad.h"
	#include "cc/test/animation_test_common.h"
	#include "cc/test/fake_output_surface.h"
	#include "cc/test/fake_software_output_device.h"
	#include "cc/test/geometry_test_utils.h"
	#include "cc/test/render_pass_test_common.h"
	#include "cc/test/render_pass_test_utils.h"
	#include "cc/tile_draw_quad.h"
	#include "testing/gmock/include/gmock/gmock.h"
	#include "testing/gtest/include/gtest/gtest.h"

	using namespace WebKit;

	namespace cc {
	namespace {

	class SoftwareRendererTest : public testing::Test, public RendererClient {
	public:
	SoftwareRendererTest()
	: m_shouldClearRootRenderPass(true)
	{
	}

	void initializeRenderer() {
	m_outputSurface = FakeOutputSurface::CreateSoftware(scoped_ptr<SoftwareOutputDevice>(new FakeSoftwareOutputDevice));
	m_resourceProvider = ResourceProvider::create(m_outputSurface.get());
	m_renderer = SoftwareRenderer::create(this, resourceProvider(), softwareDevice());
	}

	SoftwareOutputDevice* softwareDevice() const { return m_outputSurface->SoftwareDevice(); }
	FakeOutputSurface* outputSurface() const { return m_outputSurface.get(); }
	ResourceProvider* resourceProvider() const { return m_resourceProvider.get(); }
	SoftwareRenderer* renderer() const { return m_renderer.get(); }
	void setViewportSize(const gfx::Size& viewportSize) { m_viewportSize = viewportSize; }
	void setShouldClearRootRenderPass(bool clearRootRenderPass) { m_shouldClearRootRenderPass = clearRootRenderPass; }

	// RendererClient implementation.
	virtual const gfx::Size& deviceViewportSize() const OVERRIDE { return m_viewportSize; }
	virtual const LayerTreeSettings& settings() const OVERRIDE { return m_settings; }
	virtual void didLoseOutputSurface() OVERRIDE { }
	virtual void onSwapBuffersComplete() OVERRIDE { }
	virtual void setFullRootLayerDamage() OVERRIDE { }
	virtual void setManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { };
	virtual void enforceManagedMemoryPolicy(const ManagedMemoryPolicy& policy) OVERRIDE { };
	virtual bool hasImplThread() const OVERRIDE { return false; }
	virtual bool shouldClearRootRenderPass() const OVERRIDE { return m_shouldClearRootRenderPass; }
	virtual CompositorFrameMetadata makeCompositorFrameMetadata() const
	OVERRIDE { return CompositorFrameMetadata(); }

	protected:
	scoped_ptr<FakeOutputSurface> m_outputSurface;
	scoped_ptr<ResourceProvider> m_resourceProvider;
	scoped_ptr<SoftwareRenderer> m_renderer;
	gfx::Size m_viewportSize;
	LayerTreeSettings m_settings;
	bool m_shouldClearRootRenderPass;
	};

	TEST_F(SoftwareRendererTest, solidColorQuad)
	{
	gfx::Size outerSize(100, 100);
	int outerPixels = outerSize.width() * outerSize.height();
	gfx::Size innerSize(98, 98);
	gfx::Rect outerRect(gfx::Point(), outerSize);
	gfx::Rect innerRect(gfx::Point(1, 1), innerSize);
	setViewportSize(outerSize);

	initializeRenderer();

	scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
	sharedQuadState->SetAll(gfx::Transform(), outerRect, outerRect, outerRect, false, 1.0);
	RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
	scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::Create();
	rootRenderPass->SetNew(rootRenderPassId, outerRect, gfx::Rect(), gfx::Transform());
	scoped_ptr<SolidColorDrawQuad> outerQuad = SolidColorDrawQuad::Create();
	outerQuad->SetNew(sharedQuadState.get(), outerRect, SK_ColorYELLOW);
	scoped_ptr<SolidColorDrawQuad> innerQuad = SolidColorDrawQuad::Create();
	innerQuad->SetNew(sharedQuadState.get(), innerRect, SK_ColorCYAN);
	rootRenderPass->AppendQuad(innerQuad.PassAs<DrawQuad>());
	rootRenderPass->AppendQuad(outerQuad.PassAs<DrawQuad>());

	RenderPassList list;
	RenderPassIdHashMap hashmap;
	list.push_back(rootRenderPass.get());
	hashmap.add(rootRenderPassId, rootRenderPass.PassAs<RenderPass>());
	renderer()->drawFrame(list, hashmap);

	scoped_array<SkColor> pixels(new SkColor[deviceViewportSize().width() * deviceViewportSize().height()]);
	renderer()->getFramebufferPixels(pixels.get(), outerRect);

	// FIXME: This fails on Android. Endianness maybe?
	// Yellow: expects 0xFFFFFF00, was 0xFF00FFFF on android.
	// Cyan: expects 0xFF00FFFF, was 0xFFFFFF00 on android.
	// http://crbug.com/154528
	#ifndef OS_ANDROID
	EXPECT_EQ(SK_ColorYELLOW, pixels[0]);
	EXPECT_EQ(SK_ColorYELLOW, pixels[outerPixels - 1]);
	EXPECT_EQ(SK_ColorCYAN, pixels[outerSize.width() + 1]);
	EXPECT_EQ(SK_ColorCYAN, pixels[outerPixels - outerSize.width() - 2]);
	#endif
	}

	TEST_F(SoftwareRendererTest, tileQuad)
	{
	gfx::Size outerSize(100, 100);
	int outerPixels = outerSize.width() * outerSize.height();
	gfx::Size innerSize(98, 98);
	int innerPixels = innerSize.width() * innerSize.height();
	gfx::Rect outerRect(gfx::Point(), outerSize);
	gfx::Rect innerRect(gfx::Point(1, 1), innerSize);
	setViewportSize(outerSize);
	initializeRenderer();

	ResourceProvider::ResourceId resourceYellow = resourceProvider()->createResource(outerSize, GL_RGBA, ResourceProvider::TextureUsageAny);
	ResourceProvider::ResourceId resourceCyan = resourceProvider()->createResource(innerSize, GL_RGBA, ResourceProvider::TextureUsageAny);

	SkColor yellow = SK_ColorYELLOW;
	SkColor cyan = SK_ColorCYAN;
	scoped_array<SkColor> yellowPixels(new SkColor[outerPixels]);
	scoped_array<SkColor> cyanPixels(new SkColor[innerPixels]);
	for (int i = 0; i < outerPixels; i++)
	yellowPixels[i] = yellow;
	for (int i = 0; i < innerPixels; i++)
	cyanPixels[i] = cyan;

	resourceProvider()->setPixels(resourceYellow, reinterpret_cast<uint8_t*>(yellowPixels.get()), gfx::Rect(gfx::Point(), outerSize), gfx::Rect(gfx::Point(), outerSize), gfx::Vector2d());
	resourceProvider()->setPixels(resourceCyan, reinterpret_cast<uint8_t*>(cyanPixels.get()), gfx::Rect(gfx::Point(), innerSize), gfx::Rect(gfx::Point(), innerSize), gfx::Vector2d());

	gfx::Rect rect = gfx::Rect(gfx::Point(), deviceViewportSize());

	scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::Create();
	sharedQuadState->SetAll(gfx::Transform(), outerRect, outerRect, outerRect, false, 1.0);
	RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
	scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::Create();
	rootRenderPass->SetNew(rootRenderPassId, gfx::Rect(gfx::Point(), deviceViewportSize()), gfx::Rect(), gfx::Transform());
	scoped_ptr<TileDrawQuad> outerQuad = TileDrawQuad::Create();
	outerQuad->SetNew(sharedQuadState.get(), outerRect, outerRect, resourceYellow, gfx::RectF(gfx::PointF(), outerSize), outerSize, false, false, false, false, false);
	scoped_ptr<TileDrawQuad> innerQuad = TileDrawQuad::Create();
	innerQuad->SetNew(sharedQuadState.get(), innerRect, innerRect, resourceCyan, gfx::RectF(gfx::PointF(), innerSize), innerSize, false, false, false, false, false);
	rootRenderPass->AppendQuad(innerQuad.PassAs<DrawQuad>());
	rootRenderPass->AppendQuad(outerQuad.PassAs<DrawQuad>());

	RenderPassList list;
	RenderPassIdHashMap hashmap;
	list.push_back(rootRenderPass.get());
	hashmap.add(rootRenderPassId, rootRenderPass.PassAs<RenderPass>());
	renderer()->drawFrame(list, hashmap);

	scoped_array<SkColor> pixels(new SkColor[deviceViewportSize().width() * deviceViewportSize().height()]);
	renderer()->getFramebufferPixels(pixels.get(), outerRect);

	EXPECT_EQ(SK_ColorYELLOW, pixels[0]);
	EXPECT_EQ(SK_ColorYELLOW, pixels[outerPixels - 1]);
	EXPECT_EQ(SK_ColorCYAN, pixels[outerSize.width() + 1]);
	EXPECT_EQ(SK_ColorCYAN, pixels[outerPixels - outerSize.width() - 2]);
	}

	TEST_F(SoftwareRendererTest, shouldClearRootRenderPass)
	{
	gfx::Rect viewportRect(gfx::Size(100, 100));
	size_t viewportPixels = viewportRect.width() * viewportRect.height();
	setViewportSize(viewportRect.size());
	setShouldClearRootRenderPass(false);
	initializeRenderer();

	RenderPassList list;
	RenderPassIdHashMap hashmap;
	ScopedPtrVector<RenderPass> renderPasses;
	scoped_array<SkColor> pixels(new SkColor[viewportPixels]);

	// Draw a fullscreen green quad in a first frame.
	RenderPass::Id rootClearPassId(1, 0);
	TestRenderPass* rootClearPass = addRenderPass(renderPasses, rootClearPassId, viewportRect, gfx::Transform());
	addQuad(rootClearPass, viewportRect, SK_ColorGREEN);

	list.push_back(rootClearPass);
	hashmap.set(rootClearPassId, renderPasses.take(0));

	renderer()->decideRenderPassAllocationsForFrame(list);
	renderer()->drawFrame(list, hashmap);
	renderer()->getFramebufferPixels(pixels.get(), viewportRect);

	EXPECT_EQ(SK_ColorGREEN, pixels[0]);
	EXPECT_EQ(SK_ColorGREEN, pixels[viewportPixels - 1]);

	renderPasses.clear();
	hashmap.clear();
	list.clear();

	// Draw a smaller magenta rect without filling the viewport in a separate frame.
	gfx::Rect smallerRect(20, 20, 60, 60);

	RenderPass::Id rootSmallerPassId(2, 0);
	TestRenderPass* rootSmallerPass = addRenderPass(renderPasses, rootSmallerPassId, viewportRect, gfx::Transform());
	addQuad(rootSmallerPass, smallerRect, SK_ColorMAGENTA);

	list.push_back(rootSmallerPass);
	hashmap.set(rootSmallerPassId, renderPasses.take(0));

	renderer()->decideRenderPassAllocationsForFrame(list);
	renderer()->drawFrame(list, hashmap);
	renderer()->getFramebufferPixels(pixels.get(), viewportRect);

	// If we didn't clear, the borders should still be green.
	EXPECT_EQ(SK_ColorGREEN, pixels[0]);
	EXPECT_EQ(SK_ColorGREEN, pixels[viewportPixels - 1]);

	EXPECT_EQ(SK_ColorMAGENTA, pixels[smallerRect.y() * viewportRect.width() + smallerRect.x()]);
	EXPECT_EQ(SK_ColorMAGENTA, pixels[(smallerRect.bottom() - 1) * viewportRect.width() + smallerRect.right() - 1]);
	}

	} // namespace
	} // namespace cc