image_filter.h

Go to the documentation of this file.

// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef FLUTTER_IMPELLER_AIKS_IMAGE_FILTER_H_
#define FLUTTER_IMPELLER_AIKS_IMAGE_FILTER_H_
 
#include "impeller/aiks/color_filter.h"
#include "impeller/core/sampler_descriptor.h"
#include "impeller/entity/contents/filters/filter_contents.h"
#include "impeller/entity/entity.h"
#include "impeller/geometry/matrix.h"
#include "impeller/geometry/sigma.h"
 
namespace impeller {
 
struct Paint;
 
class LocalMatrixImageFilter;
class BlurImageFilter;
class DilateImageFilter;
class ErodeImageFilter;
class MatrixImageFilter;
class ComposeImageFilter;
class ColorImageFilter;
 
class ImageFilterVisitor {
 public:
  virtual void Visit(const BlurImageFilter& filter) = 0;
  virtual void Visit(const LocalMatrixImageFilter& filter) = 0;
  virtual void Visit(const DilateImageFilter& filter) = 0;
  virtual void Visit(const ErodeImageFilter& filter) = 0;
  virtual void Visit(const MatrixImageFilter& filter) = 0;
  virtual void Visit(const ComposeImageFilter& filter) = 0;
  virtual void Visit(const ColorImageFilter& filter) = 0;
};
 
/*******************************************************************************
 ******* ImageFilter
 ******************************************************************************/
 
class ImageFilter {
 public:
  ImageFilter();
 
  virtual ~ImageFilter();
 
  static std::shared_ptr<ImageFilter> MakeBlur(
      Sigma sigma_x,
      Sigma sigma_y,
      FilterContents::BlurStyle blur_style,
      Entity::TileMode tile_mode);
 
  static std::shared_ptr<ImageFilter> MakeDilate(Radius radius_x,
                                                 Radius radius_y);
 
  static std::shared_ptr<ImageFilter> MakeErode(Radius radius_x,
                                                Radius radius_y);
 
  static std::shared_ptr<ImageFilter> MakeMatrix(
      const Matrix& matrix,
      SamplerDescriptor sampler_descriptor);
 
  static std::shared_ptr<ImageFilter> MakeCompose(const ImageFilter& inner,
                                                  const ImageFilter& outer);
 
  static std::shared_ptr<ImageFilter> MakeFromColorFilter(
      const ColorFilter& color_filter);
 
  static std::shared_ptr<ImageFilter> MakeLocalMatrix(
      const Matrix& matrix,
      const ImageFilter& internal_filter);
 
  /// @brief  Generate a new FilterContents using this filter's configuration.
  ///
  ///         This is the same as WrapInput, except no input is set. The input
  ///         for the filter chain can be set later using.
  ///         FilterContents::SetLeafInputs().
  ///
  /// @see    `FilterContents::SetLeafInputs`
  std::shared_ptr<FilterContents> GetFilterContents() const;
 
  /// @brief  Wraps the given filter input with a GPU-based image filter.
  virtual std::shared_ptr<FilterContents> WrapInput(
      const FilterInput::Ref& input) const = 0;
 
  virtual std::shared_ptr<ImageFilter> Clone() const = 0;
 
  virtual void Visit(ImageFilterVisitor& visitor) = 0;
 
  virtual int GetRequiredMipCount() const { return 1; }
};
 
/*******************************************************************************
 ******* BlurImageFilter
 ******************************************************************************/
 
class BlurImageFilter : public ImageFilter {
 public:
  BlurImageFilter(Sigma sigma_x,
                  Sigma sigma_y,
                  FilterContents::BlurStyle blur_style,
                  Entity::TileMode tile_mode);
 
  ~BlurImageFilter() override;
 
  // |ImageFilter|
  std::shared_ptr<FilterContents> WrapInput(
      const FilterInput::Ref& input) const override;
 
  // |ImageFilter|
  std::shared_ptr<ImageFilter> Clone() const override;
 
  // |ImageFilter|
  void Visit(ImageFilterVisitor& visitor) override { visitor.Visit(*this); }
 
  int GetRequiredMipCount() const override { return 4; }
 
 private:
  Sigma sigma_x_;
  Sigma sigma_y_;
  FilterContents::BlurStyle blur_style_;
  Entity::TileMode tile_mode_;
};
 
/*******************************************************************************
 ******* DilateImageFilter
 ******************************************************************************/
 
class DilateImageFilter : public ImageFilter {
 public:
  DilateImageFilter(Radius radius_x, Radius radius_y);
 
