cpp-game-engine/graphics/test/renderer_test.cxx

//
//  direct_renderer_test.cxx
//  graphics-test
//
//  Created by Sam Jaffe on 6/1/19.
//  Copyright © 2019 Sam Jaffe. All rights reserved.
//

#include <gmock/gmock.h>

#include "../src/renderer_impl.hpp"
#include "game/graphics/object.hpp"
#include "game/graphics/renderer.hpp"
#include "game/graphics/vertex.h"
#include "game/math/shape.hpp"
#include "matrix/matrix.hpp"

using testing::_;
using testing::AnyNumber;
using testing::IsEmpty;
using testing::SizeIs;

struct mock_renderer_impl : graphics::renderer_impl {
  MOCK_CONST_METHOD0(manager, std::shared_ptr<graphics::manager const>());
  MOCK_METHOD3(draw, void(identity<graphics::material>, math::matr4 const &,
                          std::vector<graphics::vertex> const &));
  MOCK_METHOD0(clear, void());
  MOCK_METHOD0(flush, void());
};

identity<graphics::material> cast(unsigned int id) {
  return *reinterpret_cast<identity<graphics::material> *>(&id);
}

struct DirectRendererTest : testing::Test {
  void SetUp() override;
  void TearDown() override;

  std::unique_ptr<graphics::direct_renderer> renderer;
  mock_renderer_impl * mock;
};

void DirectRendererTest::SetUp() {
  mock = new mock_renderer_impl;
  renderer.reset(new graphics::direct_renderer(mock));
}

void DirectRendererTest::TearDown() {
  renderer.reset();
  delete mock;
}

graphics::object DemoObject(unsigned int id = 1) {
  math::dim2::rectangle const size{{{-1.f, -1.f}}, {{2.f, 2.f}}};
  math::dim2::rectangle const tex{{{0.f, 0.f}}, {{1.f, 1.f}}};
  return {size, size, cast(id), tex};
}

TEST_F(DirectRendererTest, DrawPassesToDraw) {
  EXPECT_CALL(*mock, draw(cast(1), math::matr4(), IsEmpty())).Times(1);
  renderer->draw(cast(1), math::matr4(), {});
}

TEST_F(DirectRendererTest, DrawObjectHasEmptyTranslation) {
  EXPECT_CALL(*mock, draw(cast(1), math::matr4(), _)).Times(1);
  renderer->draw(DemoObject());
}

TEST_F(DirectRendererTest, DrawObjectHasSixVertices) {
  EXPECT_CALL(*mock, draw(_, _, SizeIs(6))).Times(1);
  renderer->draw(DemoObject());
}

TEST_F(DirectRendererTest, MultipleDrawCallsDispatchMultipleDraws) {
  EXPECT_CALL(*mock, draw(_, _, SizeIs(6))).Times(2);
  renderer->draw(DemoObject());
  renderer->draw(DemoObject());
}

TEST_F(DirectRendererTest, ClearPassesToClear) {
  EXPECT_CALL(*mock, clear()).Times(1);
  renderer->clear();
}

TEST_F(DirectRendererTest, FlushPassesToFlush) {
  EXPECT_CALL(*mock, flush()).Times(1);
  renderer->flush();
}

struct BatchRendererTest : testing::Test {
  void SetUp() override;
  void TearDown() override;

  std::unique_ptr<graphics::batch_renderer> renderer;
  std::unique_ptr<graphics::direct_renderer> drenderer;
  mock_renderer_impl * mock;
};

void BatchRendererTest::SetUp() {
  mock = new mock_renderer_impl;
  drenderer.reset(new graphics::direct_renderer(mock));
  renderer.reset(new graphics::batch_renderer(drenderer.get()));
}

void BatchRendererTest::TearDown() {
  renderer.reset();
  drenderer.reset();
  delete mock;
}

TEST_F(BatchRendererTest, CallsFlushOnDestructor) {
  EXPECT_CALL(*mock, flush()).Times(1);
  renderer.reset();
  testing::Mock::VerifyAndClearExpectations(mock);
}

TEST_F(BatchRendererTest, ClearPassesToClear) {
  EXPECT_CALL(*mock, flush()).Times(AnyNumber());
  EXPECT_CALL(*mock, clear()).Times(1);
  renderer->clear();
}

TEST_F(BatchRendererTest, FlushPassesToFlush) {
  EXPECT_CALL(*mock, flush()).Times(AnyNumber());
  // This will end up changing
  EXPECT_CALL(*mock, flush()).Times(1).RetiresOnSaturation();
  renderer->flush();
}

TEST_F(BatchRendererTest, DoesNotWriteImmediately) {
  EXPECT_CALL(*mock, draw(_, _, _)).Times(0);
  renderer->draw(cast(1), math::matr4(), {});
  testing::Mock::VerifyAndClearExpectations(mock);
  // We need to re-enact this expectation
  EXPECT_CALL(*mock, flush()).Times(AnyNumber());
  EXPECT_CALL(*mock, draw(_, _, _)).Times(1);
}

TEST_F(BatchRendererTest, GroupsDataTogetherByMaterial) {
  EXPECT_CALL(*mock, flush()).Times(AnyNumber());
  EXPECT_CALL(*mock, draw(cast(1), _, SizeIs(12))).Times(1);
  EXPECT_CALL(*mock, draw(cast(2), _, SizeIs(6))).Times(1);
  renderer->draw(DemoObject());
  renderer->draw(DemoObject());
  renderer->draw(DemoObject(2));
}

TEST_F(BatchRendererTest, BatchLimitingCanSplitTheWrites) {
  EXPECT_CALL(*mock, flush()).Times(AnyNumber());
  renderer.reset(new graphics::batch_renderer(drenderer.get(), 15));
  EXPECT_CALL(*mock, draw(cast(1), _, SizeIs(12))).Times(1);
  EXPECT_CALL(*mock, draw(cast(2), _, SizeIs(6))).Times(2);
  renderer->draw(DemoObject());
  renderer->draw(DemoObject());
  renderer->draw(DemoObject(2));
  renderer->draw(DemoObject(2));
}