blob: 938a5cfd6c6a47dbcf949815f81016c6038a625d [file] [log] [blame]
/*
* 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.
*/
#ifndef COBALT_RENDERER_RASTERIZER_BLITTER_RENDER_TREE_NODE_VISITOR_H_
#define COBALT_RENDERER_RASTERIZER_BLITTER_RENDER_TREE_NODE_VISITOR_H_
#include <stack>
#include "base/callback.h"
#include "base/compiler_specific.h"
#include "base/optional.h"
#include "cobalt/math/rect.h"
#include "cobalt/render_tree/composition_node.h"
#include "cobalt/render_tree/filter_node.h"
#include "cobalt/render_tree/image_node.h"
#include "cobalt/render_tree/matrix_transform_node.h"
#include "cobalt/render_tree/node_visitor.h"
#include "cobalt/render_tree/punch_through_video_node.h"
#include "cobalt/render_tree/rect_node.h"
#include "cobalt/render_tree/rect_shadow_node.h"
#include "cobalt/render_tree/text_node.h"
#include "cobalt/renderer/rasterizer/blitter/cached_software_rasterizer.h"
#include "cobalt/renderer/rasterizer/blitter/render_state.h"
#include "cobalt/renderer/rasterizer/blitter/scratch_surface_cache.h"
#include "cobalt/renderer/rasterizer/blitter/surface_cache_delegate.h"
#include "cobalt/renderer/rasterizer/common/surface_cache.h"
#include "starboard/blitter.h"
#include "third_party/skia/include/core/SkImageInfo.h"
#ifndef SB_HAS_BLITTER
#define SB_HAS_BLITTER
#endif
#if SB_HAS(BLITTER)
namespace cobalt {
namespace render_tree {
namespace animations {
class AnimateNode;
} // namespace animations
} // namespace render_tree
namespace renderer {
namespace rasterizer {
namespace blitter {
// A Starboard Blitter API render tree node visitor. Will use the Blitter API
// to rasterize render tree nodes. If a render tree node expresses a visual
// element that the Blitter API is not capable of rendering, we will fallback
// to software rendering.
class RenderTreeNodeVisitor : public render_tree::NodeVisitor {
public:
RenderTreeNodeVisitor(SbBlitterDevice device, SbBlitterContext context,
const RenderState& render_state,
ScratchSurfaceCache* scratch_surface_cache,
SurfaceCacheDelegate* surface_cache_delegate,
common::SurfaceCache* surface_cache,
CachedSoftwareRasterizer* software_surface_cache);
void Visit(render_tree::animations::AnimateNode* animate_node) OVERRIDE {
NOTREACHED();
}
void Visit(render_tree::CompositionNode* composition_node) OVERRIDE;
void Visit(render_tree::FilterNode* filter_node) OVERRIDE;
void Visit(render_tree::ImageNode* image_node) OVERRIDE;
void Visit(render_tree::MatrixTransformNode* matrix_transform_node) OVERRIDE;
void Visit(
render_tree::PunchThroughVideoNode* punch_through_video_node) OVERRIDE;
void Visit(render_tree::RectNode* rect_node) OVERRIDE;
void Visit(render_tree::RectShadowNode* rect_shadow_node) OVERRIDE;
void Visit(render_tree::TextNode* text_node) OVERRIDE;
private:
// Can be called with any render tree node in order to invoke the Skia
// software renderer to render to an offscreen surface which is then applied
// to the render target via a Blitter API blit.
void RenderWithSoftwareRenderer(render_tree::Node* node);
RenderState* SetRenderState(const RenderState& render_state) {
render_state_ = render_state;
return &render_state_;
}
// Uses a Blitter API sub-visitor to render the provided render tree to a
// offscreen SbBlitterSurface which is then returned.
struct OffscreenRender {
math::RectF destination_rect;
scoped_ptr<CachedScratchSurface> scratch_surface;
};
scoped_ptr<OffscreenRender> RenderToOffscreenSurface(render_tree::Node* node);
SbBlitterDevice device_;
SbBlitterContext context_;
// Keeps track of our current render target, transform and clip stack.
RenderState render_state_;
// Manager for scratch surfaces used for intermediate rendering during render
// tree traversal.
ScratchSurfaceCache* scratch_surface_cache_;
SurfaceCacheDelegate* surface_cache_delegate_;
common::SurfaceCache* surface_cache_;
base::optional<SurfaceCacheDelegate::ScopedContext>
surface_cache_scoped_context_;
// We fallback to software rasterization in order to render anything that we
// cannot render via the Blitter API directly. We cache the results.
CachedSoftwareRasterizer* software_surface_cache_;
DISALLOW_COPY_AND_ASSIGN(RenderTreeNodeVisitor);
};
} // namespace blitter
} // namespace rasterizer
} // namespace renderer
} // namespace cobalt
#endif // #if SB_HAS(BLITTER)
#endif // COBALT_RENDERER_RASTERIZER_BLITTER_RENDER_TREE_NODE_VISITOR_H_