render__pass__gles__unittests_8cc_source.html

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

#include "flutter/testing/testing.h"  // IWYU pragma: keep

#include "gmock/gmock.h"

#include "gtest/gtest.h"

#include "impeller/core/device_buffer.h"

#include "impeller/core/formats.h"

#include "impeller/renderer/backend/gles/command_buffer_gles.h"

#include "impeller/renderer/backend/gles/context_gles.h"

#include "impeller/renderer/backend/gles/pipeline_gles.h"

#include "impeller/renderer/backend/gles/proc_table_gles.h"

#include "impeller/renderer/backend/gles/reactor_gles.h"

#include "impeller/renderer/backend/gles/test/mock_gles.h"

#include "impeller/renderer/backend/gles/texture_gles.h"

#include "impeller/renderer/backend/gles/unique_handle_gles.h"

#include "impeller/renderer/context.h"

#include "impeller/renderer/render_pass.h"

#include "impeller/renderer/render_target.h"


namespace impeller {

namespace testing {


using ::testing::_;

using ::testing::Args;

using ::testing::ElementsAreArray;

using ::testing::NiceMock;

using ::testing::Return;

using ::testing::SetArgPointee;

using ::testing::TestWithParam;


class TestReactorGLES : public ReactorGLES {

 public:


  TestReactorGLES()

      : ReactorGLES(std::make_unique<ProcTableGLES>(kMockResolverGLES)) {}


  ~TestReactorGLES() = default;

};


class MockWorker final : public ReactorGLES::Worker {

 public:

  MockWorker() = default;


  // |ReactorGLES::Worker|


  bool CanReactorReactOnCurrentThreadNow(

      const ReactorGLES& reactor) const override {

    return true;

  }


};


struct DiscardFrameBufferParams {

  GLuint frame_buffer_id;

  std::array<GLenum, 3> expected_attachments;

};


class RenderPassGLESWithDiscardFrameBufferExtTest

    : public TestWithParam<DiscardFrameBufferParams> {};


namespace {

std::shared_ptr<ContextGLES> CreateFakeGLESContext(

    ProcTableGLES::Resolver resolver = kMockResolverGLES) {

  auto dummy_gl_procs = std::make_unique<ProcTableGLES>(std::move(resolver));

  auto dummy_shader_library = std::vector<std::shared_ptr<fml::Mapping>>{};

  auto flags = Flags{};

  return ContextGLES::Create(flags, std::move(dummy_gl_procs),

                             dummy_shader_library, false);

}


struct RenderPassGLESContext {

  std::shared_ptr<MockGLES> mock_gl;

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref;

  std::shared_ptr<ContextGLES> context;

  std::shared_ptr<MockWorker> dummy_worker;

  std::shared_ptr<ReactorGLES> reactor;

  std::shared_ptr<CommandBuffer> command_buffer;

  std::shared_ptr<RenderPass> render_pass;

