texturemanager.cc

Go to the documentation of this file.

#include "ion/gfx/texturemanager.h"

#include <algorithm>
#include <cstring>

#include "ion/base/logging.h"

namespace ion {
namespace gfx {

const int TextureManager::kEnd = -1;

TextureManager::TextureManager(int max_texture_units)
    : items_(max_texture_units), back_(max_texture_units - 1), front_(0) {
  DCHECK_EQ(items_.size(), static_cast<size_t>(max_texture_units));
  DCHECK_GE(max_texture_units, 1) << "TextureManager was initialized with < 1 "
                                     "texture units. This could mean that "
                                     "there is no valid GL context bound.";
  SetUnitRange(math::Range1i(0, max_texture_units - 1));
}

TextureManager::~TextureManager() {}

TextureManager::TextureType TextureManager::GetTexture(int unit) const {
  DCHECK_GE(unit, 0);
  DCHECK_LT(unit, static_cast<int>(items_.size()));
  return items_[unit].texture;
}

int TextureManager::GetUnit(TextureType texture, int current_unit) {
  DCHECK_LT(current_unit, static_cast<int>(items_.size()));
  if (current_unit != kEnd && items_[current_unit].texture == texture) {
    Touch(current_unit);
  } else {
    Touch(front_);  // This changes front_ to back_.
  }
  items_[back_].texture = texture;
  return back_;
}

void TextureManager::Touch(int unit) {
  DCHECK_LT(unit, static_cast<int>(items_.size()));
  if (unit == back_)
    return;

  Item& this_item = items_[unit];
  if (this_item.prev != kEnd) {
    Item& prev_item = items_[this_item.prev];
    prev_item.next = this_item.next;
  } else {
    front_ = this_item.next;
  }
  if (this_item.next != kEnd) {
    Item& next_item = items_[this_item.next];
    next_item.prev = this_item.prev;
  }

  Item& back_item = items_[back_];
  back_item.next = unit;
  this_item.prev = back_;
  this_item.next = kEnd;
  back_ = unit;
}

void TextureManager::SetUnitRange(const math::Range1i& units) {
  if (units.GetMinPoint() < 0) {
    LOG(ERROR) << "The minimum unit for TextureManager to use must be >= 0.";
    return;
  }

  front_ = std::min(static_cast<int>(units.GetMinPoint()),
                    static_cast<int>(items_.size() - 1U));
  back_ = std::min(static_cast<int>(units.GetMaxPoint()),
                   static_cast<int>(items_.size() - 1U));

  memset(&items_[0], 0, sizeof(Item) * items_.size());

  items_[front_].prev = kEnd;
  items_[front_].texture = NULL;
  items_[front_].next = (front_ < back_) ? front_ + 1 : kEnd;
  items_[back_].prev = (front_ < back_) ? back_ - 1 : kEnd;
  items_[back_].texture = NULL;
  items_[back_].next = kEnd;
  for (int i = front_ + 1; i < back_; ++i) {
    items_[i].prev = i - 1;
    items_[i].texture = NULL;
    items_[i].next = i + 1;
  }
}

}  // namespace gfx
}  // namespace ion