path: root/src/renderer.cpp

#include "renderer.h"
#include <iostream>
#include "consts.h"
#include "game.h"
#include "map.h"
#include "transform_system.h"
#include "camera_system.h"
#include "message_system.h"

Renderer::Renderer() {
  win_ = window_ptr(
    SDL_CreateWindow(
      "Tanetane",
      100,
      100,
      GAME_WIDTH,
      GAME_HEIGHT,
      SDL_WINDOW_SHOWN));

  if (!win_)
  {
    throw sdl_error();
  }

  ren_ = renderer_ptr(
    SDL_CreateRenderer(
      win_.get(),
      -1,
      SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC));

  if (!ren_)
  {
    throw sdl_error();
  }
}

texture_ptr Renderer::renderMapLayer(const Map& map, int layer) {
  if (cachedTilesetName_ != map.getTilesetFilename()) {
    surface_ptr pfs(IMG_Load(map.getTilesetFilename().c_str()));
    if (!pfs) {
      throw img_error();
    }

    tilesetTex_ = texture_ptr(SDL_CreateTextureFromSurface(ren_.get(), pfs.get()));
    cachedTilesetName_ = map.getTilesetFilename();
  }

  vec2i mapBounds = map.getMapSize() * map.getTileSize();

  texture_ptr canvas(
    SDL_CreateTexture(
      ren_.get(),
      SDL_PIXELFORMAT_RGBA8888,
      SDL_TEXTUREACCESS_TARGET,
      mapBounds.w(),
      mapBounds.h()));

  SDL_SetTextureBlendMode(canvas.get(), SDL_BLENDMODE_BLEND);

  SDL_SetRenderTarget(ren_.get(), canvas.get());
  SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_BLEND);
  SDL_SetRenderDrawColor(ren_.get(), 255, 255, 255, 0);
  SDL_RenderClear(ren_.get());

  const std::vector<Tile>& tiles = map.getLayers().at(layer);
  for (int y = 0; y < map.getMapSize().h(); y++) {
    for (int x = 0; x < map.getMapSize().w(); x++) {
      const Tile& tile = tiles.at(x + y * map.getMapSize().w());

      SDL_Rect srcRect {
        static_cast<int>((tile.id % map.getTilesetColumns()) * map.getTileSize().w()),
        static_cast<int>((tile.id / map.getTilesetColumns()) * map.getTileSize().h()),
        map.getTileSize().w(),
        map.getTileSize().h() };

      SDL_Rect destRect {
        x * map.getTileSize().w(),
        y * map.getTileSize().h(),
        map.getTileSize().w(),
        map.getTileSize().h() };

      SDL_RendererFlip flip = SDL_FLIP_NONE;
      if (tile.flipHorizontal && tile.flipVertical) {
        flip = static_cast<SDL_RendererFlip>(SDL_FLIP_HORIZONTAL | SDL_FLIP_VERTICAL);
      } else if (tile.flipHorizontal) {
        flip = SDL_FLIP_HORIZONTAL;
      } else if (tile.flipVertical) {
        flip = SDL_FLIP_VERTICAL;
      }
      SDL_RenderCopyEx(ren_.get(), tilesetTex_.get(), &srcRect, &destRect, 0, nullptr, flip);
    }
  }

  return canvas;
}