  std::shared_ptr<PipelineGLES> pipeline;

};

}  // namespace


TEST_P(RenderPassGLESWithDiscardFrameBufferExtTest, DiscardFramebufferExt) {

  auto mock_gl_impl = std::make_unique<NiceMock<MockGLESImpl>>();

  auto& mock_gl_impl_ref = *mock_gl_impl;

  auto mock_gl =

      MockGLES::Init(std::move(mock_gl_impl), {{"GL_EXT_discard_framebuffer"}},

                     "OpenGL ES 2.0");


  auto context = CreateFakeGLESContext();

  auto dummy_worker = std::make_shared<MockWorker>();

  context->AddReactorWorker(dummy_worker);

  auto reactor = context->GetReactor();


  const auto command_buffer =

      std::static_pointer_cast<Context>(context)->CreateCommandBuffer();

  auto render_target = RenderTarget{};

  const auto description = TextureDescriptor{

      .format = PixelFormat::kR8G8B8A8UNormInt, .size = {10, 10}};


  const auto& test_params = GetParam();

  auto framebuffer_texture =

      TextureGLES::WrapFBO(reactor, description, test_params.frame_buffer_id);


  auto color_attachment = ColorAttachment{Attachment{

      .texture = framebuffer_texture, .store_action = StoreAction::kDontCare}};

  render_target.SetColorAttachment(color_attachment, 0);

  const auto render_pass = command_buffer->CreateRenderPass(render_target);


  EXPECT_CALL(mock_gl_impl_ref, GetIntegerv(GL_FRAMEBUFFER_BINDING, _))

      .WillOnce(SetArgPointee<1>(test_params.frame_buffer_id));


  EXPECT_CALL(mock_gl_impl_ref, DiscardFramebufferEXT(GL_FRAMEBUFFER, _, _))

      .With(Args<2, 1>(ElementsAreArray(test_params.expected_attachments)))

      .Times(1);

  ASSERT_TRUE(render_pass->EncodeCommands());

  ASSERT_TRUE(reactor->React());

}


INSTANTIATE_TEST_SUITE_P(

    FrameBufferObject,

    RenderPassGLESWithDiscardFrameBufferExtTest,

    ::testing::ValuesIn(std::vector<DiscardFrameBufferParams>{

        {.frame_buffer_id = 0,

         .expected_attachments = {GL_COLOR_EXT, GL_DEPTH_EXT, GL_STENCIL_EXT}},

        {.frame_buffer_id = 1,

         .expected_attachments = {GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT,

                                  GL_STENCIL_ATTACHMENT}}}),

    [](const ::testing::TestParamInfo<DiscardFrameBufferParams>& info) {

      return (info.param.frame_buffer_id == 0) ? "Default" : "NonDefault";

    });


TEST_P(RenderPassGLESWithDiscardFrameBufferExtTest, InvalidateFramebuffer) {

  auto mock_gl_impl = std::make_unique<NiceMock<MockGLESImpl>>();

  auto& mock_gl_impl_ref = *mock_gl_impl;

  auto mock_gl =

      MockGLES::Init(std::move(mock_gl_impl), std::nullopt, "OpenGL ES 3.0");


  auto context = CreateFakeGLESContext();

  auto dummy_worker = std::make_shared<MockWorker>();

  context->AddReactorWorker(dummy_worker);

  auto reactor = context->GetReactor();


  const auto command_buffer =

      std::static_pointer_cast<Context>(context)->CreateCommandBuffer();

  auto render_target = RenderTarget{};

  const auto description = TextureDescriptor{

      .format = PixelFormat::kR8G8B8A8UNormInt, .size = {10, 10}};


  const auto& test_params = GetParam();

  auto framebuffer_texture =

      TextureGLES::WrapFBO(reactor, description, test_params.frame_buffer_id);


  auto color_attachment = ColorAttachment{Attachment{

      .texture = framebuffer_texture, .store_action = StoreAction::kDontCare}};

  render_target.SetColorAttachment(color_attachment, 0);

  const auto render_pass = command_buffer->CreateRenderPass(render_target);


  EXPECT_CALL(mock_gl_impl_ref, GetIntegerv(GL_FRAMEBUFFER_BINDING, _))

      .WillOnce(SetArgPointee<1>(test_params.frame_buffer_id));


  // InvalidateFramebuffer should be called instead of DiscardFramebufferEXT

  EXPECT_CALL(mock_gl_impl_ref, InvalidateFramebuffer(GL_FRAMEBUFFER, _, _))

      .With(Args<2, 1>(ElementsAreArray(test_params.expected_attachments)))

      .Times(1);

  EXPECT_CALL(mock_gl_impl_ref, DiscardFramebufferEXT(GL_FRAMEBUFFER, _, _))

      .Times(0);


  ASSERT_TRUE(render_pass->EncodeCommands());

  ASSERT_TRUE(reactor->React());

}


TEST(RenderPassGLESTest, ResolvingMultisampleTextureCachesResolveFBO) {

  auto mock_gl_impl = std::make_unique<NiceMock<MockGLESImpl>>();

  auto& mock_gl_impl_ref = *mock_gl_impl;

  // Make sure implicit resolving isn't supported so we go down explicit path.

  auto mock_gl =

      MockGLES::Init(std::move(mock_gl_impl), std::nullopt, "OpenGL ES 3.0");


  auto context = CreateFakeGLESContext();

  auto dummy_worker = std::make_shared<MockWorker>();

  context->AddReactorWorker(dummy_worker);

  auto reactor = context->GetReactor();


  const auto command_buffer =

      std::static_pointer_cast<Context>(context)->CreateCommandBuffer();


  const auto msaa_desc =

      TextureDescriptor{.type = TextureType::kTexture2DMultisample,

                        .format = PixelFormat::kR8G8B8A8UNormInt,

                        .size = {10, 10},

                        .usage = TextureUsage::kRenderTarget,

                        .sample_count = SampleCount::kCount4};

  const auto resolve_desc =

      TextureDescriptor{.storage_mode = StorageMode::kDevicePrivate,

                        .type = TextureType::kTexture2D,

                        .format = PixelFormat::kR8G8B8A8UNormInt,

                        .size = {10, 10},

                        .usage = TextureUsage::kRenderTarget,

                        .sample_count = SampleCount::kCount1};


  auto msaa_tex = std::make_shared<TextureGLES>(reactor, msaa_desc);

  auto resolve_tex = std::make_shared<TextureGLES>(reactor, resolve_desc);


  auto render_target = RenderTarget{};

  auto color_attachment = ColorAttachment{Attachment{

      .texture = msaa_tex,

      .resolve_texture = resolve_tex,

      .load_action = LoadAction::kClear,

      .store_action = StoreAction::kMultisampleResolve,

  }};

  color_attachment.clear_color = Color::Black();

  render_target.SetColorAttachment(color_attachment, 0);


  EXPECT_CALL(mock_gl_impl_ref, CheckFramebufferStatus(_))

      .WillRepeatedly(Return(GL_FRAMEBUFFER_COMPLETE));


  // Expect GenFramebuffers is called exactly once for the offscreen FBO,

  // and exactly once for the resolve FBO over two passes.

  EXPECT_CALL(mock_gl_impl_ref, GenFramebuffers(_, _)).Times(2);


  {

    const auto render_pass = command_buffer->CreateRenderPass(render_target);

    ASSERT_TRUE(render_pass->EncodeCommands());

    ASSERT_TRUE(reactor->React());

  }

  {

    const auto render_pass2 = command_buffer->CreateRenderPass(render_target);

    ASSERT_TRUE(render_pass2->EncodeCommands());

    ASSERT_TRUE(reactor->React());

  }

}


class RenderPassGLESCommandTest : public ::testing::Test {

