impeller/entity/contents/filters/blend_filter_contents.cc - mirrors/engine - Git at Google

 // 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.

 #include "impeller/entity/contents/filters/blend_filter_contents.h"

 #include <array>
 #include <memory>
 #include <optional>

 #include "impeller/entity/contents/content_context.h"
 #include "impeller/entity/contents/contents.h"
 #include "impeller/entity/contents/filters/inputs/filter_input.h"
 #include "impeller/entity/contents/solid_color_contents.h"
 #include "impeller/geometry/path_builder.h"
 #include "impeller/renderer/render_pass.h"
 #include "impeller/renderer/sampler_library.h"

 namespace impeller {

 BlendFilterContents::BlendFilterContents() {
   SetBlendMode(Entity::BlendMode::kSourceOver);
 }

 BlendFilterContents::~BlendFilterContents() = default;

 using PipelineProc =
     std::shared_ptr<Pipeline> (ContentContext::*)(ContentContextOptions) const;

 template <typename TPipeline>
 static bool AdvancedBlend(const FilterInput::Vector& inputs,
                           const ContentContext& renderer,
                           const Entity& entity,
                           RenderPass& pass,
                           const Rect& coverage,
                           std::optional<Color> foreground_color,
                           PipelineProc pipeline_proc) {
   using VS = typename TPipeline::VertexShader;
   using FS = typename TPipeline::FragmentShader;

   const size_t total_inputs =
       inputs.size() + (foreground_color.has_value() ? 1 : 0);
   if (total_inputs < 2) {
     return false;
   }

   auto dst_snapshot = inputs[0]->GetSnapshot(renderer, entity);
   if (!dst_snapshot.has_value()) {
     return true;
   }
   auto maybe_dst_uvs = dst_snapshot->GetCoverageUVs(coverage);
   if (!maybe_dst_uvs.has_value()) {
     return true;
   }
   auto dst_uvs = maybe_dst_uvs.value();

   std::optional<Snapshot> src_snapshot;
   std::array<Point, 4> src_uvs;
   if (!foreground_color.has_value()) {
     src_snapshot = inputs[1]->GetSnapshot(renderer, entity);
     if (!src_snapshot.has_value()) {
       return true;
     }
     auto maybe_src_uvs = src_snapshot->GetCoverageUVs(coverage);
     if (!maybe_src_uvs.has_value()) {
       return true;
     }
     src_uvs = maybe_src_uvs.value();
   }

   auto& host_buffer = pass.GetTransientsBuffer();

   auto size = pass.GetRenderTargetSize();
   VertexBufferBuilder<typename VS::PerVertexData> vtx_builder;
   vtx_builder.AddVertices({
       {Point(0, 0), dst_uvs[0], src_uvs[0]},
       {Point(size.width, 0), dst_uvs[1], src_uvs[1]},
       {Point(size.width, size.height), dst_uvs[3], src_uvs[3]},
       {Point(0, 0), dst_uvs[0], src_uvs[0]},
       {Point(size.width, size.height), dst_uvs[3], src_uvs[3]},
       {Point(0, size.height), dst_uvs[2], src_uvs[2]},
   });
   auto vtx_buffer = vtx_builder.CreateVertexBuffer(host_buffer);

   auto options = OptionsFromPassAndEntity(pass, entity);
   std::shared_ptr<Pipeline> pipeline =
       std::invoke(pipeline_proc, renderer, options);

   Command cmd;
   cmd.label = "Advanced Blend Filter";
   cmd.BindVertices(vtx_buffer);
   cmd.pipeline = std::move(pipeline);

   auto sampler = renderer.GetContext()->GetSamplerLibrary()->GetSampler({});
   FS::BindTextureSamplerDst(cmd, dst_snapshot->texture, sampler);

   typename FS::BlendInfo blend_info;
   if (foreground_color.has_value()) {
     blend_info.color_factor = 1;
     blend_info.color = foreground_color.value();
     // This texture will not be sampled from due to the color factor. But this
     // is present so that validation doesn't trip on a missing binding.
     FS::BindTextureSamplerSrc(cmd, dst_snapshot->texture, sampler);
   } else {
     blend_info.color_factor = 0;
     FS::BindTextureSamplerSrc(cmd, src_snapshot->texture, sampler);
   }
   auto blend_uniform = host_buffer.EmplaceUniform(blend_info);
   FS::BindBlendInfo(cmd, blend_uniform);

   typename VS::FrameInfo frame_info;
   frame_info.mvp = Matrix::MakeOrthographic(size);

   auto uniform_view = host_buffer.EmplaceUniform(frame_info);
   VS::BindFrameInfo(cmd, uniform_view);
   pass.AddCommand(cmd);

   return true;
 }

 static bool PipelineBlend(const FilterInput::Vector& inputs,
                           const ContentContext& renderer,
                           const Entity& entity,
                           RenderPass& pass,
                           const Rect& coverage,
                           Entity::BlendMode pipeline_blend,
                           std::optional<Color> foreground_color) {
   using VS = BlendPipeline::VertexShader;
   using FS = BlendPipeline::FragmentShader;

   auto& host_buffer = pass.GetTransientsBuffer();

   auto sampler = renderer.GetContext()->GetSamplerLibrary()->GetSampler({});

   Command cmd;
   cmd.label = "Pipeline Blend Filter";
   auto options = OptionsFromPass(pass);

   auto add_blend_command = [&](std::optional<Snapshot> input) {
     if (!input.has_value()) {
       return false;
     }
     auto input_coverage = input->GetCoverage();
     if (!input_coverage.has_value()) {
       return false;
     }

     FS::BindTextureSamplerSrc(cmd, input->texture, sampler);

     auto size = input->texture->GetSize();
     VertexBufferBuilder<VS::PerVertexData> vtx_builder;
     vtx_builder.AddVertices({
         {Point(0, 0), Point(0, 0)},
         {Point(size.width, 0), Point(1, 0)},
         {Point(size.width, size.height), Point(1, 1)},
         {Point(0, 0), Point(0, 0)},
         {Point(size.width, size.height), Point(1, 1)},
         {Point(0, size.height), Point(0, 1)},
     });
     auto vtx_buffer = vtx_builder.CreateVertexBuffer(host_buffer);
     cmd.BindVertices(vtx_buffer);

     VS::FrameInfo frame_info;
     frame_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
                      Matrix::MakeTranslation(-coverage.origin) *
                      input->transform;

     auto uniform_view = host_buffer.EmplaceUniform(frame_info);
     VS::BindFrameInfo(cmd, uniform_view);

     pass.AddCommand(cmd);
     return true;
   };

   // Draw the first texture using kSource.

   options.blend_mode = Entity::BlendMode::kSource;
   cmd.pipeline = renderer.GetBlendPipeline(options);
   if (!add_blend_command(inputs[0]->GetSnapshot(renderer, entity))) {
     return true;
   }

   // Write subsequent textures using the selected blend mode.

   if (inputs.size() >= 2) {
     options.blend_mode = pipeline_blend;
     cmd.pipeline = renderer.GetBlendPipeline(options);

     for (auto texture_i = inputs.begin() + 1; texture_i < inputs.end();
          texture_i++) {
       auto input = texture_i->get()->GetSnapshot(renderer, entity);
       if (!add_blend_command(input)) {
         return true;
       }
     }
   }

   // If a foreground color is set, blend it in.

   if (foreground_color.has_value()) {
     auto contents = std::make_shared<SolidColorContents>();
     contents->SetPath(PathBuilder{}
                           .AddRect(Rect::MakeSize(pass.GetRenderTargetSize()))
                           .TakePath());
     contents->SetColor(foreground_color.value());

     Entity foreground_entity;
     foreground_entity.SetBlendMode(pipeline_blend);
     foreground_entity.SetContents(contents);
     if (!foreground_entity.Render(renderer, pass)) {
       return false;
     }
   }

   return true;
 }

 #define BLEND_CASE(mode)                                                      \
   case Entity::BlendMode::k##mode:                                            \
     advanced_blend_proc_ =                                                    \
         [](const FilterInput::Vector& inputs, const ContentContext& renderer, \
            const Entity& entity, RenderPass& pass, const Rect& coverage,      \
            std::optional<Color> fg_color) {                                   \
           PipelineProc p = &ContentContext::GetBlend##mode##Pipeline;         \
           return AdvancedBlend<BlendScreenPipeline>(                          \
               inputs, renderer, entity, pass, coverage, fg_color, p);         \
         };                                                                    \
     break;

 void BlendFilterContents::SetBlendMode(Entity::BlendMode blend_mode) {
   if (blend_mode > Entity::BlendMode::kLastAdvancedBlendMode) {
     VALIDATION_LOG << "Invalid blend mode " << static_cast<int>(blend_mode)
                    << " assigned to BlendFilterContents.";
   }

   blend_mode_ = blend_mode;

   if (blend_mode > Entity::BlendMode::kLastPipelineBlendMode) {
     static_assert(Entity::BlendMode::kLastAdvancedBlendMode ==
                   Entity::BlendMode::kLuminosity);

     switch (blend_mode) {
       BLEND_CASE(Screen)
       BLEND_CASE(Overlay)
       BLEND_CASE(Darken)
       BLEND_CASE(Lighten)
       BLEND_CASE(ColorDodge)
       BLEND_CASE(ColorBurn)
       BLEND_CASE(HardLight)
       BLEND_CASE(SoftLight)
       BLEND_CASE(Difference)
       BLEND_CASE(Exclusion)
       BLEND_CASE(Multiply)
       BLEND_CASE(Hue)
       BLEND_CASE(Saturation)
       BLEND_CASE(Color)
       BLEND_CASE(Luminosity)
       default:
         FML_UNREACHABLE();
     }
   }
 }

 void BlendFilterContents::SetForegroundColor(std::optional<Color> color) {
   foreground_color_ = color;
 }

 bool BlendFilterContents::RenderFilter(const FilterInput::Vector& inputs,
                                        const ContentContext& renderer,
                                        const Entity& entity,
                                        RenderPass& pass,
                                        const Rect& coverage) const {
   if (inputs.empty()) {
     return true;
   }

   if (inputs.size() == 1 && !foreground_color_.has_value()) {
     // Nothing to blend.
     return PipelineBlend(inputs, renderer, entity, pass, coverage,
                          Entity::BlendMode::kSource, std::nullopt);
   }

   if (blend_mode_ <= Entity::BlendMode::kLastPipelineBlendMode) {
     return PipelineBlend(inputs, renderer, entity, pass, coverage, blend_mode_,
                          foreground_color_);
   }

   if (blend_mode_ <= Entity::BlendMode::kLastAdvancedBlendMode) {
     return advanced_blend_proc_(inputs, renderer, entity, pass, coverage,
                                 foreground_color_);
   }

   FML_UNREACHABLE();
 }

 }  // namespace impeller
	// 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.

	#include "impeller/entity/contents/filters/blend_filter_contents.h"

	#include <array>
	#include <memory>
	#include <optional>

	#include "impeller/entity/contents/content_context.h"
	#include "impeller/entity/contents/contents.h"
	#include "impeller/entity/contents/filters/inputs/filter_input.h"
	#include "impeller/entity/contents/solid_color_contents.h"
	#include "impeller/geometry/path_builder.h"
	#include "impeller/renderer/render_pass.h"
	#include "impeller/renderer/sampler_library.h"

	namespace impeller {

	BlendFilterContents::BlendFilterContents() {
	SetBlendMode(Entity::BlendMode::kSourceOver);
	}

	BlendFilterContents::~BlendFilterContents() = default;

	using PipelineProc =
	std::shared_ptr<Pipeline> (ContentContext::*)(ContentContextOptions) const;

	template <typename TPipeline>
	static bool AdvancedBlend(const FilterInput::Vector& inputs,
	const ContentContext& renderer,
	const Entity& entity,
	RenderPass& pass,
	const Rect& coverage,
	std::optional<Color> foreground_color,
	PipelineProc pipeline_proc) {
	using VS = typename TPipeline::VertexShader;
	using FS = typename TPipeline::FragmentShader;

	const size_t total_inputs =
	inputs.size() + (foreground_color.has_value() ? 1 : 0);
	if (total_inputs < 2) {
	return false;
	}

	auto dst_snapshot = inputs[0]->GetSnapshot(renderer, entity);
	if (!dst_snapshot.has_value()) {
	return true;
	}
	auto maybe_dst_uvs = dst_snapshot->GetCoverageUVs(coverage);
	if (!maybe_dst_uvs.has_value()) {
	return true;
	}
	auto dst_uvs = maybe_dst_uvs.value();

	std::optional<Snapshot> src_snapshot;
	std::array<Point, 4> src_uvs;
	if (!foreground_color.has_value()) {
	src_snapshot = inputs[1]->GetSnapshot(renderer, entity);
	if (!src_snapshot.has_value()) {
	return true;
	}
	auto maybe_src_uvs = src_snapshot->GetCoverageUVs(coverage);
	if (!maybe_src_uvs.has_value()) {
	return true;
	}
	src_uvs = maybe_src_uvs.value();
	}

	auto& host_buffer = pass.GetTransientsBuffer();

	auto size = pass.GetRenderTargetSize();
	VertexBufferBuilder<typename VS::PerVertexData> vtx_builder;
	vtx_builder.AddVertices({
	{Point(0, 0), dst_uvs[0], src_uvs[0]},
	{Point(size.width, 0), dst_uvs[1], src_uvs[1]},
	{Point(size.width, size.height), dst_uvs[3], src_uvs[3]},
	{Point(0, 0), dst_uvs[0], src_uvs[0]},
	{Point(size.width, size.height), dst_uvs[3], src_uvs[3]},
	{Point(0, size.height), dst_uvs[2], src_uvs[2]},
	});
	auto vtx_buffer = vtx_builder.CreateVertexBuffer(host_buffer);

	auto options = OptionsFromPassAndEntity(pass, entity);
	std::shared_ptr<Pipeline> pipeline =
	std::invoke(pipeline_proc, renderer, options);

	Command cmd;
	cmd.label = "Advanced Blend Filter";
	cmd.BindVertices(vtx_buffer);
	cmd.pipeline = std::move(pipeline);

	auto sampler = renderer.GetContext()->GetSamplerLibrary()->GetSampler({});
	FS::BindTextureSamplerDst(cmd, dst_snapshot->texture, sampler);

	typename FS::BlendInfo blend_info;
	if (foreground_color.has_value()) {
	blend_info.color_factor = 1;
	blend_info.color = foreground_color.value();
	// This texture will not be sampled from due to the color factor. But this
	// is present so that validation doesn't trip on a missing binding.
	FS::BindTextureSamplerSrc(cmd, dst_snapshot->texture, sampler);
	} else {
	blend_info.color_factor = 0;
	FS::BindTextureSamplerSrc(cmd, src_snapshot->texture, sampler);
	}
	auto blend_uniform = host_buffer.EmplaceUniform(blend_info);
	FS::BindBlendInfo(cmd, blend_uniform);

	typename VS::FrameInfo frame_info;
	frame_info.mvp = Matrix::MakeOrthographic(size);

	auto uniform_view = host_buffer.EmplaceUniform(frame_info);
	VS::BindFrameInfo(cmd, uniform_view);
	pass.AddCommand(cmd);

	return true;
	}

	static bool PipelineBlend(const FilterInput::Vector& inputs,
	const ContentContext& renderer,
	const Entity& entity,
	RenderPass& pass,
	const Rect& coverage,
	Entity::BlendMode pipeline_blend,
	std::optional<Color> foreground_color) {
	using VS = BlendPipeline::VertexShader;
	using FS = BlendPipeline::FragmentShader;

	auto& host_buffer = pass.GetTransientsBuffer();

	auto sampler = renderer.GetContext()->GetSamplerLibrary()->GetSampler({});

	Command cmd;
	cmd.label = "Pipeline Blend Filter";
	auto options = OptionsFromPass(pass);

	auto add_blend_command = [&](std::optional<Snapshot> input) {
	if (!input.has_value()) {
	return false;
	}
	auto input_coverage = input->GetCoverage();
	if (!input_coverage.has_value()) {
	return false;
	}

	FS::BindTextureSamplerSrc(cmd, input->texture, sampler);

	auto size = input->texture->GetSize();
	VertexBufferBuilder<VS::PerVertexData> vtx_builder;
	vtx_builder.AddVertices({
	{Point(0, 0), Point(0, 0)},
	{Point(size.width, 0), Point(1, 0)},
	{Point(size.width, size.height), Point(1, 1)},
	{Point(0, 0), Point(0, 0)},
	{Point(size.width, size.height), Point(1, 1)},
	{Point(0, size.height), Point(0, 1)},
	});
	auto vtx_buffer = vtx_builder.CreateVertexBuffer(host_buffer);
	cmd.BindVertices(vtx_buffer);

	VS::FrameInfo frame_info;
	frame_info.mvp = Matrix::MakeOrthographic(pass.GetRenderTargetSize()) *
	Matrix::MakeTranslation(-coverage.origin) *
	input->transform;

	auto uniform_view = host_buffer.EmplaceUniform(frame_info);
	VS::BindFrameInfo(cmd, uniform_view);

	pass.AddCommand(cmd);
	return true;
	};

	// Draw the first texture using kSource.

	options.blend_mode = Entity::BlendMode::kSource;
	cmd.pipeline = renderer.GetBlendPipeline(options);
	if (!add_blend_command(inputs[0]->GetSnapshot(renderer, entity))) {
	return true;
	}

	// Write subsequent textures using the selected blend mode.

	if (inputs.size() >= 2) {
	options.blend_mode = pipeline_blend;
	cmd.pipeline = renderer.GetBlendPipeline(options);

	for (auto texture_i = inputs.begin() + 1; texture_i < inputs.end();
	texture_i++) {
	auto input = texture_i->get()->GetSnapshot(renderer, entity);
	if (!add_blend_command(input)) {
	return true;
	}
	}
	}

	// If a foreground color is set, blend it in.

	if (foreground_color.has_value()) {
	auto contents = std::make_shared<SolidColorContents>();
	contents->SetPath(PathBuilder{}
	.AddRect(Rect::MakeSize(pass.GetRenderTargetSize()))
	.TakePath());
	contents->SetColor(foreground_color.value());

	Entity foreground_entity;
	foreground_entity.SetBlendMode(pipeline_blend);
	foreground_entity.SetContents(contents);
	if (!foreground_entity.Render(renderer, pass)) {
	return false;
	}
	}

	return true;
	}

	#define BLEND_CASE(mode) \
	case Entity::BlendMode::k##mode: \
	advanced_blend_proc_ = \
	[](const FilterInput::Vector& inputs, const ContentContext& renderer, \
	const Entity& entity, RenderPass& pass, const Rect& coverage, \
	std::optional<Color> fg_color) { \
	PipelineProc p = &ContentContext::GetBlend##mode##Pipeline; \
	return AdvancedBlend<BlendScreenPipeline>( \
	inputs, renderer, entity, pass, coverage, fg_color, p); \
	}; \
	break;

	void BlendFilterContents::SetBlendMode(Entity::BlendMode blend_mode) {
	if (blend_mode > Entity::BlendMode::kLastAdvancedBlendMode) {
	VALIDATION_LOG << "Invalid blend mode " << static_cast<int>(blend_mode)
	<< " assigned to BlendFilterContents.";
	}

	blend_mode_ = blend_mode;

	if (blend_mode > Entity::BlendMode::kLastPipelineBlendMode) {
	static_assert(Entity::BlendMode::kLastAdvancedBlendMode ==
	Entity::BlendMode::kLuminosity);

	switch (blend_mode) {
	BLEND_CASE(Screen)
	BLEND_CASE(Overlay)
	BLEND_CASE(Darken)
	BLEND_CASE(Lighten)
	BLEND_CASE(ColorDodge)
	BLEND_CASE(ColorBurn)
	BLEND_CASE(HardLight)
	BLEND_CASE(SoftLight)
	BLEND_CASE(Difference)
	BLEND_CASE(Exclusion)
	BLEND_CASE(Multiply)
	BLEND_CASE(Hue)
	BLEND_CASE(Saturation)
	BLEND_CASE(Color)
	BLEND_CASE(Luminosity)
	default:
	FML_UNREACHABLE();
	}
	}
	}

	void BlendFilterContents::SetForegroundColor(std::optional<Color> color) {
	foreground_color_ = color;
	}

	bool BlendFilterContents::RenderFilter(const FilterInput::Vector& inputs,
	const ContentContext& renderer,
	const Entity& entity,
	RenderPass& pass,
	const Rect& coverage) const {
	if (inputs.empty()) {
	return true;
	}

	if (inputs.size() == 1 && !foreground_color_.has_value()) {
	// Nothing to blend.
	return PipelineBlend(inputs, renderer, entity, pass, coverage,
	Entity::BlendMode::kSource, std::nullopt);
	}

	if (blend_mode_ <= Entity::BlendMode::kLastPipelineBlendMode) {
	return PipelineBlend(inputs, renderer, entity, pass, coverage, blend_mode_,
	foreground_color_);
	}

	if (blend_mode_ <= Entity::BlendMode::kLastAdvancedBlendMode) {
	return advanced_blend_proc_(inputs, renderer, entity, pass, coverage,
	foreground_color_);
	}

	FML_UNREACHABLE();
	}

	} // namespace impeller