texture.cc

Go to the documentation of this file.

#include "ion/gfx/texture.h"

#include <algorithm>

#include "ion/base/enumhelper.h"
#include "ion/base/static_assert.h"
#include "ion/math/utils.h"
#include "ion/portgfx/glheaders.h"

namespace ion {
namespace gfx {



TextureBase::Face::Face(TextureBase* texture, int sub_image_changed_bit,
                        int mipmaps_changed_start_bit)
    : sub_images_changed_(sub_image_changed_bit, false, texture),
      sub_images_(*texture),
      mipmaps_(mipmaps_changed_start_bit, kMipmapSlotCount, texture) {
  for (size_t i = 0; i < kMipmapSlotCount; ++i)
    mipmaps_.Add(ImagePtr());
}

void TextureBase::Face::SetSubImage(size_t level, const math::Point2ui offset,
                                    const ImagePtr& image) {
  SetSubImage(level, math::Point3ui(offset[0], offset[1], 0), image);
}

void TextureBase::Face::SetSubImage(size_t level, const math::Point3ui offset,
                                    const ImagePtr& image) {
  sub_images_.push_back(SubImage(level, offset, image));
  sub_images_changed_.Set(false);
  sub_images_changed_.Set(true);
}

void TextureBase::Face::SetImage(size_t level, const ImagePtr& image_in,
                                 TextureBase* texture) {
  if (level < kMipmapSlotCount) {
    if (Image* img = mipmaps_.Get(level).Get())
      img->RemoveReceiver(texture);
    mipmaps_.Set(level, image_in);
    if (Image* img = image_in.Get()) {
      img->AddReceiver(texture);
      mipmaps_set_.set(level);
    } else {
      mipmaps_set_.reset(level);
    }
  }
}




TextureBase::TextureBase(TextureType type)
    : sampler_(kSamplerChanged, SamplerPtr(), this),
      base_level_(kBaseLevelChanged, 0, this),
      max_level_(kMaxLevelChanged, 1000, this),
      swizzle_red_(kSwizzleRedChanged, kRed, kRed, kAlpha, this),
      swizzle_green_(kSwizzleGreenChanged, kGreen, kRed, kAlpha, this),
      swizzle_blue_(kSwizzleBlueChanged, kBlue, kRed, kAlpha, this),
      swizzle_alpha_(kSwizzleAlphaChanged, kAlpha, kRed, kAlpha, this),
      texture_type_(type),
      immutable_image_(kImmutableImageChanged, ImagePtr(), this),
      immutable_levels_(0),
      multisample_samples_(kMultisampleChanged, 0, this),
      multisample_fixed_sample_locations_(kMultisampleChanged, true, this) {}

TextureBase::~TextureBase() {
  if (Sampler* sampler = sampler_.Get().Get())
    sampler->RemoveReceiver(this);
}

void TextureBase::SetSampler(const SamplerPtr& sampler) {
  if (Sampler* old_sampler = sampler_.Get().Get())
    old_sampler->RemoveReceiver(this);
  sampler_.Set(sampler);
  if (Sampler* new_sampler = sampler_.Get().Get())
    new_sampler->AddReceiver(this);
}

void TextureBase::SetImmutableImage(const ImagePtr& image, size_t levels) {
  if (image.Get()) {
    if (immutable_image_.Get().Get()) {
      LOG(ERROR) << "ION: SetImmutableImage() called on an already immutable "
                    "texture; SetImmutableImage() can only be called once.";
    } else if (levels == 0) {
      LOG(ERROR) << "ION: SetImmutableImage() called with levels == 0. A "
                    "texture must have at least one level (the 0th level).";
    } else {
      immutable_levels_ = levels;
      immutable_image_.Set(image);
    }
  }
}




Texture::Texture()
    : TextureBase(kTexture),
      face_(this, kSubImageChanged, kMipmapChanged) {
}

bool Texture::ExpectedDimensionsForMipmap(const uint32 mipmap_width,
                                          const uint32 mipmap_height,
                                          const uint32 mipmap_level,
                                          const uint32 base_width,
                                          const uint32 base_height,
                                          uint32* expected_width,
                                          uint32* expected_height) {
  *expected_width = 0;
  *expected_height = 0;

  if (mipmap_width != 1 && (mipmap_width & (mipmap_width - 1))) {
    LOG(ERROR) << "Mipmap width: " << mipmap_width << " is not a power of 2.";
    return false;
  }
  if (mipmap_height != 1 && (mipmap_height & (mipmap_height - 1))) {
    LOG(ERROR) << "Mipmap height: " << mipmap_height << " is not a power of 2.";
    return false;
  }

  if (mipmap_width != 1 && mipmap_height != 1) {
    const float base_ratio =
        static_cast<float>(base_width) / static_cast<float>(base_height);
    const float mipmap_ratio =
        static_cast<float>(mipmap_width) / static_cast<float>(mipmap_height);
    if (base_ratio != mipmap_ratio) {
      LOG(ERROR) << "Bad aspect ratio for mipmap.";
      return false;
    }
  }

  const uint32 max_dimension = std::max(base_width, base_height);
  const uint32 max_level = static_cast<uint32>(math::Log2(max_dimension));
  if (mipmap_level > max_level) {
    LOG(ERROR) << "Mipmap level is: " << mipmap_level <<
                  " but maximum level is: " << max_level << ".";
    return false;
  }

  *expected_width = base_width >> mipmap_level;
  *expected_height = base_height >> mipmap_level;

  if (base_width != base_height) {
    *expected_width = std::max(*expected_width, 1U);
    *expected_height = std::max(*expected_height, 1U);
  }

  if (!((mipmap_width == *expected_width) &&
        (mipmap_height == *expected_height))) {
    LOG(ERROR) << "***ION: Mipmap level " << mipmap_level << " has incorrect"
               << " dimensions [" << mipmap_width << "x"
               << mipmap_height << "], expected [" << *expected_width << "x"
               << *expected_height << "].  Base dimensions: ("
               << base_width << ", " << base_height << ").  Ignoring.\n";
    return false;
  }

  return true;
}

Texture::~Texture() {
  for (size_t i = 0; i < kMipmapSlotCount; ++i) {
    if (Image* image = face_.GetImage(i).Get()) image->RemoveReceiver(this);
  }
}

void Texture::OnNotify(const base::Notifier* notifier) {
  if (GetResourceCount()) {
    if (notifier == GetSampler().Get()) {
      OnChanged(kSamplerChanged);
    } else {
      for (size_t i = 0; i < kMipmapSlotCount; ++i) {
        if (notifier == face_.GetImage(i).Get())
          OnChanged(static_cast<int>(kMipmapChanged + i));
      }
    }
  }
}

}  // namespace gfx

namespace base {

using gfx::Texture;

template <> ION_API
const EnumHelper::EnumData<Texture::Swizzle> EnumHelper::GetEnumData() {
  static const GLenum kValues[] = { GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA };
  static const char* kStrings[] = { "Red", "Green", "Blue", "Alpha" };
  ION_STATIC_ASSERT(ARRAYSIZE(kValues) == ARRAYSIZE(kStrings),
                    "EnumHelper size mismatch");
  return EnumData<Texture::Swizzle>(
      base::IndexMap<Texture::Swizzle, GLenum>(kValues, ARRAYSIZE(kValues)),
      kStrings);
}

}  // namespace base

}  // namespace ion