src/cobalt/renderer/rasterizer/blitter/surface_cache_delegate.cc - cobalt - Git at Google

 /*
  * Copyright 2016 Google Inc. 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 "cobalt/renderer/rasterizer/blitter/surface_cache_delegate.h"

 #include <string>

 #include "base/debug/trace_event.h"
 #include "cobalt/base/polymorphic_downcast.h"
 #include "cobalt/math/transform_2d.h"
 #include "cobalt/math/vector2d_f.h"
 #include "cobalt/math/vector3d_f.h"
 #include "cobalt/renderer/rasterizer/blitter/cobalt_blitter_conversions.h"
 #include "cobalt/renderer/rasterizer/skia/cobalt_skia_type_conversions.h"
 #include "starboard/blitter.h"

 #if SB_HAS(BLITTER)

 namespace cobalt {
 namespace renderer {
 namespace rasterizer {
 namespace blitter {

 SurfaceCacheDelegate::SurfaceCacheDelegate(SbBlitterDevice device,
                                            SbBlitterContext context)
     : device_(device),
       context_(context)
 #if defined(ENABLE_DEBUG_CONSOLE)
       ,
       toggle_cache_highlights_(false),
       toggle_cache_highlights_command_handler_(
           "toggle_cache_highlights",
           base::Bind(&SurfaceCacheDelegate::OnToggleCacheHighlights,
                      base::Unretained(this)),
           "Toggles cache highlights showing render tree nodes that are cached.",
           "Will replace render tree node images with translucent red "
           "rectangles so that cached nodes can be visualized on screen.")
 #endif
 {
 }

 #if defined(ENABLE_DEBUG_CONSOLE)
 void SurfaceCacheDelegate::OnToggleCacheHighlights(const std::string& message) {
   toggle_cache_highlights_ = !toggle_cache_highlights_;
 }
 #endif

 void SurfaceCacheDelegate::ApplySurface(
     common::SurfaceCache::CachedSurface* surface) {
   TRACE_EVENT0("cobalt::renderer", "SurfaceCacheDelegate::ApplySurface()");
   CachedSurface* blitter_surface =
       base::polymorphic_downcast<CachedSurface*>(surface);

   if (!SbBlitterIsSurfaceValid(blitter_surface->surface())) {
     return;
   }

   // First, post-apply our scale to our current transform.
   Transform apply_transform(render_state_->transform);
   apply_transform.ApplyScale(blitter_surface->output_post_scale());
   math::RectF output_rectf =
       apply_transform.TransformRect(blitter_surface->output_bounds());
   // We can simulate a "pre-multiply" by translation by offsetting the final
   // output rectangle by the pre-translate, effectively resulting in the
   // translation being applied last, as intended.
   output_rectf.Offset(blitter_surface->output_pre_translate());
   SbBlitterRect output_blitter_rect = RectFToBlitterRect(output_rectf);

 #if defined(ENABLE_DEBUG_CONSOLE)
   if (toggle_cache_highlights_) {
     SbBlitterSetColor(context_, SbBlitterColorFromRGBA(255, 128, 128, 128));
     SbBlitterSetBlending(context_, true);
     SbBlitterFillRect(context_, output_blitter_rect);
   } else  // NOLINT(readability/braces)
 #endif
   {
     // Render the cached surface to the output render target.
     SbBlitterSetBlending(context_, true);
     SbBlitterSetModulateBlitsWithColor(context_, false);
     SbBlitterBlitRectToRect(
         context_, blitter_surface->surface(),
         SbBlitterMakeRect(0, 0, blitter_surface->output_bounds().width(),
                           blitter_surface->output_bounds().height()),
         output_blitter_rect);
   }
 }

 void SurfaceCacheDelegate::StartRecording(const math::RectF& local_bounds) {
   TRACE_EVENT0("cobalt::renderer", "SurfaceCacheDelegate::StartRecording()");
   DCHECK(!recording_data_);

   // If the scale is less than one, render to the offscreen surface as if the
   // scale is 1, since the scale may be animating and this way we do not need
   // to rerender the subtree each frame of the animation.  If the scale is
   // larger than 1, we cache it as is and if it is animating, performance will
   // suffer.
   math::Vector2dF scale = render_state_->transform.scale();
   math::Vector2dF inv_scale(scale.x() < 1.0f ? 1.0f / scale.x() : 1.0f,
                             scale.y() < 1.0f ? 1.0f / scale.y() : 1.0f);
   Transform inv_scale_transform(render_state_->transform);
   inv_scale_transform.ApplyScale(inv_scale);

   // Figure where we should render to the offscreen surface and then how to map
   // that later to the onscreen surface when applying the cached surface.  We
   // ignore the viewport so that we cache all of partially on-screen surfaces.
   common::OffscreenRenderCoordinateMapping coord_mapping =
       common::GetOffscreenRenderCoordinateMapping(
           local_bounds, inv_scale_transform.ToMatrix(),
           base::optional<math::Rect>());

   // If the output has an area of 0 then there is nothing to cache.  This should
   // not be common.
   if (coord_mapping.output_bounds.size().GetArea() == 0) {
     recording_data_.emplace(*render_state_, coord_mapping,
                             kSbBlitterInvalidSurface);
     return;
   }

   // Now create a surface and set it up as the new render target for our client
   // to target.
   SbBlitterSurface surface = SbBlitterCreateRenderTargetSurface(
       device_, coord_mapping.output_bounds.width(),
       coord_mapping.output_bounds.height(), kSbBlitterSurfaceFormatRGBA8);
   CHECK(SbBlitterIsSurfaceValid(surface));

   // Setup our offscreen surface as the render target for use while recording.
   SbBlitterRenderTarget offscreen_render_target =
       SbBlitterGetRenderTargetFromSurface(surface);
   CHECK(SbBlitterIsRenderTargetValid(offscreen_render_target));

   recording_data_.emplace(*render_state_, coord_mapping, surface);

   // Set our new render state to the recording render state.
   render_state_ = set_render_state_function_.Run(RenderState(
       offscreen_render_target, Transform(coord_mapping.sub_render_transform),
       BoundsStack(context_, math::Rect(coord_mapping.output_bounds.size()))));
   SbBlitterSetRenderTarget(context_, render_state_->render_target);
   render_state_->bounds_stack.UpdateContext();

   // Clear the draw area to RGBA(0, 0, 0, 0) for a fresh scratch surface before
   // returning.
   SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, 0, 0, 0));
   SbBlitterSetBlending(context_, false);
   SbBlitterFillRect(context_,
                     SbBlitterMakeRect(0, 0, coord_mapping.output_bounds.width(),
                                       coord_mapping.output_bounds.height()));
 }

 common::SurfaceCache::CachedSurface* SurfaceCacheDelegate::EndRecording() {
   TRACE_EVENT0("cobalt::renderer", "SurfaceCacheDelegate::EndRecording()");
   DCHECK(recording_data_);

   // Restore our original render state from before we started recording.
   render_state_ =
       set_render_state_function_.Run(recording_data_->original_render_state);
   SbBlitterSetRenderTarget(context_, render_state_->render_target);
   render_state_->bounds_stack.UpdateContext();

   // Save the results as a CachedSurface and return them.
   CachedSurface* cached_surface =
       new CachedSurface(recording_data_->surface,
                         recording_data_->coord_mapping.output_post_scale,
                         recording_data_->coord_mapping.output_pre_translate,
                         recording_data_->coord_mapping.output_bounds);

   recording_data_ = base::nullopt;

   return cached_surface;
 }

 void SurfaceCacheDelegate::ReleaseSurface(
     common::SurfaceCache::CachedSurface* surface) {
   TRACE_EVENT0("cobalt::renderer", "SurfaceCacheDelegate::ReleaseSurface()");
   delete surface;
 }

 math::Size SurfaceCacheDelegate::GetRenderSize(const math::SizeF& local_size) {
   math::Size size(
       static_cast<int>(
           local_size.width() * render_state_->transform.scale().x() + 0.5f),
       static_cast<int>(
           local_size.height() * render_state_->transform.scale().y() + 0.5f));
   return size;
 }

 math::Size SurfaceCacheDelegate::MaximumSurfaceSize() {
   // The Blitter API does not have methods for determining the maximum surface
   // size.
   return math::Size(2048, 2048);
 }

 }  // namespace blitter
 }  // namespace rasterizer
 }  // namespace renderer
 }  // namespace cobalt

 #endif  // #if SB_HAS(BLITTER)
	/*
	* Copyright 2016 Google Inc. 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 "cobalt/renderer/rasterizer/blitter/surface_cache_delegate.h"

	#include <string>

	#include "base/debug/trace_event.h"
	#include "cobalt/base/polymorphic_downcast.h"
	#include "cobalt/math/transform_2d.h"
	#include "cobalt/math/vector2d_f.h"
	#include "cobalt/math/vector3d_f.h"
	#include "cobalt/renderer/rasterizer/blitter/cobalt_blitter_conversions.h"
	#include "cobalt/renderer/rasterizer/skia/cobalt_skia_type_conversions.h"
	#include "starboard/blitter.h"

	#if SB_HAS(BLITTER)

	namespace cobalt {
	namespace renderer {
	namespace rasterizer {
	namespace blitter {

	SurfaceCacheDelegate::SurfaceCacheDelegate(SbBlitterDevice device,
	SbBlitterContext context)
	: device_(device),
	context_(context)
	#if defined(ENABLE_DEBUG_CONSOLE)
	,
	toggle_cache_highlights_(false),
	toggle_cache_highlights_command_handler_(
	"toggle_cache_highlights",
	base::Bind(&SurfaceCacheDelegate::OnToggleCacheHighlights,
	base::Unretained(this)),
	"Toggles cache highlights showing render tree nodes that are cached.",
	"Will replace render tree node images with translucent red "
	"rectangles so that cached nodes can be visualized on screen.")
	#endif
	{
	}

	#if defined(ENABLE_DEBUG_CONSOLE)
	void SurfaceCacheDelegate::OnToggleCacheHighlights(const std::string& message) {
	toggle_cache_highlights_ = !toggle_cache_highlights_;
	}
	#endif

	void SurfaceCacheDelegate::ApplySurface(
	common::SurfaceCache::CachedSurface* surface) {
	TRACE_EVENT0("cobalt::renderer", "SurfaceCacheDelegate::ApplySurface()");
	CachedSurface* blitter_surface =
	base::polymorphic_downcast<CachedSurface*>(surface);

	if (!SbBlitterIsSurfaceValid(blitter_surface->surface())) {
	return;
	}

	// First, post-apply our scale to our current transform.
	Transform apply_transform(render_state_->transform);
	apply_transform.ApplyScale(blitter_surface->output_post_scale());
	math::RectF output_rectf =
	apply_transform.TransformRect(blitter_surface->output_bounds());
	// We can simulate a "pre-multiply" by translation by offsetting the final
	// output rectangle by the pre-translate, effectively resulting in the
	// translation being applied last, as intended.
	output_rectf.Offset(blitter_surface->output_pre_translate());
	SbBlitterRect output_blitter_rect = RectFToBlitterRect(output_rectf);

	#if defined(ENABLE_DEBUG_CONSOLE)
	if (toggle_cache_highlights_) {
	SbBlitterSetColor(context_, SbBlitterColorFromRGBA(255, 128, 128, 128));
	SbBlitterSetBlending(context_, true);
	SbBlitterFillRect(context_, output_blitter_rect);
	} else // NOLINT(readability/braces)
	#endif
	{
	// Render the cached surface to the output render target.
	SbBlitterSetBlending(context_, true);
	SbBlitterSetModulateBlitsWithColor(context_, false);
	SbBlitterBlitRectToRect(
	context_, blitter_surface->surface(),
	SbBlitterMakeRect(0, 0, blitter_surface->output_bounds().width(),
	blitter_surface->output_bounds().height()),
	output_blitter_rect);
	}
	}

	void SurfaceCacheDelegate::StartRecording(const math::RectF& local_bounds) {
	TRACE_EVENT0("cobalt::renderer", "SurfaceCacheDelegate::StartRecording()");
	DCHECK(!recording_data_);

	// If the scale is less than one, render to the offscreen surface as if the
	// scale is 1, since the scale may be animating and this way we do not need
	// to rerender the subtree each frame of the animation. If the scale is
	// larger than 1, we cache it as is and if it is animating, performance will
	// suffer.
	math::Vector2dF scale = render_state_->transform.scale();
	math::Vector2dF inv_scale(scale.x() < 1.0f ? 1.0f / scale.x() : 1.0f,
	scale.y() < 1.0f ? 1.0f / scale.y() : 1.0f);
	Transform inv_scale_transform(render_state_->transform);
	inv_scale_transform.ApplyScale(inv_scale);

	// Figure where we should render to the offscreen surface and then how to map
	// that later to the onscreen surface when applying the cached surface. We
	// ignore the viewport so that we cache all of partially on-screen surfaces.
	common::OffscreenRenderCoordinateMapping coord_mapping =
	common::GetOffscreenRenderCoordinateMapping(
	local_bounds, inv_scale_transform.ToMatrix(),
	base::optional<math::Rect>());

	// If the output has an area of 0 then there is nothing to cache. This should
	// not be common.
	if (coord_mapping.output_bounds.size().GetArea() == 0) {
	recording_data_.emplace(*render_state_, coord_mapping,
	kSbBlitterInvalidSurface);
	return;
	}

	// Now create a surface and set it up as the new render target for our client
	// to target.
	SbBlitterSurface surface = SbBlitterCreateRenderTargetSurface(
	device_, coord_mapping.output_bounds.width(),
	coord_mapping.output_bounds.height(), kSbBlitterSurfaceFormatRGBA8);
	CHECK(SbBlitterIsSurfaceValid(surface));

	// Setup our offscreen surface as the render target for use while recording.
	SbBlitterRenderTarget offscreen_render_target =
	SbBlitterGetRenderTargetFromSurface(surface);
	CHECK(SbBlitterIsRenderTargetValid(offscreen_render_target));

	recording_data_.emplace(*render_state_, coord_mapping, surface);

	// Set our new render state to the recording render state.
	render_state_ = set_render_state_function_.Run(RenderState(
	offscreen_render_target, Transform(coord_mapping.sub_render_transform),
	BoundsStack(context_, math::Rect(coord_mapping.output_bounds.size()))));
	SbBlitterSetRenderTarget(context_, render_state_->render_target);
	render_state_->bounds_stack.UpdateContext();

	// Clear the draw area to RGBA(0, 0, 0, 0) for a fresh scratch surface before
	// returning.
	SbBlitterSetColor(context_, SbBlitterColorFromRGBA(0, 0, 0, 0));
	SbBlitterSetBlending(context_, false);
	SbBlitterFillRect(context_,
	SbBlitterMakeRect(0, 0, coord_mapping.output_bounds.width(),
	coord_mapping.output_bounds.height()));
	}

	common::SurfaceCache::CachedSurface* SurfaceCacheDelegate::EndRecording() {
	TRACE_EVENT0("cobalt::renderer", "SurfaceCacheDelegate::EndRecording()");
	DCHECK(recording_data_);

	// Restore our original render state from before we started recording.
	render_state_ =
	set_render_state_function_.Run(recording_data_->original_render_state);
	SbBlitterSetRenderTarget(context_, render_state_->render_target);
	render_state_->bounds_stack.UpdateContext();

	// Save the results as a CachedSurface and return them.
	CachedSurface* cached_surface =
	new CachedSurface(recording_data_->surface,
	recording_data_->coord_mapping.output_post_scale,
	recording_data_->coord_mapping.output_pre_translate,
	recording_data_->coord_mapping.output_bounds);

	recording_data_ = base::nullopt;

	return cached_surface;
	}

	void SurfaceCacheDelegate::ReleaseSurface(
	common::SurfaceCache::CachedSurface* surface) {
	TRACE_EVENT0("cobalt::renderer", "SurfaceCacheDelegate::ReleaseSurface()");
	delete surface;
	}

	math::Size SurfaceCacheDelegate::GetRenderSize(const math::SizeF& local_size) {
	math::Size size(
	static_cast<int>(
	local_size.width() * render_state_->transform.scale().x() + 0.5f),
	static_cast<int>(
	local_size.height() * render_state_->transform.scale().y() + 0.5f));
	return size;
	}

	math::Size SurfaceCacheDelegate::MaximumSurfaceSize() {
	// The Blitter API does not have methods for determining the maximum surface
	// size.
	return math::Size(2048, 2048);
	}

	} // namespace blitter
	} // namespace rasterizer
	} // namespace renderer
	} // namespace cobalt

	#endif // #if SB_HAS(BLITTER)