blob: fea7fe298e794e531b0dbf6a2dedf8d0c654cb91 [file] [log] [blame]
/*
* Copyright 2014 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_RASTERIZER_H_
#define COBALT_RENDERER_RASTERIZER_RASTERIZER_H_
#include "base/memory/ref_counted.h"
#include "base/optional.h"
#include "cobalt/math/rect.h"
#include "cobalt/render_tree/font.h"
#include "cobalt/render_tree/image.h"
#include "cobalt/render_tree/node.h"
#include "cobalt/render_tree/resource_provider.h"
#include "cobalt/renderer/backend/render_target.h"
namespace cobalt {
namespace renderer {
namespace rasterizer {
// This class abstracts the concept of an actor that consumes render trees
// and produces graphics on a given render target. A rasterizer
// would typically be setup with a render target that ultimately the submitted
// render tree would be rasterized to. Having this as an abstract class
// allows for flexibility in its implementation, for example we may provide
// a software rasterizer that simply blits the output to a render target
// after it is done being rasterized. Alternatively, a hardware implementation
// may be implemented so that render tree rasterization is performed on the GPU.
// The rasterizer leaves the above choices to the implementation, as well
// as choices like which rendering library to use (e.g. Skia). Of course,
// resources such as Images and Fonts that are referenced by the render tree
// must be in a format supported by the rasterizer, and this is enabled by
// having the Rasterizer return a specialized ResourceProvider.
class Rasterizer {
public:
// When set, will clear the render target before rasterizing the render tree
// to it.
static const int kSubmitFlags_Clear = (1 << 0);
struct Options {
Options() : flags(0) {}
// A bitwise combination of any of the |kSubmitFlags_*| constants defined
// above.
int flags;
// If specified, indicates which region of |render_target| is
// dirty and needs to be updated. If animations are playing for example,
// then |dirty| can be setup to bound the animations. A rasterizer is free
// to ignore this value if they wish.
base::optional<math::Rect> dirty;
};
virtual ~Rasterizer() {}
// Consumes the render tree and rasterizes it to the specified render_target.
// |options| must be a combination of the |kSubmitOptions_*| constants defined
// above.
virtual void Submit(const scoped_refptr<render_tree::Node>& render_tree,
const scoped_refptr<backend::RenderTarget>& render_target,
const Options& options) = 0;
void Submit(const scoped_refptr<render_tree::Node>& render_tree,
const scoped_refptr<backend::RenderTarget>& render_target) {
Submit(render_tree, render_target, Options());
}
// Returns a thread-safe object from which one can produce renderer resources
// like images and fonts which can be referenced by render trees that are
// subsequently submitted to this pipeline. This call must be thread-safe.
virtual render_tree::ResourceProvider* GetResourceProvider() = 0;
};
} // namespace rasterizer
} // namespace renderer
} // namespace cobalt
#endif // COBALT_RENDERER_RASTERIZER_RASTERIZER_H_