 protected:

  // Builds a mock OpenGL ES context with a render pass and a minimal

  // pipeline. The [resolver] controls which GL entry points the backend can

  // see, which is how a caller selects the hardware or emulated instancing

  // path.


  static RenderPassGLESContext CreateRenderPassGLESContext(

      ProcTableGLES::Resolver resolver = kMockResolverGLES) {

    std::unique_ptr<NiceMock<MockGLESImpl>> mock_gl_impl =

        std::make_unique<NiceMock<MockGLESImpl>>();

    testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = *mock_gl_impl;

    std::shared_ptr<MockGLES> mock_gl = MockGLES::Init(std::move(mock_gl_impl));


    std::shared_ptr<ContextGLES> context =

        CreateFakeGLESContext(std::move(resolver));

    std::shared_ptr<MockWorker> dummy_worker = std::make_shared<MockWorker>();

    context->AddReactorWorker(dummy_worker);

    std::shared_ptr<ReactorGLES> reactor = context->GetReactor();


    TextureDescriptor tex_desc;

    tex_desc.size = {100, 100};

    tex_desc.format = PixelFormat::kR8G8B8A8UNormInt;

    auto texture = std::make_shared<TextureGLES>(reactor, tex_desc, false);


    RenderTarget target;

    ColorAttachment color0;

    color0.texture = texture;

    color0.store_action = StoreAction::kDontCare;

    color0.load_action = LoadAction::kClear;

    target.SetColorAttachment(color0, 0);


    std::shared_ptr<CommandBuffer> command_buffer =

        std::static_pointer_cast<Context>(context)->CreateCommandBuffer();

    std::shared_ptr<RenderPass> render_pass =

        command_buffer->CreateRenderPass(target);


    EXPECT_CALL(mock_gl_impl_ref, CheckFramebufferStatus(_))

        .WillRepeatedly(Return(GL_FRAMEBUFFER_COMPLETE));


    PipelineDescriptor desc;

    ColorAttachmentDescriptor color0_desc;

    color0_desc.format = PixelFormat::kR8G8B8A8UNormInt;

    desc.SetColorAttachmentDescriptor(0, color0_desc);


    HandleGLES pipeline_handle = reactor->CreateHandle(HandleType::kProgram);

    std::shared_ptr<PipelineGLES> pipeline =

        std::shared_ptr<PipelineGLES>(new PipelineGLES(

            reactor, std::weak_ptr<PipelineLibrary>(), desc,

            std::make_shared<UniqueHandleGLES>(reactor, pipeline_handle)));

    pipeline->buffer_bindings_ = std::make_unique<BufferBindingsGLES>();


    return {std::move(mock_gl),     mock_gl_impl_ref,

            std::move(context),     std::move(dummy_worker),

            std::move(reactor),     std::move(command_buffer),

            std::move(render_pass), std::move(pipeline)};

  }


};


TEST_F(RenderPassGLESCommandTest, ViewportCachedAcrossCommands) {

  auto ctx = CreateRenderPassGLESContext();

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(1);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  EXPECT_TRUE(render_pass->Draw().ok());


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(1);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  render_pass->SetViewport(

      Viewport{Rect::MakeXYWH(0, 0, 50, 50), DepthRange{0.0f, 1.0f}});

  EXPECT_TRUE(render_pass->Draw().ok());


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(1);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  render_pass->SetViewport(

      Viewport{Rect::MakeXYWH(0, 0, 50, 50), DepthRange{0.0f, 1.0f}});

  EXPECT_TRUE(render_pass->Draw().ok());


  // Viewport should only be called twice. Once for the fallback, once for the

  // first override. We set a catch-all to 0 to ensure no other calls occur.

  EXPECT_CALL(mock_gl_impl_ref, Viewport(_, _, _, _)).Times(0);

  EXPECT_CALL(mock_gl_impl_ref, Viewport(0, 0, 100, 100)).Times(1);

  EXPECT_CALL(mock_gl_impl_ref, Viewport(0, 0, 50, 50)).Times(1);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


TEST_F(RenderPassGLESCommandTest,

       CommandsWithoutViewportGetRenderPassViewport) {

  auto ctx = CreateRenderPassGLESContext();

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(1);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  EXPECT_TRUE(render_pass->Draw().ok());


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(1);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  render_pass->SetViewport(

      Viewport{Rect::MakeXYWH(0, 0, 50, 50), DepthRange{0.0f, 1.0f}});

  EXPECT_TRUE(render_pass->Draw().ok());


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(1);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  EXPECT_TRUE(render_pass->Draw().ok());


  EXPECT_CALL(mock_gl_impl_ref, Viewport(_, _, _, _)).Times(0);

  EXPECT_CALL(mock_gl_impl_ref, Viewport(0, 0, 100, 100)).Times(2);

  EXPECT_CALL(mock_gl_impl_ref, Viewport(0, 0, 50, 50)).Times(1);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


// Sibling regression guard for the bug fixed alongside this test on the

// Vulkan backend. The GLES backend has always honored the X offset; this

// asserts that explicitly so a future change can't silently regress it.


TEST_F(RenderPassGLESCommandTest, ViewportWithNonZeroXOffsetReachesGL) {

  auto ctx = CreateRenderPassGLESContext();

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(1);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  render_pass->SetViewport(

      Viewport{Rect::MakeXYWH(25, 0, 50, 100), DepthRange{0.0f, 1.0f}});

  EXPECT_TRUE(render_pass->Draw().ok());


  EXPECT_CALL(mock_gl_impl_ref, Viewport(_, _, _, _)).Times(0);

  EXPECT_CALL(mock_gl_impl_ref, Viewport(25, 0, 50, 100)).Times(1);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


// When the driver exposes the hardware instancing entry points, a

// non-indexed instanced command issues a single glDrawArraysInstanced call

// that carries the instance count.


TEST_F(RenderPassGLESCommandTest, HardwareInstancedArrayDraw) {

  auto ctx = CreateRenderPassGLESContext();

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(3);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  render_pass->SetInstanceCount(4);

  EXPECT_TRUE(render_pass->Draw().ok());


  EXPECT_CALL(mock_gl_impl_ref,

              DrawArraysInstanced(/*mode=*/_, /*first=*/0, /*count=*/3,

                                  /*instancecount=*/4))

      .Times(1);

  EXPECT_CALL(mock_gl_impl_ref, DrawArrays(_, _, _)).Times(0);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


// The indexed counterpart: a hardware instanced indexed command issues a

// single glDrawElementsInstanced call.


TEST_F(RenderPassGLESCommandTest, HardwareInstancedElementsDraw) {

  auto ctx = CreateRenderPassGLESContext();

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  DeviceBufferDescriptor index_desc;

  index_desc.size = 6 * sizeof(uint16_t);

  index_desc.storage_mode = StorageMode::kHostVisible;

  auto index_buffer = std::static_pointer_cast<Context>(ctx.context)

                          ->GetResourceAllocator()

                          ->CreateBuffer(index_desc);

  ASSERT_TRUE(index_buffer);


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(6);

  ASSERT_TRUE(render_pass->SetIndexBuffer(

      DeviceBuffer::AsBufferView(index_buffer), IndexType::k16bit));

  render_pass->SetInstanceCount(4);

  EXPECT_TRUE(render_pass->Draw().ok());


  EXPECT_CALL(mock_gl_impl_ref,

              DrawElementsInstanced(/*mode=*/_, /*count=*/6, /*type=*/_,

                                    /*indices=*/_, /*instancecount=*/4))

      .Times(1);

  EXPECT_CALL(mock_gl_impl_ref, DrawElements(_, _, _, _)).Times(0);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


// When the hardware instancing entry points are missing, a non-indexed

// instanced command is emulated by repeating the plain draw once per

// instance.


TEST_F(RenderPassGLESCommandTest, EmulatedInstancedArrayDraw) {

  auto ctx = CreateRenderPassGLESContext(kMockResolverGLESWithoutInstancing);

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(3);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  render_pass->SetInstanceCount(4);

  EXPECT_TRUE(render_pass->Draw().ok());


  EXPECT_CALL(mock_gl_impl_ref,

              DrawArrays(/*mode=*/_, /*first=*/0, /*count=*/3))

      .Times(4);

  EXPECT_CALL(mock_gl_impl_ref, DrawArraysInstanced(_, _, _, _)).Times(0);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


// The indexed counterpart of the emulation path: the plain indexed draw is

// repeated once per instance.


TEST_F(RenderPassGLESCommandTest, EmulatedInstancedElementsDraw) {

  auto ctx = CreateRenderPassGLESContext(kMockResolverGLESWithoutInstancing);

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  DeviceBufferDescriptor index_desc;

  index_desc.size = 6 * sizeof(uint16_t);

  index_desc.storage_mode = StorageMode::kHostVisible;

  auto index_buffer = std::static_pointer_cast<Context>(ctx.context)

                          ->GetResourceAllocator()

                          ->CreateBuffer(index_desc);

  ASSERT_TRUE(index_buffer);


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(6);

  ASSERT_TRUE(render_pass->SetIndexBuffer(

      DeviceBuffer::AsBufferView(index_buffer), IndexType::k16bit));

  render_pass->SetInstanceCount(4);

  EXPECT_TRUE(render_pass->Draw().ok());


  EXPECT_CALL(mock_gl_impl_ref,

              DrawElements(/*mode=*/_, /*count=*/6, /*type=*/_, /*indices=*/_))

      .Times(4);

  EXPECT_CALL(mock_gl_impl_ref, DrawElementsInstanced(_, _, _, _, _)).Times(0);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


// Regression guard: a command with no instance count set draws a single

// instance through the plain, non-instanced entry point.


TEST_F(RenderPassGLESCommandTest, NonInstancedDrawIssuesSingleDrawArrays) {

  auto ctx = CreateRenderPassGLESContext();

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(3);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  EXPECT_TRUE(render_pass->Draw().ok());


  EXPECT_CALL(mock_gl_impl_ref,

              DrawArrays(/*mode=*/_, /*first=*/0, /*count=*/3))

      .Times(1);

  EXPECT_CALL(mock_gl_impl_ref, DrawArraysInstanced(_, _, _, _)).Times(0);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


// A command with an explicit instance count of zero draws nothing, matching

// the Metal and Vulkan backends.


TEST_F(RenderPassGLESCommandTest, ZeroInstanceCountIssuesNoDraw) {

  auto ctx = CreateRenderPassGLESContext();

  testing::NiceMock<MockGLESImpl>& mock_gl_impl_ref = ctx.mock_gl_impl_ref;

  std::shared_ptr<RenderPass>& render_pass = ctx.render_pass;

  std::shared_ptr<PipelineGLES>& pipeline = ctx.pipeline;

  std::shared_ptr<ReactorGLES>& reactor = ctx.reactor;


  render_pass->SetPipeline(PipelineRef(pipeline));

  render_pass->SetElementCount(3);

  render_pass->SetIndexBuffer({}, IndexType::kNone);

  render_pass->SetInstanceCount(0);

  EXPECT_TRUE(render_pass->Draw().ok());


  EXPECT_CALL(mock_gl_impl_ref, DrawArrays(_, _, _)).Times(0);

  EXPECT_CALL(mock_gl_impl_ref, DrawArraysInstanced(_, _, _, _)).Times(0);


  EXPECT_TRUE(render_pass->EncodeCommands());

  EXPECT_TRUE(reactor->React());

}


}  // namespace testing

}  // namespace impeller

impeller::ContextGLES::Create
static std::shared_ptr< ContextGLES > Create(const Flags &flags, std::unique_ptr< ProcTableGLES > gl, const std::vector< std::shared_ptr< fml::Mapping > > &shader_libraries, bool enable_gpu_tracing)
Definition context_gles.cc:21

impeller::DeviceBuffer::AsBufferView
static BufferView AsBufferView(std::shared_ptr< DeviceBuffer > buffer)
Create a buffer view of this entire buffer.
Definition device_buffer.cc:18

impeller::HandleGLES
Represents a handle to an underlying OpenGL object. Unlike OpenGL object handles, these handles can b...
Definition handle_gles.h:42

impeller::PipelineDescriptor
Definition pipeline_descriptor.h:24

impeller::PipelineDescriptor::SetColorAttachmentDescriptor
PipelineDescriptor & SetColorAttachmentDescriptor(size_t index, ColorAttachmentDescriptor desc)
Definition pipeline_descriptor.cc:111

impeller::PipelineGLES
Definition pipeline_gles.h:24

impeller::ProcTableGLES
Definition proc_table_gles.h:307

impeller::ProcTableGLES::Resolver
std::function< void *(const char *function_name)> Resolver
Definition proc_table_gles.h:309

impeller::ReactorGLES::Worker
A delegate implemented by a thread on which an OpenGL context is current. There may be multiple worke...
Definition reactor_gles.h:69

impeller::ReactorGLES
The reactor attempts to make thread-safe usage of OpenGL ES easier to reason about.
Definition reactor_gles.h:57

impeller::RenderTarget
Definition render_target.h:38

impeller::TextureGLES::WrapFBO
static std::shared_ptr< TextureGLES > WrapFBO(std::shared_ptr< ReactorGLES > reactor, TextureDescriptor desc, GLuint fbo)
Create a texture by wrapping an external framebuffer object whose lifecycle is owned by the caller.
Definition texture_gles.cc:95

impeller::testing::MockGLES::Init
static std::shared_ptr< MockGLES > Init(std::unique_ptr< MockGLESImpl > impl, const std::optional< std::vector< const char * > > &extensions=std::nullopt, const char *version_string="OpenGL ES 3.0")
Definition mock_gles.cc:417

impeller::testing::MockWorker
Definition blit_command_gles_unittests.cc:30

impeller::testing::MockWorker::MockWorker
MockWorker()=default

impeller::testing::MockWorker::CanReactorReactOnCurrentThreadNow
bool CanReactorReactOnCurrentThreadNow(const ReactorGLES &reactor) const override
Determines the ability of the worker to service a reaction on the current thread. The OpenGL context ...
Definition render_pass_gles_unittests.cc:47

impeller::testing::RenderPassGLESCommandTest
Definition render_pass_gles_unittests.cc:234

impeller::testing::RenderPassGLESCommandTest::CreateRenderPassGLESContext
static RenderPassGLESContext CreateRenderPassGLESContext(ProcTableGLES::Resolver resolver=kMockResolverGLES)
Definition render_pass_gles_unittests.cc:240

impeller::testing::RenderPassGLESWithDiscardFrameBufferExtTest
Definition render_pass_gles_unittests.cc:59

impeller::testing::TestReactorGLES::TestReactorGLES
TestReactorGLES()
Definition render_pass_gles_unittests.cc:36

impeller::testing::TestReactorGLES::~TestReactorGLES
~TestReactorGLES()=default

command_buffer_gles.h

target
uint32_t * target
Definition fl_texture_registrar_test.cc:41

device_buffer.h

formats.h

context.h

render_pass.h

mock_gles.h

texture
FlTexture * texture
Definition mock_texture_registrar.cc:24

flutter::TEST
TEST(FrameTimingsRecorderTest, RecordVsync)
Definition frame_timings_recorder_unittests.cc:22

impeller::testing::kMockResolverGLESWithoutInstancing
const ProcTableGLES::Resolver kMockResolverGLESWithoutInstancing
Definition mock_gles.cc:545

impeller::testing::TEST_P
TEST_P(AiksTest, DrawAtlasNoColor)
Definition aiks_dl_atlas_unittests.cc:60

impeller::testing::kMockResolverGLES
const ProcTableGLES::Resolver kMockResolverGLES
Definition mock_gles.cc:459

impeller::testing::TEST_F
TEST_F(GoldenTests, ConicalGradient)
Definition golden_tests.cc:80

impeller::testing::INSTANTIATE_TEST_SUITE_P
INSTANTIATE_TEST_SUITE_P(FrameBufferObject, RenderPassGLESWithDiscardFrameBufferExtTest, ::testing::ValuesIn(std::vector< DiscardFrameBufferParams >{ {.frame_buffer_id=0,.expected_attachments={GL_COLOR_EXT, GL_DEPTH_EXT, GL_STENCIL_EXT}}, {.frame_buffer_id=1,.expected_attachments={GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT}}}), [](const ::testing::TestParamInfo< DiscardFrameBufferParams > &info) { return(info.param.frame_buffer_id==0) ? "Default" :"NonDefault";})

impeller
Definition texture.h:16

impeller::IndexType::k16bit
@ k16bit

impeller::IndexType::kNone
@ kNone
Does not use the index buffer.

impeller::StorageMode::kDevicePrivate
@ kDevicePrivate

impeller::StorageMode::kHostVisible
@ kHostVisible

impeller::PipelineRef
raw_ptr< Pipeline< PipelineDescriptor > > PipelineRef
A raw ptr to a pipeline object.
Definition pipeline.h:89

impeller::PixelFormat::kR8G8B8A8UNormInt
@ kR8G8B8A8UNormInt

impeller::TextureType::kTexture2DMultisample
@ kTexture2DMultisample

impeller::TextureType::kTexture2D
@ kTexture2D

impeller::LoadAction::kClear
@ kClear

impeller::StoreAction::kDontCare
@ kDontCare

impeller::StoreAction::kMultisampleResolve
@ kMultisampleResolve

impeller::HandleType::kProgram
@ kProgram

impeller::TextureUsage::kRenderTarget
@ kRenderTarget

impeller::SampleCount::kCount4
@ kCount4

impeller::SampleCount::kCount1
@ kCount1

std
Definition ref_ptr.h:261

pipeline_gles.h

proc_table_gles.h

reactor_gles.h

dummy_worker
std::shared_ptr< MockWorker > dummy_worker
Definition render_pass_gles_unittests.cc:75

reactor
std::shared_ptr< ReactorGLES > reactor
Definition render_pass_gles_unittests.cc:76

context
std::shared_ptr< ContextGLES > context
Definition render_pass_gles_unittests.cc:74

render_pass
std::shared_ptr< RenderPass > render_pass
Definition render_pass_gles_unittests.cc:78

mock_gl_impl_ref
testing::NiceMock< MockGLESImpl > & mock_gl_impl_ref
Definition render_pass_gles_unittests.cc:73

pipeline
std::shared_ptr< PipelineGLES > pipeline
Definition render_pass_gles_unittests.cc:79

mock_gl
std::shared_ptr< MockGLES > mock_gl
Definition render_pass_gles_unittests.cc:72

command_buffer
std::shared_ptr< CommandBuffer > command_buffer
Definition render_pass_gles_unittests.cc:77

render_target.h

context_gles.h

impeller::Attachment
Definition formats.h:908

impeller::Attachment::load_action
LoadAction load_action
Definition formats.h:911

impeller::Attachment::texture
std::shared_ptr< Texture > texture
Definition formats.h:909

impeller::Attachment::store_action
StoreAction store_action
Definition formats.h:912

impeller::ColorAttachmentDescriptor
Describe the color attachment that will be used with this pipeline.
Definition formats.h:770

impeller::ColorAttachmentDescriptor::format
PixelFormat format
Definition formats.h:771

impeller::ColorAttachment
Definition formats.h:923

impeller::Color::Black
static constexpr Color Black()
Definition color.h:271

impeller::DepthRange
Definition formats.h:571

impeller::DeviceBufferDescriptor
Definition device_buffer_descriptor.h:14

impeller::DeviceBufferDescriptor::storage_mode
StorageMode storage_mode
Definition device_buffer_descriptor.h:15

impeller::DeviceBufferDescriptor::size
size_t size
Definition device_buffer_descriptor.h:16

impeller::Flags
Definition flags.h:9

impeller::TRect< Scalar >::MakeXYWH
static constexpr TRect MakeXYWH(Type x, Type y, Type width, Type height)
Definition rect.h:136

impeller::TextureDescriptor
A lightweight object that describes the attributes of a texture that can then used an allocator to cr...
Definition texture_descriptor.h:38

impeller::TextureDescriptor::type
TextureType type
Definition texture_descriptor.h:40

impeller::TextureDescriptor::size
ISize size
Definition texture_descriptor.h:42

impeller::TextureDescriptor::storage_mode
StorageMode storage_mode
Definition texture_descriptor.h:39

impeller::TextureDescriptor::format
PixelFormat format
Definition texture_descriptor.h:41

impeller::Viewport
Definition formats.h:580

impeller::testing::DiscardFrameBufferParams
Definition render_pass_gles_unittests.cc:53

impeller::testing::DiscardFrameBufferParams::frame_buffer_id
GLuint frame_buffer_id
Definition render_pass_gles_unittests.cc:54

impeller::testing::DiscardFrameBufferParams::expected_attachments
std::array< GLenum, 3 > expected_attachments
Definition render_pass_gles_unittests.cc:55

testing.h

texture_gles.h

unique_handle_gles.h