11 #include "flutter/fml/logging.h"
25 #include "impeller/entity/texture_fill.frag.h"
26 #include "impeller/entity/texture_fill.vert.h"
37 #define _IMPELLER_BLEND_MODE_FILTER_NAME_LIST(blend_mode) \
38 "Blend Filter " #blend_mode,
40 static constexpr
const char* kBlendModeFilterNames[] = {
43 const std::string_view BlendModeToFilterString(
BlendMode blend_mode) {
44 return kBlendModeFilterNames[
static_cast<std::underlying_type_t<BlendMode>
>(
95 template <
typename TPipeline>
100 const Rect& coverage,
102 std::optional<Color> foreground_color,
105 std::optional<Scalar> alpha) {
106 using VS =
typename TPipeline::VertexShader;
107 using FS =
typename TPipeline::FragmentShader;
113 const size_t total_inputs =
114 inputs.size() + (foreground_color.has_value() ? 1 : 0);
115 if (total_inputs < 2) {
120 inputs[0]->GetSnapshot(
"AdvancedBlend(Dst)", renderer, entity);
121 if (!dst_snapshot.has_value()) {
124 auto maybe_dst_uvs = dst_snapshot->GetCoverageUVs(coverage);
125 if (!maybe_dst_uvs.has_value()) {
128 auto dst_uvs = maybe_dst_uvs.value();
130 std::optional<Snapshot> src_snapshot;
131 std::array<Point, 4> src_uvs;
132 if (!foreground_color.has_value()) {
134 inputs[1]->GetSnapshot(
"AdvancedBlend(Src)", renderer, entity);
135 if (!src_snapshot.has_value()) {
136 if (!dst_snapshot.has_value()) {
141 auto maybe_src_uvs = src_snapshot->GetCoverageUVs(coverage);
142 if (!maybe_src_uvs.has_value()) {
143 if (!dst_snapshot.has_value()) {
148 src_uvs = maybe_src_uvs.value();
151 Rect subpass_coverage = coverage;
153 auto coverage_hint = entity.
GetContents()->GetCoverageHint();
155 if (coverage_hint.has_value()) {
156 auto maybe_subpass_coverage =
158 if (!maybe_subpass_coverage.has_value()) {
162 subpass_coverage = *maybe_subpass_coverage;
174 auto size = pass.GetRenderTargetSize();
176 std::array<typename VS::PerVertexData, 4> vertices = {
177 typename VS::PerVertexData{
Point(0, 0), dst_uvs[0], src_uvs[0]},
178 typename VS::PerVertexData{
Point(size.width, 0), dst_uvs[1],
180 typename VS::PerVertexData{
Point(0, size.height), dst_uvs[2],
182 typename VS::PerVertexData{
Point(size.width, size.height), dst_uvs[3],
191 PipelineRef pipeline = std::invoke(pipeline_proc, renderer, options);
193 #ifdef IMPELLER_DEBUG
194 pass.SetCommandLabel(BlendModeToFilterString(blend_mode));
196 pass.SetVertexBuffer(std::move(vtx_buffer));
197 pass.SetPipeline(pipeline);
199 typename FS::BlendInfo blend_info;
200 typename VS::FrameInfo frame_info;
203 renderer.
GetContext()->GetSamplerLibrary()->GetSampler(
204 dst_snapshot->sampler_descriptor);
205 FS::BindTextureSamplerDst(pass, dst_snapshot->texture, dst_sampler);
206 frame_info.dst_y_coord_scale = dst_snapshot->texture->GetYCoordScale();
207 blend_info.dst_input_alpha =
209 ? dst_snapshot->opacity
212 if (foreground_color.has_value()) {
213 blend_info.color_factor = 1;
214 blend_info.color = foreground_color.value();
218 FS::BindTextureSamplerSrc(pass, dst_snapshot->texture, dst_sampler);
221 renderer.
GetContext()->GetSamplerLibrary()->GetSampler(
222 src_snapshot->sampler_descriptor);
223 blend_info.color_factor = 0;
224 blend_info.src_input_alpha = src_snapshot->opacity;
225 FS::BindTextureSamplerSrc(pass, src_snapshot->texture, src_sampler);
226 frame_info.src_y_coord_scale = src_snapshot->texture->GetYCoordScale();
228 auto blend_uniform = host_buffer.EmplaceUniform(blend_info);
229 FS::BindBlendInfo(pass, blend_uniform);
231 frame_info.mvp = pass.GetOrthographicTransform() *
235 auto uniform_view = host_buffer.EmplaceUniform(frame_info);
236 VS::BindFrameInfo(pass, uniform_view);
238 return pass.Draw().ok();
241 std::shared_ptr<CommandBuffer> command_buffer =
243 if (!command_buffer) {
246 fml::StatusOr<RenderTarget> render_target =
254 if (!render_target.ok()) {
257 if (!renderer.
GetContext()->EnqueueCommandBuffer(std::move(command_buffer))) {
263 .
texture = render_target.value().GetRenderTargetTexture(),
268 .sampler_descriptor = {},
271 : dst_snapshot->opacity) *
272 alpha.value_or(1.0)},
276 std::optional<Entity> BlendFilterContents::CreateForegroundAdvancedBlend(
277 const std::shared_ptr<FilterInput>& input,
278 const ContentContext& renderer,
279 const Entity& entity,
280 const Rect& coverage,
281 Color foreground_color,
283 std::optional<Scalar> alpha,
286 input->GetSnapshot(
"ForegroundAdvancedBlend", renderer, entity);
287 if (!dst_snapshot.has_value()) {
291 RenderProc render_proc = [foreground_color, dst_snapshot, blend_mode, alpha,
292 absorb_opacity](
const ContentContext& renderer,
293 const Entity& entity,
294 RenderPass& pass) ->
bool {
298 auto& host_buffer = renderer.GetTransientsBuffer();
299 auto size = dst_snapshot->texture->GetSize();
301 std::array<VS::PerVertexData, 4> vertices = {
302 VS::PerVertexData{{0, 0}, {0, 0}, {0, 0}},
303 VS::PerVertexData{
Point(size.width, 0), {1, 0}, {1, 0}},
304 VS::PerVertexData{
Point(0, size.height), {0, 1}, {0, 1}},
305 VS::PerVertexData{
Point(size.width, size.height), {1, 1}, {1, 1}},
310 #ifdef IMPELLER_DEBUG
311 pass.SetCommandLabel(BlendModeToFilterString(blend_mode));
313 pass.SetVertexBuffer(std::move(vtx_buffer));
317 switch (blend_mode) {
319 pass.SetPipeline(renderer.GetBlendScreenPipeline(options));
322 pass.SetPipeline(renderer.GetBlendOverlayPipeline(options));
325 pass.SetPipeline(renderer.GetBlendDarkenPipeline(options));
328 pass.SetPipeline(renderer.GetBlendLightenPipeline(options));
331 pass.SetPipeline(renderer.GetBlendColorDodgePipeline(options));
334 pass.SetPipeline(renderer.GetBlendColorBurnPipeline(options));
337 pass.SetPipeline(renderer.GetBlendHardLightPipeline(options));
340 pass.SetPipeline(renderer.GetBlendSoftLightPipeline(options));
343 pass.SetPipeline(renderer.GetBlendDifferencePipeline(options));
346 pass.SetPipeline(renderer.GetBlendExclusionPipeline(options));
349 pass.SetPipeline(renderer.GetBlendMultiplyPipeline(options));
352 pass.SetPipeline(renderer.GetBlendHuePipeline(options));
355 pass.SetPipeline(renderer.GetBlendSaturationPipeline(options));
358 pass.SetPipeline(renderer.GetBlendColorPipeline(options));
361 pass.SetPipeline(renderer.GetBlendLuminosityPipeline(options));
367 FS::BlendInfo blend_info;
368 VS::FrameInfo frame_info;
370 raw_ptr<const Sampler> dst_sampler =
371 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
372 dst_snapshot->sampler_descriptor);
373 FS::BindTextureSamplerDst(pass, dst_snapshot->texture, dst_sampler);
374 frame_info.dst_y_coord_scale = dst_snapshot->texture->GetYCoordScale();
377 entity.GetShaderClipDepth(), pass,
378 entity.GetTransform() * dst_snapshot->transform);
380 blend_info.dst_input_alpha =
382 ? dst_snapshot->opacity * alpha.value_or(1.0)
385 blend_info.color_factor = 1;
386 blend_info.color = foreground_color;
390 FS::BindTextureSamplerSrc(pass, dst_snapshot->texture, dst_sampler);
392 auto blend_uniform = host_buffer.EmplaceUniform(blend_info);
393 FS::BindBlendInfo(pass, blend_uniform);
395 auto uniform_view = host_buffer.EmplaceUniform(frame_info);
396 VS::BindFrameInfo(pass, uniform_view);
398 return pass.Draw().ok();
401 [coverage](
const Entity& entity) -> std::optional<Rect> {
402 return coverage.TransformBounds(entity.GetTransform());
408 sub_entity.SetContents(std::move(contents));
409 sub_entity.SetBlendMode(entity.GetBlendMode());
414 std::optional<Entity> BlendFilterContents::CreateForegroundPorterDuffBlend(
415 const std::shared_ptr<FilterInput>& input,
416 const ContentContext& renderer,
417 const Entity& entity,
418 const Rect& coverage,
419 Color foreground_color,
421 std::optional<Scalar> alpha,
428 input->GetSnapshot(
"ForegroundPorterDuffBlend", renderer, entity);
429 if (!dst_snapshot.has_value()) {
437 RenderProc render_proc = [foreground_color, dst_snapshot, blend_mode,
438 absorb_opacity, alpha](
439 const ContentContext& renderer,
440 const Entity& entity, RenderPass& pass) ->
bool {
444 auto& host_buffer = renderer.GetTransientsBuffer();
445 auto size = dst_snapshot->texture->GetSize();
446 auto color = foreground_color.Premultiply();
448 std::array<VS::PerVertexData, 4> vertices = {
449 VS::PerVertexData{{0, 0}, {0, 0}, color},
450 VS::PerVertexData{
Point(size.width, 0), {1, 0}, color},
451 VS::PerVertexData{
Point(0, size.height), {0, 1}, color},
452 VS::PerVertexData{
Point(size.width, size.height), {1, 1}, color},
457 #ifdef IMPELLER_DEBUG
458 pass.SetCommandLabel(BlendModeToFilterString(blend_mode));
460 pass.SetVertexBuffer(std::move(vtx_buffer));
463 pass.SetPipeline(renderer.GetPorterDuffPipeline(blend_mode, options));
465 FS::FragInfo frag_info;
466 VS::FrameInfo frame_info;
469 entity.GetShaderClipDepth(), pass,
470 entity.GetTransform() * dst_snapshot->transform);
472 raw_ptr<const Sampler> dst_sampler =
473 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
474 dst_snapshot->sampler_descriptor);
475 FS::BindTextureSamplerDst(pass, dst_snapshot->texture, dst_sampler);
476 frame_info.texture_sampler_y_coord_scale =
477 dst_snapshot->texture->GetYCoordScale();
479 frag_info.input_alpha_output_alpha_tmx_tmy =
481 ? dst_snapshot->opacity * alpha.value_or(1.0)
484 frag_info.use_strict_source_rect = 0.0;
486 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
487 VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
489 return pass.Draw().ok();
493 [coverage](
const Entity& entity) -> std::optional<Rect> {
494 return coverage.TransformBounds(entity.GetTransform());
500 sub_entity.SetContents(std::move(contents));
501 sub_entity.SetBlendMode(entity.GetBlendMode());
510 const Rect& coverage,
512 std::optional<Color> foreground_color,
514 std::optional<Scalar> alpha) {
519 inputs[0]->GetSnapshot(
"PipelineBlend(Dst)", renderer, entity);
520 if (!dst_snapshot.has_value()) {
524 Rect subpass_coverage = coverage;
526 auto coverage_hint = entity.
GetContents()->GetCoverageHint();
528 if (coverage_hint.has_value()) {
529 auto maybe_subpass_coverage =
531 if (!maybe_subpass_coverage.has_value()) {
535 subpass_coverage = *maybe_subpass_coverage;
543 #ifdef IMPELLER_DEBUG
544 pass.SetCommandLabel(BlendModeToFilterString(blend_mode));
549 auto add_blend_command = [&](std::optional<Snapshot> input) {
550 if (!input.has_value()) {
553 auto input_coverage = input->GetCoverage();
554 if (!input_coverage.has_value()) {
559 renderer.
GetContext()->GetSamplerLibrary()->GetSampler(
560 input->sampler_descriptor);
561 FS::BindTextureSampler(pass, input->texture, sampler);
563 auto size = input->texture->GetSize();
564 std::array<VS::PerVertexData, 4> vertices = {
566 VS::PerVertexData{
Point(size.width, 0),
Point(1, 0)},
567 VS::PerVertexData{
Point(0, size.height),
Point(0, 1)},
568 VS::PerVertexData{
Point(size.width, size.height),
Point(1, 1)},
570 pass.SetVertexBuffer(
573 VS::FrameInfo frame_info;
574 frame_info.mvp = pass.GetOrthographicTransform() *
577 frame_info.texture_sampler_y_coord_scale =
578 input->texture->GetYCoordScale();
580 FS::FragInfo frag_info;
585 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
586 VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
588 return pass.Draw().ok();
594 if (!add_blend_command(dst_snapshot)) {
600 if (inputs.size() >= 2) {
601 options.blend_mode = blend_mode;
604 for (
auto texture_i = inputs.begin() + 1; texture_i < inputs.end();
606 auto src_input = texture_i->get()->GetSnapshot(
"PipelineBlend(Src)",
608 if (!add_blend_command(src_input)) {
616 if (foreground_color.has_value()) {
617 auto contents = std::make_shared<SolidColorContents>();
619 contents->SetGeometry(&geom);
620 contents->SetColor(foreground_color.value());
625 if (!foreground_entity.
Render(renderer, pass)) {
633 std::shared_ptr<CommandBuffer> command_buffer =
635 if (!command_buffer) {
639 fml::StatusOr<RenderTarget> render_target =
648 if (!render_target.ok()) {
651 if (!renderer.
GetContext()->EnqueueCommandBuffer(std::move(command_buffer))) {
657 .
texture = render_target.value().GetRenderTargetTexture(),
662 .sampler_descriptor = {},
665 : dst_snapshot->opacity) *
666 alpha.value_or(1.0)},
670 std::optional<Entity> BlendFilterContents::CreateFramebufferAdvancedBlend(
672 const ContentContext& renderer,
673 const Entity& entity,
674 const Rect& coverage,
675 std::optional<Color> foreground_color,
677 std::optional<Scalar> alpha,
680 FML_DCHECK(inputs.size() == 2u ||
681 (inputs.size() == 1u && foreground_color.has_value()));
684 inputs[0]->GetSnapshot(
"ForegroundAdvancedBlend", renderer, entity);
685 if (!dst_snapshot.has_value()) {
689 std::shared_ptr<Texture> foreground_texture;
696 HostBuffer& host_buffer = renderer.GetTransientsBuffer();
699 using FS = TextureFillFragmentShader;
700 using VS = TextureFillVertexShader;
702 pass.SetCommandLabel(
"Framebuffer Advanced Blend");
705 pass.SetPipeline(renderer.GetTexturePipeline(pipeline_options));
707 VS::FrameInfo frame_info;
709 frame_info.texture_sampler_y_coord_scale = 1.0;
711 FS::FragInfo frag_info;
712 frag_info.alpha = 1.0;
714 std::array<VS::PerVertexData, 4> vertices = {
715 VS::PerVertexData{{0, 0}, {0, 0}},
716 VS::PerVertexData{
Point(1, 0), {1, 0}},
717 VS::PerVertexData{
Point(0, 1), {0, 1}},
718 VS::PerVertexData{
Point(1, 1), {1, 1}},
720 pass.SetVertexBuffer(
723 VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
724 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
725 FS::BindTextureSampler(
726 pass, dst_snapshot->texture,
727 renderer.GetContext()->GetSamplerLibrary()->GetSampler({}));
729 if (!pass.Draw().ok()) {
740 std::shared_ptr<Texture> src_texture;
741 SamplerDescriptor src_sampler_descriptor = SamplerDescriptor{};
742 if (foreground_color.has_value()) {
743 src_texture = foreground_texture;
746 inputs[0]->GetSnapshot(
"ForegroundAdvancedBlend", renderer, entity);
747 if (!src_snapshot.has_value()) {
753 src_texture = src_snapshot->texture;
754 src_sampler_descriptor = src_snapshot->sampler_descriptor;
757 std::array<VS::PerVertexData, 4> vertices = {
768 pass.SetCommandLabel(
"Framebuffer Advanced Blend Filter");
769 pass.SetVertexBuffer(
772 switch (blend_mode) {
774 pass.SetPipeline(renderer.GetFramebufferBlendScreenPipeline(options));
778 renderer.GetFramebufferBlendOverlayPipeline(options));
781 pass.SetPipeline(renderer.GetFramebufferBlendDarkenPipeline(options));
785 renderer.GetFramebufferBlendLightenPipeline(options));
789 renderer.GetFramebufferBlendColorDodgePipeline(options));
793 renderer.GetFramebufferBlendColorBurnPipeline(options));
797 renderer.GetFramebufferBlendHardLightPipeline(options));
801 renderer.GetFramebufferBlendSoftLightPipeline(options));
805 renderer.GetFramebufferBlendDifferencePipeline(options));
809 renderer.GetFramebufferBlendExclusionPipeline(options));
813 renderer.GetFramebufferBlendMultiplyPipeline(options));
816 pass.SetPipeline(renderer.GetFramebufferBlendHuePipeline(options));
820 renderer.GetFramebufferBlendSaturationPipeline(options));
823 pass.SetPipeline(renderer.GetFramebufferBlendColorPipeline(options));
827 renderer.GetFramebufferBlendLuminosityPipeline(options));
833 VS::FrameInfo frame_info;
834 FS::FragInfo frag_info;
836 raw_ptr<const Sampler> src_sampler =
837 renderer.GetContext()->GetSamplerLibrary()->GetSampler(
838 src_sampler_descriptor);
839 FS::BindTextureSamplerSrc(pass, src_texture, src_sampler);
842 frame_info.src_y_coord_scale = src_texture->GetYCoordScale();
843 VS::BindFrameInfo(pass, host_buffer.EmplaceUniform(frame_info));
845 frag_info.src_input_alpha = 1.0;
846 frag_info.dst_input_alpha =
848 ? dst_snapshot->opacity
850 FS::BindFragInfo(pass, host_buffer.EmplaceUniform(frag_info));
852 return pass.Draw().ok();
856 std::shared_ptr<CommandBuffer> cmd_buffer =
857 renderer.GetContext()->CreateCommandBuffer();
860 if (foreground_color.has_value()) {
861 TextureDescriptor desc;
866 renderer.GetContext()->GetResourceAllocator()->CreateTexture(desc);
867 if (!foreground_texture) {
870 std::shared_ptr<BlitPass> blit_pass = cmd_buffer->CreateBlitPass();
871 auto buffer_view = renderer.GetTransientsBuffer().Emplace(
872 foreground_color->Premultiply().ToR8G8B8A8(), 4);
874 blit_pass->AddCopy(std::move(
buffer_view), foreground_texture);
875 if (!blit_pass->EncodeCommands()) {
880 fml::StatusOr<RenderTarget> render_target =
881 renderer.MakeSubpass(
"FramebufferBlend",
882 dst_snapshot->texture->GetSize(),
889 if (!render_target.ok()) {
892 if (!renderer.GetContext()->EnqueueCommandBuffer(std::move(cmd_buffer))) {
898 .texture = render_target.value().GetRenderTargetTexture(),
903 .sampler_descriptor = {},
906 : dst_snapshot->opacity) *
907 alpha.value_or(1.0)},
908 entity.GetBlendMode());
911 #define BLEND_CASE(mode) \
912 case BlendMode::k##mode: \
913 advanced_blend_proc_ = \
914 [](const FilterInput::Vector& inputs, const ContentContext& renderer, \
915 const Entity& entity, const Rect& coverage, BlendMode blend_mode, \
916 std::optional<Color> fg_color, \
917 ColorFilterContents::AbsorbOpacity absorb_opacity, \
918 std::optional<Scalar> alpha) { \
919 PipelineProc p = &ContentContext::GetBlend##mode##Pipeline; \
920 return AdvancedBlend<Blend##mode##Pipeline>( \
921 inputs, renderer, entity, coverage, blend_mode, fg_color, \
922 absorb_opacity, p, alpha); \
928 VALIDATION_LOG <<
"Invalid blend mode " <<
static_cast<int>(blend_mode)
929 <<
" assigned to BlendFilterContents.";
932 blend_mode_ = blend_mode;
935 switch (blend_mode) {
958 foreground_color_ = color;
961 std::optional<Entity> BlendFilterContents::RenderFilter(
965 const Matrix& effect_transform,
966 const Rect& coverage,
967 const std::optional<Rect>& coverage_hint)
const {
968 if (inputs.empty()) {
972 if (inputs.size() == 1 && !foreground_color_.has_value()) {
979 if (inputs.size() == 1 && foreground_color_.has_value() &&
981 return CreateForegroundPorterDuffBlend(
982 inputs[0], renderer, entity, coverage, foreground_color_.value(),
985 return PipelineBlend(inputs, renderer, entity, coverage, blend_mode_,
991 return CreateFramebufferAdvancedBlend(inputs, renderer, entity, coverage,
992 foreground_color_, blend_mode_,
995 if (inputs.size() == 1 && foreground_color_.has_value() &&
997 return CreateForegroundAdvancedBlend(
998 inputs[0], renderer, entity, coverage, foreground_color_.value(),
1001 return advanced_blend_proc_(inputs, renderer, entity, coverage, blend_mode_,
static std::shared_ptr< Contents > Make(RenderProc render_proc, CoverageProc coverage_proc)
~BlendFilterContents() override
void SetBlendMode(BlendMode blend_mode)
void SetForegroundColor(std::optional< Color > color)
Sets a source color which is blended after all of the inputs have been blended.
virtual bool SupportsFramebufferFetch() const =0
Whether the context backend is able to support pipelines with shaders that read from the framebuffer ...
std::optional< Scalar > GetAlpha() const
AbsorbOpacity GetAbsorbOpacity() const
HostBuffer & GetTransientsBuffer() const
Retrieve the currnent host buffer for transient storage.
fml::StatusOr< RenderTarget > MakeSubpass(std::string_view label, ISize texture_size, const std::shared_ptr< CommandBuffer > &command_buffer, const SubpassCallback &subpass_callback, bool msaa_enabled=true, bool depth_stencil_enabled=false, int32_t mip_count=1) const
Creates a new texture of size texture_size and calls subpass_callback with a RenderPass for drawing t...
const Capabilities & GetDeviceCapabilities() const
PipelineRef GetTexturePipeline(ContentContextOptions opts) const
std::function< bool(const ContentContext &, RenderPass &)> SubpassCallback
std::shared_ptr< Context > GetContext() const
std::function< std::optional< Rect >(const Entity &entity)> CoverageProc
std::function< bool(const ContentContext &renderer, const Entity &entity, RenderPass &pass)> RenderProc
const std::shared_ptr< Contents > & GetContents() const
Matrix GetShaderTransform(const RenderPass &pass) const
BlendMode GetBlendMode() const
void SetContents(std::shared_ptr< Contents > contents)
void SetBlendMode(BlendMode blend_mode)
static constexpr BlendMode kLastAdvancedBlendMode
bool Render(const ContentContext &renderer, RenderPass &parent_pass) const
static constexpr BlendMode kLastPipelineBlendMode
static Entity FromSnapshot(const Snapshot &snapshot, BlendMode blend_mode=BlendMode::kSrcOver)
Create an entity that can be used to render a given snapshot.
Render passes encode render commands directed as one specific render target into an underlying comman...
VertexShader_ VertexShader
FragmentShader_ FragmentShader
#define IMPELLER_FOR_EACH_BLEND_MODE(V)
static constexpr Scalar Saturation(Vector3 color)
raw_ptr< Pipeline< PipelineDescriptor > > PipelineRef
A raw ptr to a pipeline object.
LinePipeline::FragmentShader FS
VertexBuffer CreateVertexBuffer(std::array< VertexType, size > input, HostBuffer &host_buffer)
Create an index-less vertex buffer from a fixed size array.
std::optional< BlendMode > InvertPorterDuffBlend(BlendMode blend_mode)
static std::optional< Entity > PipelineBlend(const FilterInput::Vector &inputs, const ContentContext &renderer, const Entity &entity, const Rect &coverage, BlendMode blend_mode, std::optional< Color > foreground_color, ColorFilterContents::AbsorbOpacity absorb_opacity, std::optional< Scalar > alpha)
LinePipeline::VertexShader VS
PipelineRef(ContentContext::*)(ContentContextOptions) const PipelineProc
ContentContextOptions OptionsFromPassAndEntity(const RenderPass &pass, const Entity &entity)
ContentContextOptions OptionsFromPass(const RenderPass &pass)
static std::optional< Entity > AdvancedBlend(const FilterInput::Vector &inputs, const ContentContext &renderer, const Entity &entity, const Rect &coverage, BlendMode blend_mode, std::optional< Color > foreground_color, ColorFilterContents::AbsorbOpacity absorb_opacity, PipelineProc pipeline_proc, std::optional< Scalar > alpha)
static constexpr Scalar Luminosity(Vector3 color)
A 4x4 matrix using column-major storage.
static constexpr Matrix MakeOrthographic(TSize< T > size)
static constexpr Matrix MakeTranslation(const Vector3 &t)
Represents a texture and its intended draw transform/sampler configuration.
std::shared_ptr< Texture > texture
constexpr TPoint< Type > GetOrigin() const
Returns the upper left corner of the rectangle as specified by the left/top or x/y values when it was...
constexpr std::optional< TRect > Intersection(const TRect &o) const
constexpr TSize< Type > GetSize() const
Returns the size of the rectangle which may be negative in either width or height and may have been c...
constexpr static TRect MakeSize(const TSize< U > &size)