void Renderer::render(Game& game) {
  if (cachedMapName_ != game.getMap().getName()) {
    cachedMapName_ = game.getMap().getName();
    renLay1_ = renderMapLayer(game.getMap(), 0);
    renLay0_ = renderMapLayer(game.getMap(), 1);
  }

  vec2i mapBounds = game.getMap().getMapSize() * game.getMap().getTileSize();

  texture_ptr canvas(
    SDL_CreateTexture(
      ren_.get(),
      SDL_PIXELFORMAT_RGBA8888,
      SDL_TEXTUREACCESS_TARGET,
      mapBounds.w(),
      mapBounds.h()));

  if (!canvas) {
    throw sdl_error();
  }

  SDL_SetRenderTarget(ren_.get(), canvas.get());
  SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_NONE);
  SDL_SetRenderDrawColor(ren_.get(), 255, 255, 255, 255);
  SDL_RenderClear(ren_.get());

  SDL_RenderCopy(ren_.get(), renLay1_.get(), nullptr, nullptr);

  for (const Sprite& sprite : game.getSystem<TransformSystem>().getSpritesByY() | game.spriteView()) {
    if (sprite.isAnimated) {
      const SpriteFrame& frame = sprite.frames.at(sprite.animations.at(sprite.animationId).at(sprite.animationFrame));
      const SDL_Rect& src = frame.srcRect;
      SDL_Rect dest { sprite.loc.x() - frame.center.x(), sprite.loc.y() - frame.center.y(), frame.size.w(), frame.size.h() };
      SDL_RenderCopy(ren_.get(), textures_.at(loadImageFromFile(sprite.spritesheet)).get(), &src, &dest);
    }
  }

  SDL_RenderCopy(ren_.get(), renLay0_.get(), nullptr, nullptr);

  SDL_Rect cameraField {
    game.getSystem<CameraSystem>().getCameraPosition().x(),
    game.getSystem<CameraSystem>().getCameraPosition().y(),
    game.getSystem<CameraSystem>().getFieldOfView().w(),
    game.getSystem<CameraSystem>().getFieldOfView().h()
  };

  texture_ptr cameraTex(
    SDL_CreateTexture(
      ren_.get(),
      SDL_PIXELFORMAT_RGBA8888,
      SDL_TEXTUREACCESS_TARGET,
      CANVAS_WIDTH,
      CANVAS_HEIGHT));

  if (!cameraTex) {
    throw sdl_error();
  }

  SDL_SetRenderTarget(ren_.get(), cameraTex.get());
  SDL_RenderCopy(ren_.get(), canvas.get(), &cameraField, nullptr);

  if (game.getSystem<MessageSystem>().getCutsceneBarsProgress() > 0) {
    SDL_SetRenderDrawColor(ren_.get(), 0, 0, 0, 255);

    int topBarHeight = 16.0 * game.getSystem<MessageSystem>().getCutsceneBarsProgress();
    SDL_Rect topBar { 0, 0, CANVAS_WIDTH, topBarHeight };
    SDL_RenderFillRect(ren_.get(), &topBar);

    int bottomBarHeight = 36.0 * game.getSystem<MessageSystem>().getCutsceneBarsProgress();
    SDL_Rect bottomBar { 0, CANVAS_HEIGHT - bottomBarHeight, CANVAS_WIDTH, bottomBarHeight };
    SDL_RenderFillRect(ren_.get(), &bottomBar);

    if (game.getSystem<MessageSystem>().getCutsceneBarsProgress() == 1.0 &&
        !game.getSystem<MessageSystem>().getLines().empty()) {
      if (!game.getSystem<MessageSystem>().getSpeaker().empty()) {
        if (speakerHeaderTex_ == -1) {
          speakerHeaderTex_ = loadImageFromFile("../res/speaker_header.png");
        }

        {
          SDL_Rect destRect { 0, 111, 57, 13 };
          SDL_RenderCopy(ren_.get(), textures_.at(speakerHeaderTex_).get(), nullptr, &destRect);
        }

        if (speakerHeaderLine_.line != game.getSystem<MessageSystem>().getSpeaker()) {
          renderMessageLine(speakerHeaderLine_, game.getSystem<MessageSystem>().getSpeaker(), game);
        }

        {
          SDL_Rect destRect {
            4,
            112,
            MESSAGE_TEXT_WIDTH,
            game.getFont().getCharacterHeight() };

          SDL_RenderCopy(ren_.get(), speakerHeaderLine_.renderedTex.get(), nullptr, &destRect);
        }
      }

      int lineIndex = 0;
      for (const MessageSystem::MessageLine& line : game.getSystem<MessageSystem>().getLines()) {
        if (messageLines_[lineIndex].line != line.text) {
          renderMessageLine(messageLines_[lineIndex], line.text, game);
        }

        // 18x, 127y1, 143y2
        if (line.charsRevealed > 0) {
          SDL_Rect srcRect {
            0, 0, messageLines_[lineIndex].charIndexToWidth[line.charsRevealed],
            game.getFont().getCharacterHeight()
          };
          SDL_Rect destRect {
            18,
            127 + 16 * lineIndex,
            srcRect.w,
            srcRect.h };

          SDL_RenderCopy(ren_.get(), messageLines_[lineIndex].renderedTex.get(), &srcRect, &destRect);
        }

        lineIndex++;
      }

      // 216, 138, 142
      if (game.getSystem<MessageSystem>().isNextArrowShowing()) {
        if (advMsgArrowTex_ == -1) {
          advMsgArrowTex_ = loadImageFromFile("../res/advance_text_arrow.png");
        }

        SDL_Rect destRect {
          216,
          138 + game.getSystem<MessageSystem>().getNextArrowBob(),
          16,
          16 };

        SDL_RenderCopy(ren_.get(), textures_.at(advMsgArrowTex_).get(), nullptr, &destRect);
      }
    }
  }

  if (game.getFadeoutProgress() > 0.0) {
    SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_BLEND);
    SDL_SetRenderDrawColor(ren_.get(), 0, 0, 0, game.getFadeoutProgress() * 255);
    SDL_RenderFillRect(ren_.get(), nullptr);
  }

  SDL_SetRenderTarget(ren_.get(), nullptr);
  SDL_RenderCopy(ren_.get(), cameraTex.get(), nullptr, nullptr);
  SDL_RenderPresent(ren_.get());
}

