src/starboard/examples/blitter/main.cc - cobalt - Git at Google

 // Copyright 2016 The Cobalt Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "starboard/blitter.h"
 #include "starboard/event.h"
 #include "starboard/log.h"
 #include "starboard/system.h"
 #include "starboard/thread.h"
 #include "starboard/time.h"
 #include "starboard/window.h"

 #if SB_HAS(BLITTER)

 class Application {
  public:
   Application();
   ~Application();

  private:
   // The callback function passed to SbEventSchedule().  Its purpose is to
   // forward to the non-static RenderScene() method.
   static void RenderSceneEventCallback(void* param);

   // Renders one frame of the animated scene, incrementing |frame_| each time
   // it is called.
   void RenderScene();

   static Application* application_;

   // The current frame we are rendering, initialized to 0 and incremented after
   // each frame.
   int frame_;

   // The SbWindow within which we will perform our rendering.
   SbWindow window_;

   // The blitting device we will be targeting.
   SbBlitterDevice device_;

   // The swap chain that represents |window_|'s display.
   SbBlitterSwapChain swap_chain_;
   static const int kOutputWidth = 1920;
   static const int kOutputHeight = 1080;

   // The surface of a simple unchanging RGBA bitmap image we will use while
   // rendering.
   SbBlitterSurface rgba_image_surface_;
   // The surface of a simple unchanging alpha-only bitmap image we will use
   // while rendering.
   SbBlitterSurface alpha_image_surface_;
   static const int kImageWidth = 100;
   static const int kImageHeight = 100;

   // An offscreen surface that we will render to and render from each frame.
   SbBlitterSurface offscreen_surface_;
   static const int kOffscreenWidth = 400;
   static const int kOffscreenHeight = 400;

   // The context within which we will issue all our draw commands.
   SbBlitterContext context_;
 };

 namespace {
 // Populates a region of memory designated as pixel data with a gradient texture
 // that includes transparent alpha.
 void FillGradientImageData(int width,
                            int height,
                            int pitch_in_bytes,
                            void* pixel_data) {
   uint8_t* pixels = static_cast<uint8_t*>(pixel_data);

   for (int y = 0; y < height; ++y) {
     for (int x = 0; x < width; ++x) {
       // Setup a vertical gradient in the alpha color channel.
       float alpha = static_cast<float>(y) / height;
       uint8_t alpha_byte = static_cast<uint8_t>(alpha) * 255;

       // Setup a horizontal gradient in the green color channel.
       uint8_t green_byte =
           static_cast<uint8_t>((alpha * static_cast<float>(x) / width) * 255);

       // Assuming BGRA color format.
       pixels[x * 4 + 0] = 0;
       pixels[x * 4 + 1] = green_byte;
       pixels[x * 4 + 0] = 0;
       pixels[x * 4 + 3] = alpha_byte;
     }

     pixels += pitch_in_bytes;
   }
 }

 // Populates a region of memory designated as pixel data with a checker texture
 // using an alpha-only pixel format.
 void FillAlphaCheckerImageData(int width,
                                int height,
                                int pitch,
                                void* pixel_data) {
   uint8_t* pixels = static_cast<uint8_t*>(pixel_data);

   for (int y = 0; y < height; ++y) {
     for (int x = 0; x < width; ++x) {
       bool is_first_vertical_half = y <= height / 2;
       bool is_first_horizontal_half = x <= width / 2;

       uint8_t color =
           is_first_horizontal_half ^ is_first_vertical_half ? 255 : 0;

       pixels[x + y * pitch] = color;
     }
   }
 }
 }  // namespace

 Application::Application() {
   frame_ = 0;
   // In order to access most of the Blitter API, we'll need to create a SbWindow
   // object whose display we can have the Blitter API target.
   SbWindowOptions options;
   SbWindowSetDefaultOptions(&options);
   options.size.width = 1920;
   options.size.height = 1080;
   window_ = SbWindowCreate(NULL);
   SB_CHECK(SbWindowIsValid(window_));

   // We start by constructing a SbBlitterDevice which represents the connection
   // to the hardware blitting device (e.g. a GPU).
   device_ = SbBlitterCreateDefaultDevice();

   // Creating the swap chain associates our blitting device to the target
   // window's output display.
   swap_chain_ = SbBlitterCreateSwapChainFromWindow(device_, window_);

   // Let's setup a texture.  We start by creating a SbBlitterPixelData object
   // which can be populated with pixel data by the CPU and then passed on to
   // the device for reference within blit calls.
   SbBlitterPixelData image_data = SbBlitterCreatePixelData(
       device_, kImageWidth, kImageHeight, kSbBlitterPixelDataFormatBGRA8);

   // Once our pixel data object is created, we can extract from it the image
   // data pitch as well as a CPU-accessible pointer to the pixel data.  We
   // pass this information into a function to populate the image.
   int image_data_pitch = SbBlitterGetPixelDataPitchInBytes(image_data);
   FillGradientImageData(kImageHeight, kImageHeight, image_data_pitch,
                         SbBlitterGetPixelDataPointer(image_data));

   // Now that our pixel data is finalized, we create a surface from it.  After
   // this call, our SbBlitterPixelData object is invalid (i.e. it is transformed
   // into a SbBlitterSurface object).
   rgba_image_surface_ =
       SbBlitterCreateSurfaceFromPixelData(device_, image_data);

   // Now setup our alpha-only image.
   SbBlitterPixelData alpha_image_data = SbBlitterCreatePixelData(
       device_, kImageWidth, kImageHeight, kSbBlitterPixelDataFormatA8);
   int alpha_image_data_pitch =
       SbBlitterGetPixelDataPitchInBytes(alpha_image_data);
   FillAlphaCheckerImageData(kImageHeight, kImageHeight, alpha_image_data_pitch,
                             SbBlitterGetPixelDataPointer(alpha_image_data));
   alpha_image_surface_ =
       SbBlitterCreateSurfaceFromPixelData(device_, alpha_image_data);

   // We will also create a (initially blank) surface for use as an offscreen
   // render target.
   offscreen_surface_ = SbBlitterCreateRenderTargetSurface(
       device_, kOffscreenWidth, kOffscreenHeight, kSbBlitterSurfaceFormatRGBA8);

   // Finally, in order to issue draw calls, we need a context that maintains
   // draw state for us.
   context_ = SbBlitterCreateContext(device_);

   RenderScene();
 }

 Application::~Application() {
   // Cleanup all used resources.
   SbBlitterDestroyContext(context_);
   SbBlitterDestroySurface(offscreen_surface_);
   SbBlitterDestroySurface(alpha_image_surface_);
   SbBlitterDestroySurface(rgba_image_surface_);
   SbBlitterDestroySwapChain(swap_chain_);
   SbBlitterDestroyDevice(device_);
   SbWindowDestroy(window_);
 }

 void Application::RenderSceneEventCallback(void* param) {
   // Forward the call to the application instance specified as the parameter.
   Application* application = static_cast<Application*>(param);
   application->RenderScene();
 }

 void Application::RenderScene() {
   // Setup our animation parameter that follows a sawtooth pattern.
   int frame_mod_255 = frame_ % 255;

   // We can get a render target from a swap chain, so that we can target the
   // display with draw calls.
   SbBlitterRenderTarget primary_render_target =
       SbBlitterGetRenderTargetFromSwapChain(swap_chain_);

   // Surfaces created for use as a render target provide both a
   // SbBlitterRenderTarget and SbBlitterTexture objects, for use as target and
   // source in draw calls, respectively.
   SbBlitterRenderTarget offscreen_render_target =
       SbBlitterGetRenderTargetFromSurface(offscreen_surface_);

   // First we set the render target to our offscreen surface.
   SbBlitterSetRenderTarget(context_, offscreen_render_target);

   // And enable alpha blending.
   SbBlitterSetBlending(context_, true);

   // We start by clearing our entire surface to a animating shade of red.
   SbBlitterSetColor(context_, SbBlitterColorFromRGBA(frame_mod_255, 0, 0, 255));
   SbBlitterFillRect(context_,
                     SbBlitterMakeRect(0, 0, kOffscreenWidth, kOffscreenHeight));
   // We then draw a green rectangle in the top left corner.
   SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, 255, 0, 32));
   SbBlitterFillRect(context_, SbBlitterMakeRect(50, 50, 100, 100));

   // Now we disable blending for the next few draw calls, resulting in their
   // alpha channels replacing the alpha channels that already exist in the
   // render target.
   SbBlitterSetBlending(context_, false);

   // Punch a blue half-transparent rectangle out in the top right corner.
   SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, 0, 255, 128));
   SbBlitterFillRect(context_, SbBlitterMakeRect(250, 50, 100, 100));

   // Render our surface to the offscreen surface as well, stretched
   // horizontally, in two different locations.
   SbBlitterSetBlending(context_, true);
   SbBlitterSetModulateBlitsWithColor(context_, false);
   SbBlitterBlitRectToRect(context_, rgba_image_surface_,
                           SbBlitterMakeRect(0, 0, kImageWidth, kImageHeight),
                           SbBlitterMakeRect(frame_mod_255, frame_mod_255,
                                             kImageWidth * 2, kImageHeight));

   SbBlitterSetModulateBlitsWithColor(context_, true);
   SbBlitterSetColor(context_, SbBlitterColorFromRGBA(255, 255, 255, 128));
   SbBlitterBlitRectToRect(context_, rgba_image_surface_,
                           SbBlitterMakeRect(0, 0, kImageWidth, kImageHeight),
                           SbBlitterMakeRect(frame_mod_255, frame_mod_255 + 100,
                                             kImageWidth * 2, kImageHeight));

   // Blit out our alpha checker surface in the color blue.
   SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, 0, 255, 255));
   SbBlitterBlitRectToRect(
       context_, alpha_image_surface_,
       SbBlitterMakeRect(0, 0, kImageWidth, kImageHeight),
       SbBlitterMakeRect(50, 200, kImageWidth, kImageHeight));

   // Now switch to the primary display render target.
   SbBlitterSetRenderTarget(context_, primary_render_target);

   // Clear the display to an animating shade of green.
   SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, frame_mod_255, 0, 255));
   SbBlitterFillRect(context_,
                     SbBlitterMakeRect(0, 0, kOutputWidth, kOutputHeight));

   // Render our offscreen surface to the display in three different places
   // and sizes.
   SbBlitterSetColor(context_,
                     SbBlitterColorFromRGBA(255, 255, 255, frame_mod_255));
   SbBlitterSetModulateBlitsWithColor(context_, true);
   SbBlitterBlitRectToRect(
       context_, offscreen_surface_,
       SbBlitterMakeRect(0, 0, kOffscreenWidth, kOffscreenHeight),
       SbBlitterMakeRect(10, 10, 200, 200));
   SbBlitterBlitRectToRect(
       context_, offscreen_surface_,
       SbBlitterMakeRect(0, 0, kOffscreenWidth, kOffscreenHeight),
       SbBlitterMakeRect(300, 10, 400, 400));
   SbBlitterBlitRectToRect(
       context_, offscreen_surface_,
       SbBlitterMakeRect(0, 0, kOffscreenWidth, kOffscreenHeight),
       SbBlitterMakeRect(10, 500, 800, 200));

   SbBlitterSetModulateBlitsWithColor(context_, false);

   // Blit an animated tiling of the offscreen surface.
   SbBlitterBlitRectToRectTiled(
       context_, offscreen_surface_,
       SbBlitterMakeRect(
           frame_mod_255 * 3, frame_mod_255 * 5,
           1 + static_cast<int>(kOffscreenWidth * (frame_mod_255 / 31.0f)),
           1 + static_cast<int>(kOffscreenWidth * (frame_mod_255 / 63.0f))),
       SbBlitterMakeRect(900, 100, 400, 400));

   // Blit a batch of 4 instances of the offscreen surface in one draw call.
   const int kNumBatchRects = 4;
   SbBlitterRect src_rects[kNumBatchRects];
   SbBlitterRect dst_rects[kNumBatchRects];
   for (int j = 0; j < kNumBatchRects; ++j) {
     src_rects[j].x = 0;
     src_rects[j].y = 0;
     src_rects[j].width = kOffscreenWidth;
     src_rects[j].height = kOffscreenHeight;

     dst_rects[j].x = 900 + j * 220;
     dst_rects[j].y = 600;
     dst_rects[j].width = 200;
     dst_rects[j].height = 300;
   }
   SbBlitterBlitRectsToRects(context_, offscreen_surface_, src_rects, dst_rects,
                             kNumBatchRects);

   // Ensure that all draw commands issued to the context are flushed to
   // the device and guaranteed to eventually be processed.
   SbBlitterFlushContext(context_);

   // Flip the swap chain to reveal our masterpiece to the user.
   SbBlitterFlipSwapChain(swap_chain_);
   ++frame_;

   // Schedule another frame render ASAP.
   SbEventSchedule(&Application::RenderSceneEventCallback, this, 0);
 }

 Application* s_application = NULL;

 // Simple Starboard window event handling to kick off our blitter application.
 void SbEventHandle(const SbEvent* event) {
   switch (event->type) {
     case kSbEventTypeStart: {
       // Create the application, after which it will use SbEventSchedule()
       // on itself to trigger a frame update until the application is
       // terminated.
       s_application = new Application();
     } break;

     case kSbEventTypeStop: {
       // Shutdown the application.
       delete s_application;
     } break;

     default: {}
   }
 }

 #else  // SB_HAS(BLITTER)

 void SbEventHandle(const SbEvent* event) {
   switch (event->type) {
     case kSbEventTypeStart: {
       SB_LOG(ERROR)
           << "Starboard Blitter API is not available on this platform.";

       SbSystemRequestStop(0);
     } break;

     default: {}
   }
 }

 #endif  // SB_HAS(BLITTER)
	// Copyright 2016 The Cobalt Authors. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "starboard/blitter.h"
	#include "starboard/event.h"
	#include "starboard/log.h"
	#include "starboard/system.h"
	#include "starboard/thread.h"
	#include "starboard/time.h"
	#include "starboard/window.h"

	#if SB_HAS(BLITTER)

	class Application {
	public:
	Application();
	~Application();

	private:
	// The callback function passed to SbEventSchedule(). Its purpose is to
	// forward to the non-static RenderScene() method.
	static void RenderSceneEventCallback(void* param);

	// Renders one frame of the animated scene, incrementing \|frame_\| each time
	// it is called.
	void RenderScene();

	static Application* application_;

	// The current frame we are rendering, initialized to 0 and incremented after
	// each frame.
	int frame_;

	// The SbWindow within which we will perform our rendering.
	SbWindow window_;

	// The blitting device we will be targeting.
	SbBlitterDevice device_;

	// The swap chain that represents \|window_\|'s display.
	SbBlitterSwapChain swap_chain_;
	static const int kOutputWidth = 1920;
	static const int kOutputHeight = 1080;

	// The surface of a simple unchanging RGBA bitmap image we will use while
	// rendering.
	SbBlitterSurface rgba_image_surface_;
	// The surface of a simple unchanging alpha-only bitmap image we will use
	// while rendering.
	SbBlitterSurface alpha_image_surface_;
	static const int kImageWidth = 100;
	static const int kImageHeight = 100;

	// An offscreen surface that we will render to and render from each frame.
	SbBlitterSurface offscreen_surface_;
	static const int kOffscreenWidth = 400;
	static const int kOffscreenHeight = 400;

	// The context within which we will issue all our draw commands.
	SbBlitterContext context_;
	};

	namespace {
	// Populates a region of memory designated as pixel data with a gradient texture
	// that includes transparent alpha.
	void FillGradientImageData(int width,
	int height,
	int pitch_in_bytes,
	void* pixel_data) {
	uint8_t* pixels = static_cast<uint8_t*>(pixel_data);

	for (int y = 0; y < height; ++y) {
	for (int x = 0; x < width; ++x) {
	// Setup a vertical gradient in the alpha color channel.
	float alpha = static_cast<float>(y) / height;
	uint8_t alpha_byte = static_cast<uint8_t>(alpha) * 255;

	// Setup a horizontal gradient in the green color channel.
	uint8_t green_byte =
	static_cast<uint8_t>((alpha * static_cast<float>(x) / width) * 255);

	// Assuming BGRA color format.
	pixels[x * 4 + 0] = 0;
	pixels[x * 4 + 1] = green_byte;
	pixels[x * 4 + 0] = 0;
	pixels[x * 4 + 3] = alpha_byte;
	}

	pixels += pitch_in_bytes;
	}
	}

	// Populates a region of memory designated as pixel data with a checker texture
	// using an alpha-only pixel format.
	void FillAlphaCheckerImageData(int width,
	int height,
	int pitch,
	void* pixel_data) {
	uint8_t* pixels = static_cast<uint8_t*>(pixel_data);

	for (int y = 0; y < height; ++y) {
	for (int x = 0; x < width; ++x) {
	bool is_first_vertical_half = y <= height / 2;
	bool is_first_horizontal_half = x <= width / 2;

	uint8_t color =
	is_first_horizontal_half ^ is_first_vertical_half ? 255 : 0;

	pixels[x + y * pitch] = color;
	}
	}
	}
	} // namespace

	Application::Application() {
	frame_ = 0;
	// In order to access most of the Blitter API, we'll need to create a SbWindow
	// object whose display we can have the Blitter API target.
	SbWindowOptions options;
	SbWindowSetDefaultOptions(&options);
	options.size.width = 1920;
	options.size.height = 1080;
	window_ = SbWindowCreate(NULL);
	SB_CHECK(SbWindowIsValid(window_));

	// We start by constructing a SbBlitterDevice which represents the connection
	// to the hardware blitting device (e.g. a GPU).
	device_ = SbBlitterCreateDefaultDevice();

	// Creating the swap chain associates our blitting device to the target
	// window's output display.
	swap_chain_ = SbBlitterCreateSwapChainFromWindow(device_, window_);

	// Let's setup a texture. We start by creating a SbBlitterPixelData object
	// which can be populated with pixel data by the CPU and then passed on to
	// the device for reference within blit calls.
	SbBlitterPixelData image_data = SbBlitterCreatePixelData(
	device_, kImageWidth, kImageHeight, kSbBlitterPixelDataFormatBGRA8);

	// Once our pixel data object is created, we can extract from it the image
	// data pitch as well as a CPU-accessible pointer to the pixel data. We
	// pass this information into a function to populate the image.
	int image_data_pitch = SbBlitterGetPixelDataPitchInBytes(image_data);
	FillGradientImageData(kImageHeight, kImageHeight, image_data_pitch,
	SbBlitterGetPixelDataPointer(image_data));

	// Now that our pixel data is finalized, we create a surface from it. After
	// this call, our SbBlitterPixelData object is invalid (i.e. it is transformed
	// into a SbBlitterSurface object).
	rgba_image_surface_ =
	SbBlitterCreateSurfaceFromPixelData(device_, image_data);

	// Now setup our alpha-only image.
	SbBlitterPixelData alpha_image_data = SbBlitterCreatePixelData(
	device_, kImageWidth, kImageHeight, kSbBlitterPixelDataFormatA8);
	int alpha_image_data_pitch =
	SbBlitterGetPixelDataPitchInBytes(alpha_image_data);
	FillAlphaCheckerImageData(kImageHeight, kImageHeight, alpha_image_data_pitch,
	SbBlitterGetPixelDataPointer(alpha_image_data));
	alpha_image_surface_ =
	SbBlitterCreateSurfaceFromPixelData(device_, alpha_image_data);

	// We will also create a (initially blank) surface for use as an offscreen
	// render target.
	offscreen_surface_ = SbBlitterCreateRenderTargetSurface(
	device_, kOffscreenWidth, kOffscreenHeight, kSbBlitterSurfaceFormatRGBA8);

	// Finally, in order to issue draw calls, we need a context that maintains
	// draw state for us.
	context_ = SbBlitterCreateContext(device_);

	RenderScene();
	}

	Application::~Application() {
	// Cleanup all used resources.
	SbBlitterDestroyContext(context_);
	SbBlitterDestroySurface(offscreen_surface_);
	SbBlitterDestroySurface(alpha_image_surface_);
	SbBlitterDestroySurface(rgba_image_surface_);
	SbBlitterDestroySwapChain(swap_chain_);
	SbBlitterDestroyDevice(device_);
	SbWindowDestroy(window_);
	}

	void Application::RenderSceneEventCallback(void* param) {
	// Forward the call to the application instance specified as the parameter.
	Application* application = static_cast<Application*>(param);
	application->RenderScene();
	}

	void Application::RenderScene() {
	// Setup our animation parameter that follows a sawtooth pattern.
	int frame_mod_255 = frame_ % 255;

	// We can get a render target from a swap chain, so that we can target the
	// display with draw calls.
	SbBlitterRenderTarget primary_render_target =
	SbBlitterGetRenderTargetFromSwapChain(swap_chain_);

	// Surfaces created for use as a render target provide both a
	// SbBlitterRenderTarget and SbBlitterTexture objects, for use as target and
	// source in draw calls, respectively.
	SbBlitterRenderTarget offscreen_render_target =
	SbBlitterGetRenderTargetFromSurface(offscreen_surface_);

	// First we set the render target to our offscreen surface.
	SbBlitterSetRenderTarget(context_, offscreen_render_target);

	// And enable alpha blending.
	SbBlitterSetBlending(context_, true);

	// We start by clearing our entire surface to a animating shade of red.
	SbBlitterSetColor(context_, SbBlitterColorFromRGBA(frame_mod_255, 0, 0, 255));
	SbBlitterFillRect(context_,
	SbBlitterMakeRect(0, 0, kOffscreenWidth, kOffscreenHeight));
	// We then draw a green rectangle in the top left corner.
	SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, 255, 0, 32));
	SbBlitterFillRect(context_, SbBlitterMakeRect(50, 50, 100, 100));

	// Now we disable blending for the next few draw calls, resulting in their
	// alpha channels replacing the alpha channels that already exist in the
	// render target.
	SbBlitterSetBlending(context_, false);

	// Punch a blue half-transparent rectangle out in the top right corner.
	SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, 0, 255, 128));
	SbBlitterFillRect(context_, SbBlitterMakeRect(250, 50, 100, 100));

	// Render our surface to the offscreen surface as well, stretched
	// horizontally, in two different locations.
	SbBlitterSetBlending(context_, true);
	SbBlitterSetModulateBlitsWithColor(context_, false);
	SbBlitterBlitRectToRect(context_, rgba_image_surface_,
	SbBlitterMakeRect(0, 0, kImageWidth, kImageHeight),
	SbBlitterMakeRect(frame_mod_255, frame_mod_255,
	kImageWidth * 2, kImageHeight));

	SbBlitterSetModulateBlitsWithColor(context_, true);
	SbBlitterSetColor(context_, SbBlitterColorFromRGBA(255, 255, 255, 128));
	SbBlitterBlitRectToRect(context_, rgba_image_surface_,
	SbBlitterMakeRect(0, 0, kImageWidth, kImageHeight),
	SbBlitterMakeRect(frame_mod_255, frame_mod_255 + 100,
	kImageWidth * 2, kImageHeight));

	// Blit out our alpha checker surface in the color blue.
	SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, 0, 255, 255));
	SbBlitterBlitRectToRect(
	context_, alpha_image_surface_,
	SbBlitterMakeRect(0, 0, kImageWidth, kImageHeight),
	SbBlitterMakeRect(50, 200, kImageWidth, kImageHeight));

	// Now switch to the primary display render target.
	SbBlitterSetRenderTarget(context_, primary_render_target);

	// Clear the display to an animating shade of green.
	SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, frame_mod_255, 0, 255));
	SbBlitterFillRect(context_,
	SbBlitterMakeRect(0, 0, kOutputWidth, kOutputHeight));

	// Render our offscreen surface to the display in three different places
	// and sizes.
	SbBlitterSetColor(context_,
	SbBlitterColorFromRGBA(255, 255, 255, frame_mod_255));
	SbBlitterSetModulateBlitsWithColor(context_, true);
	SbBlitterBlitRectToRect(
	context_, offscreen_surface_,
	SbBlitterMakeRect(0, 0, kOffscreenWidth, kOffscreenHeight),
	SbBlitterMakeRect(10, 10, 200, 200));
	SbBlitterBlitRectToRect(
	context_, offscreen_surface_,
	SbBlitterMakeRect(0, 0, kOffscreenWidth, kOffscreenHeight),
	SbBlitterMakeRect(300, 10, 400, 400));
	SbBlitterBlitRectToRect(
	context_, offscreen_surface_,
	SbBlitterMakeRect(0, 0, kOffscreenWidth, kOffscreenHeight),
	SbBlitterMakeRect(10, 500, 800, 200));

	SbBlitterSetModulateBlitsWithColor(context_, false);

	// Blit an animated tiling of the offscreen surface.
	SbBlitterBlitRectToRectTiled(
	context_, offscreen_surface_,
	SbBlitterMakeRect(
	frame_mod_255 * 3, frame_mod_255 * 5,
	1 + static_cast<int>(kOffscreenWidth * (frame_mod_255 / 31.0f)),
	1 + static_cast<int>(kOffscreenWidth * (frame_mod_255 / 63.0f))),
	SbBlitterMakeRect(900, 100, 400, 400));

	// Blit a batch of 4 instances of the offscreen surface in one draw call.
	const int kNumBatchRects = 4;
	SbBlitterRect src_rects[kNumBatchRects];
	SbBlitterRect dst_rects[kNumBatchRects];
	for (int j = 0; j < kNumBatchRects; ++j) {
	src_rects[j].x = 0;
	src_rects[j].y = 0;
	src_rects[j].width = kOffscreenWidth;
	src_rects[j].height = kOffscreenHeight;

	dst_rects[j].x = 900 + j * 220;
	dst_rects[j].y = 600;
	dst_rects[j].width = 200;
	dst_rects[j].height = 300;
	}
	SbBlitterBlitRectsToRects(context_, offscreen_surface_, src_rects, dst_rects,
	kNumBatchRects);

	// Ensure that all draw commands issued to the context are flushed to
	// the device and guaranteed to eventually be processed.
	SbBlitterFlushContext(context_);

	// Flip the swap chain to reveal our masterpiece to the user.
	SbBlitterFlipSwapChain(swap_chain_);
	++frame_;

	// Schedule another frame render ASAP.
	SbEventSchedule(&Application::RenderSceneEventCallback, this, 0);
	}

	Application* s_application = NULL;

	// Simple Starboard window event handling to kick off our blitter application.
	void SbEventHandle(const SbEvent* event) {
	switch (event->type) {
	case kSbEventTypeStart: {
	// Create the application, after which it will use SbEventSchedule()
	// on itself to trigger a frame update until the application is
	// terminated.
	s_application = new Application();
	} break;

	case kSbEventTypeStop: {
	// Shutdown the application.
	delete s_application;
	} break;

	default: {}
	}
	}

	#else // SB_HAS(BLITTER)

	void SbEventHandle(const SbEvent* event) {
	switch (event->type) {
	case kSbEventTypeStart: {
	SB_LOG(ERROR)
	<< "Starboard Blitter API is not available on this platform.";

	SbSystemRequestStop(0);
	} break;

	default: {}
	}
	}

	#endif // SB_HAS(BLITTER)