  ~DilateImageFilter() override;
 
  // |ImageFilter|
  std::shared_ptr<FilterContents> WrapInput(
      const FilterInput::Ref& input) const override;
 
  // |ImageFilter|
  std::shared_ptr<ImageFilter> Clone() const override;
 
  // |ImageFilter|
  void Visit(ImageFilterVisitor& visitor) override { visitor.Visit(*this); }
 
 private:
  Radius radius_x_;
  Radius radius_y_;
};
 
/*******************************************************************************
 ******* ErodeImageFilter
 ******************************************************************************/
 
class ErodeImageFilter : public ImageFilter {
 public:
  ErodeImageFilter(Radius radius_x, Radius radius_y);
 
  ~ErodeImageFilter() override;
 
  // |ImageFilter|
  std::shared_ptr<FilterContents> WrapInput(
      const FilterInput::Ref& input) const override;
 
  // |ImageFilter|
  std::shared_ptr<ImageFilter> Clone() const override;
 
  // |ImageFilter|
  void Visit(ImageFilterVisitor& visitor) override { visitor.Visit(*this); }
 
 private:
  Radius radius_x_;
  Radius radius_y_;
};
 
/*******************************************************************************
 ******* MatrixImageFilter
 ******************************************************************************/
 
class MatrixImageFilter : public ImageFilter {
 public:
  MatrixImageFilter(const Matrix& matrix, SamplerDescriptor sampler_descriptor);
 
  ~MatrixImageFilter() override;
 
  // |ImageFilter|
  std::shared_ptr<FilterContents> WrapInput(
      const FilterInput::Ref& input) const override;
 
  // |ImageFilter|
  std::shared_ptr<ImageFilter> Clone() const override;
 
  // |ImageFilter|
  void Visit(ImageFilterVisitor& visitor) override { visitor.Visit(*this); }
 
  const Matrix& GetMatrix() const { return matrix_; }
 
 private:
  Matrix matrix_;
  SamplerDescriptor sampler_descriptor_;
};
 
/*******************************************************************************
 ******* ComposeImageFilter
 ******************************************************************************/
 
class ComposeImageFilter : public ImageFilter {
 public:
  ComposeImageFilter(const ImageFilter& inner, const ImageFilter& outer);
 
  ~ComposeImageFilter() override;
 
  // |ImageFilter|
  std::shared_ptr<FilterContents> WrapInput(
      const FilterInput::Ref& input) const override;
 
  // |ImageFilter|
  std::shared_ptr<ImageFilter> Clone() const override;
 
  // |ImageFilter|
  void Visit(ImageFilterVisitor& visitor) override { visitor.Visit(*this); }
 
 private:
  std::shared_ptr<ImageFilter> inner_;
  std::shared_ptr<ImageFilter> outer_;
};
 
/*******************************************************************************
 ******* ColorImageFilter
 ******************************************************************************/
 
class ColorImageFilter : public ImageFilter {
 public:
  explicit ColorImageFilter(const ColorFilter& color_filter);
 
  ~ColorImageFilter() override;
 
  // |ImageFilter|
  std::shared_ptr<FilterContents> WrapInput(
      const FilterInput::Ref& input) const override;
 
  // |ImageFilter|
  std::shared_ptr<ImageFilter> Clone() const override;
 
  // |ImageFilter|
  void Visit(ImageFilterVisitor& visitor) override { visitor.Visit(*this); }
 
 private:
  std::shared_ptr<ColorFilter> color_filter_;
};
 
/*******************************************************************************
 ******* LocalMatrixImageFilter
 ******************************************************************************/
 
class LocalMatrixImageFilter : public ImageFilter {
 public:
  LocalMatrixImageFilter(const Matrix& matrix,
                         const ImageFilter& internal_filter);
 
  ~LocalMatrixImageFilter() override;
 
  // |ImageFilter|
  std::shared_ptr<FilterContents> WrapInput(
      const FilterInput::Ref& input) const override;
 
  // |ImageFilter|
  std::shared_ptr<ImageFilter> Clone() const override;
 
  // |ImageFilter|
  void Visit(ImageFilterVisitor& visitor) override { visitor.Visit(*this); }
 
 private:
  Matrix matrix_;
  std::shared_ptr<ImageFilter> internal_filter_;
};
 
}  // namespace impeller
 
#endif  // FLUTTER_IMPELLER_AIKS_IMAGE_FILTER_H_