int Renderer::loadImageFromFile(std::string filename) {
  if (!filenameToTexId_.count(filename)) {
    surface_ptr pfs(IMG_Load(filename.data()));
    if (!pfs)
    {
      throw img_error();
    }

    texture_ptr tex = texture_ptr(SDL_CreateTextureFromSurface(ren_.get(), pfs.get()));
    //SDL_SetTextureBlendMode(tex, SDL_BLENDMODE_BLEND);

    int texId = textures_.size();
    textures_.push_back(std::move(tex));

    filenameToTexId_[filename] = texId;
  }

  return filenameToTexId_[filename];
}

void Renderer::renderMessageLine(MessageCache& line, const std::string& text, Game& game) {
  line.line = text;

  line.renderedTex.reset(
    SDL_CreateTexture(
      ren_.get(),
      SDL_PIXELFORMAT_RGBA8888,
      SDL_TEXTUREACCESS_TARGET,
      MESSAGE_TEXT_WIDTH,
      game.getFont().getCharacterHeight()));

  SDL_SetTextureBlendMode(line.renderedTex.get(), SDL_BLENDMODE_BLEND);

  SDL_SetRenderTarget(ren_.get(), line.renderedTex.get());
  SDL_SetRenderDrawBlendMode(ren_.get(), SDL_BLENDMODE_BLEND);
  SDL_SetRenderDrawColor(ren_.get(), 0, 0, 0, 0);
  SDL_RenderClear(ren_.get());

  line.charIndexToWidth.clear();
  line.charIndexToWidth.push_back(0);

  int length = 0;

  for (int i=0; i<line.line.size(); i++) {
    if (line.line[i] != ' ') {
      vec2i charLoc = game.getFont().getCharacterLocation(line.line[i]);
      vec2i charSize = game.getFont().getCharacterSize(line.line[i]);
      SDL_Rect srcRect { charLoc.x(), charLoc.y(), charSize.w(), charSize.h() };
      SDL_Rect destRect { length, 0, charSize.w(), charSize.h() };

      SDL_RenderCopy(ren_.get(), textures_.at(game.getFont().getTextureId()).get(), &srcRect, &destRect);

      length++;
    }

    length += game.getFont().getCharacterWidth(line.line[i]);
    line.charIndexToWidth.push_back(length);
  }

  line.charIndexToWidth.back()--;
}