texture.h

Go to the documentation of this file.

#ifndef ION_GFX_TEXTURE_H_
#define ION_GFX_TEXTURE_H_

#include <bitset>

#include "base/integral_types.h"
#include "base/macros.h"
#include "ion/base/invalid.h"
#include "ion/base/referent.h"
#include "ion/base/stlalloc/allocvector.h"
#include "ion/gfx/image.h"
#include "ion/gfx/resourceholder.h"
#include "ion/gfx/sampler.h"
#include "ion/math/vector.h"

namespace ion {
namespace gfx {

static const size_t kMipmapSlotCount = 16;

class ION_API TextureBase : public ResourceHolder {
 public:
  struct SubImage {
    SubImage() : level(0U) {}

    SubImage(size_t level_in, const math::Point2ui& offset_in,
             const ImagePtr& image_in)
        : level(level_in),
          offset(offset_in[0], offset_in[1], 0U),
          image(image_in) {}
    SubImage(size_t level_in, const math::Point3ui& offset_in,
             const ImagePtr& image_in)
    : level(level_in), offset(offset_in), image(image_in) {}

    size_t level;
    math::Point3ui offset;
    ImagePtr image;
  };

  enum Changes {
    kBaseLevelChanged = kNumBaseChanges,
    kContentsImplicitlyChanged,
    kImmutableImageChanged,
    kMaxLevelChanged,
    kMultisampleChanged,
    kSamplerChanged,
    kSwizzleRedChanged,
    kSwizzleGreenChanged,
    kSwizzleBlueChanged,
    kSwizzleAlphaChanged,
    kNumChanges
  };

  enum Swizzle {
    kRed,
    kGreen,
    kBlue,
    kAlpha,
  };

  enum TextureType {
    kCubeMapTexture,
    kTexture
  };

  void SetSampler(const SamplerPtr& sampler);
  const SamplerPtr& GetSampler() const { return sampler_.Get(); }

  void SetImmutableImage(const ImagePtr& image, size_t levels);
  const ImagePtr& GetImmutableImage() const { return immutable_image_.Get(); }
  size_t GetImmutableLevels() const { return immutable_levels_; }

  void SetBaseLevel(int level) { base_level_.Set(level); }
  int GetBaseLevel() const { return base_level_.Get(); }

  void SetMaxLevel(int level) { max_level_.Set(level); }
  int GetMaxLevel() const { return max_level_.Get(); }

  void SetSwizzleRed(Swizzle r) { swizzle_red_.Set(r); }
  Swizzle GetSwizzleRed() const { return swizzle_red_.Get(); }
  void SetSwizzleGreen(Swizzle g) { swizzle_green_.Set(g); }
  Swizzle GetSwizzleGreen() const { return swizzle_green_.Get(); }
  void SetSwizzleBlue(Swizzle b) { swizzle_blue_.Set(b); }
  Swizzle GetSwizzleBlue() const { return swizzle_blue_.Get(); }
  void SetSwizzleAlpha(Swizzle a) { swizzle_alpha_.Set(a); }
  Swizzle GetSwizzleAlpha() const { return swizzle_alpha_.Get(); }
  void SetSwizzles(Swizzle r, Swizzle g, Swizzle b, Swizzle a) {
    swizzle_red_.Set(r);
    swizzle_green_.Set(g);
    swizzle_blue_.Set(b);
    swizzle_alpha_.Set(a);
  }

  TextureType GetTextureType() const { return texture_type_; }

  void SetMultisampling(int samples, bool fixed_sample_locations) {
    if (samples < 0) {
      LOG(WARNING) << "Ignoring bad number of samples: " << samples;
      return;
    }
    multisample_samples_.Set(samples);
    multisample_fixed_sample_locations_.Set(fixed_sample_locations);
  }
  int GetMultisampleSamples() const {
    return multisample_samples_.Get();
  }
  bool IsMultisampleFixedSampleLocations() const {
    return multisample_fixed_sample_locations_.Get();
  }

 protected:
  class Face {
   public:
    Face(TextureBase* texture, int sub_image_changed_bit,
         int mipmaps_changed_start_bit);

    void SetSubImage(size_t level, const math::Point2ui offset,
                     const ImagePtr& image);

    void SetSubImage(size_t level, const math::Point3ui offset,
                     const ImagePtr& image);

    const base::AllocVector<SubImage>& GetSubImages() const {
      return sub_images_;
    }

    void ClearSubImages() const {
      sub_images_.clear();
    }

    bool HasImage(size_t level) const {
      return level < mipmaps_set_.size() && mipmaps_set_.test(level);
    }

    const ImagePtr GetImage(size_t level) const {
      if (HasImage(level))
        return mipmaps_.Get(level);
      else
        return ImagePtr();
    }

    size_t GetImageCount() const {
      return mipmaps_set_.count();
    }

    void SetImage(size_t level, const ImagePtr& image_in, TextureBase* texture);

   private:
    Field<bool> sub_images_changed_;
    mutable base::AllocVector<TextureBase::SubImage> sub_images_;
    VectorField<ImagePtr> mipmaps_;
    std::bitset<kMipmapSlotCount> mipmaps_set_;
  };

  explicit TextureBase(TextureType type);

  ~TextureBase() override;

 private:
  Field<SamplerPtr> sampler_;
  Field<int> base_level_;
  Field<int> max_level_;
  RangedField<Swizzle> swizzle_red_;
  RangedField<Swizzle> swizzle_green_;
  RangedField<Swizzle> swizzle_blue_;
  RangedField<Swizzle> swizzle_alpha_;

  TextureType texture_type_;

  Field<ImagePtr> immutable_image_;
  size_t immutable_levels_;

  Field<int> multisample_samples_;
  Field<bool> multisample_fixed_sample_locations_;

  DISALLOW_IMPLICIT_CONSTRUCTORS(TextureBase);
};

class ION_API Texture : public TextureBase {
 public:
  enum Changes {
    kSubImageChanged = TextureBase::kNumChanges,
    kMipmapChanged,
    kNumChanges = kMipmapChanged + kMipmapSlotCount
  };

  Texture();

  void SetImage(size_t level, const ImagePtr& image) {
    if (GetImmutableImage().Get())
      LOG(ERROR) << "ION: SetImage() called on immutable texture \""
                 << GetLabel()
                 << "\".  Use SetSubImage() to update an immutable texture.";
    else
      face_.SetImage(level, image, this);
  }
  bool HasImage(size_t level) const {
    return face_.HasImage(level);
  }
  const ImagePtr GetImage(size_t level) const {
    return face_.GetImage(level);
  }
  size_t GetImageCount() const {
    return face_.GetImageCount();
  }
  void SetSubImage(size_t level, const math::Point2ui offset,
                   const ImagePtr& image) {
    SetSubImage(level, math::Point3ui(offset[0], offset[1], 0), image);
  }
  void SetSubImage(size_t level, const math::Point3ui offset,
                   const ImagePtr& image) {
    face_.SetSubImage(level, offset, image);
  }
  const base::AllocVector<SubImage>& GetSubImages() const {
    return face_.GetSubImages();
  }
  void ClearSubImages() const {
    face_.ClearSubImages();
  }

  static bool 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);

 protected:
  ~Texture() override;

 private:
  void OnNotify(const base::Notifier* notifier) override;

  Face face_;
};

typedef base::ReferentPtr<Texture>::Type TexturePtr;

}  // namespace gfx
}  // namespace ion

#endif  // ION_GFX_TEXTURE_H_