test.cc

TEST_P(RendererTest, BabysFirstTriangle2) {
  auto context = GetContext();
  ASSERT_TRUE(context);

  using VS = BabyVertexShader;
  using FS = BabyFragmentShader;
  auto desc = PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
  ASSERT_TRUE(desc.has_value());

  ColorAttachmentDescriptor color0;
  color0.blending_enabled = true;
  color0.format = PixelFormat::kB10G10R10A10XR;

  desc->SetColorAttachmentDescriptor(0, color0);
  desc->SetSampleCount(SampleCount::kCount4);
  desc->SetStencilAttachmentDescriptors(std::nullopt);

  auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
  auto host_buffer = HostBuffer::Create(context->GetResourceAllocator(),
                                        context->GetIdleWaiter());

  Playground::SinglePassCallback callback = [&](RenderPass& pass) -> bool {
    std::shared_ptr<Texture> texture;
    {
      // Resolve.
      TextureDescriptor tex_desc;
      tex_desc.format = PixelFormat::kB10G10R10XR;
      tex_desc.mip_count = 1;
      tex_desc.size = pass.GetRenderTargetSize();
      tex_desc.storage_mode = StorageMode::kDevicePrivate;
      tex_desc.sample_count = SampleCount::kCount1;
      tex_desc.usage = TextureUsage::kRenderTarget;
      tex_desc.type = TextureType::kTexture2D;

      // MSAA
      TextureDescriptor msaa_desc;
      msaa_desc.format = PixelFormat::kB10G10R10A10XR;
      msaa_desc.type = TextureType::kTexture2DMultisample;
      msaa_desc.mip_count = 1;
      msaa_desc.size = pass.GetRenderTargetSize();
      msaa_desc.storage_mode = StorageMode::kDeviceTransient;
      msaa_desc.sample_count = SampleCount::kCount4;
      msaa_desc.usage = TextureUsage::kRenderTarget;

      auto resolve_tex =
          context->GetResourceAllocator()->CreateTexture(tex_desc);
      auto msaa_tex = context->GetResourceAllocator()->CreateTexture(msaa_desc);

      ColorAttachment color0;
      color0.clear_color = Color::BlackTransparent();
      color0.load_action = LoadAction::kClear;
      color0.store_action = StoreAction::kMultisampleResolve;
      color0.texture = msaa_tex;
      color0.resolve_texture = resolve_tex;

      RenderTarget render_target;
      render_target.SetColorAttachment(color0, 0);

      auto cmd_buffer = context->CreateCommandBuffer();
      auto render_pass = cmd_buffer->CreateRenderPass(render_target);

      render_pass->SetPipeline(pipeline);

      VertexBufferBuilder<VS::PerVertexData> vertex_buffer_builder;
      vertex_buffer_builder.AddVertices({
          {{-0.5, -0.5}, Color::Red(), Color::Green()},
          {{0.0, 0.5}, Color::Green(), Color::Blue()},
          {{0.5, -0.5}, Color::Blue(), Color::Red()},
      });

      VertexBuffer vertex_buffer = vertex_buffer_builder.CreateVertexBuffer(
          *context->GetResourceAllocator());
      render_pass->SetVertexBuffer(vertex_buffer);

      FS::FragInfo frag_info;
      frag_info.time = fml::TimePoint::Now().ToEpochDelta().ToSecondsF();

      FS::BindFragInfo(*render_pass, host_buffer->EmplaceUniform(frag_info));

      if (!render_pass->Draw().ok()) {
        return false;
      }
      render_pass->EncodeCommands();
      if (!GetContext()
               ->GetCommandQueue()
               ->Submit({std::move(cmd_buffer)})
               .ok()) {
        return false;
      }
      texture = resolve_tex;
    }

    using VS = TextureFillVertexShader;
    using FS = TextureFillFragmentShader;
    auto desc =
        PipelineBuilder<VS, FS>::MakeDefaultPipelineDescriptor(*context);
    desc->SetPrimitiveType(PrimitiveType::kTriangleStrip);
    auto pipeline = context->GetPipelineLibrary()->GetPipeline(desc).Get();
    pass.SetPipeline(pipeline);

    FS::FragInfo frag_info;
    frag_info.alpha = 1.0;
    FS::BindFragInfo(pass, host_buffer->Emplace(frag_info));

    VS::FrameInfo frame_info;
    frame_info.mvp = Matrix();
    frame_info.texture_sampler_y_coord_scale = 1;
    VS::BindFrameInfo(pass, host_buffer->Emplace(frame_info));

    FS::BindTextureSampler(pass, texture,
                           GetContext()->GetSamplerLibrary()->GetSampler({}));

    VertexBufferBuilder<VS::PerVertexData> vertex_buffer_builder;
    vertex_buffer_builder.AddVertices({
        {{-1, -1}, {0, 0}},
        {{-1, 1}, {0, 1}},
        {{1, 1}, {1, 1}},
        {{1, -1}, {1, 0}},
    });
    auto vertex_buffer = vertex_buffer_builder.CreateVertexBuffer(
        *context->GetResourceAllocator());
    pass.SetVertexBuffer(vertex_buffer);
    pass.Draw();
    return true;
  };

  OpenPlaygroundHere(callback);
}