Image.h

Go to the documentation of this file.

// Copyright (c) 2018 the Talvos developers. All rights reserved.
//
// This file is distributed under a three-clause BSD license. For full license
// terms please see the LICENSE file distributed with this source code.


#ifndef TALVOS_IMAGE_H
#define TALVOS_IMAGE_H

#include <cassert>

#include "vulkan/vulkan_core.h"

#include "talvos/Object.h"

namespace talvos
{

class Device;

class Image
{
public:
  class Texel
  {
  public:
    Texel() {}

    Texel(const Object &Obj);

    Texel(const VkClearColorValue &ClearColor);

    template <typename T> T get(unsigned C) const
    {
      static_assert(sizeof(T) == 4);
      assert(C < 4);
      return ((T *)Data)[C];
    }

    const uint8_t *getData() const { return Data; }

    template <typename T> void loadSInt(const T *Data);

    template <typename T> void loadSFloat(const T *Data);

    template <typename T> void loadSNorm(const T *Data);

    template <typename T> void loadUInt(const T *Data);

    template <typename T> void loadUNorm(const T *Data);

    template <typename T> void set(unsigned C, T Value)
    {
      static_assert(sizeof(T) == 4);
      assert(C < 4);
      ((T *)Data)[C] = Value;
    }

    template <typename T> void storeSInt(T *Data) const;

    template <typename T> void storeSNorm(T *Data) const;

    template <typename T> void storeUInt(T *Data) const;

    template <typename T> void storeUNorm(T *Data) const;

    Object toObject(const Type *Ty) const;

  private:
    uint8_t Data[16];
  };

public:
  Image(Device &Dev, VkImageType Type, VkFormat Format, VkExtent3D Extent,
        uint32_t NumArrayLayers = 1, uint32_t NumMipLevels = 1)
      : Dev(Dev), Type(Type), Format(Format), Extent(Extent),
        NumArrayLayers(NumArrayLayers), NumMipLevels(NumMipLevels)
  {
    Address = 0;
  }

  void bindAddress(uint64_t Address);

  uint64_t getAddress() const { return Address; }

  uint32_t getDepth(uint32_t Level = 0) const;

  uint32_t getElementSize() const;

  VkExtent3D getExtent() const { return Extent; }

  VkFormat getFormat() const { return Format; }

  uint32_t getHeight(uint32_t Level = 0) const;

  uint64_t getMipLevelOffset(uint32_t Level) const;

  uint32_t getNumArrayLayers() const { return NumArrayLayers; }

  uint32_t getNumMipLevels() const { return NumMipLevels; }

  uint64_t getTexelAddress(uint32_t X, uint32_t Y = 0, uint32_t Z = 0,
                           uint32_t Layer = 0, uint32_t MipLevel = 0) const;

  uint64_t getTotalSize() const { return getMipLevelOffset(NumMipLevels); }

  VkImageType getType() const { return Type; }

  uint32_t getWidth(uint32_t Level = 0) const;

  void read(Texel &T, uint64_t Address) const;

  void read(Texel &T, uint64_t Address, VkFormat ReadFormat) const;

  void write(const Texel &T, uint64_t Address) const;

  void write(const Texel &T, uint64_t Address, VkFormat WriteFormat) const;

private:
  Device &Dev; 

  VkImageType Type;        
  VkFormat Format;         
  VkExtent3D Extent;       
  uint32_t NumArrayLayers; 
  uint32_t NumMipLevels;   

  uint64_t Address = 0; 
};

class ImageView
{
public:
  ImageView(const Image &Img, VkImageViewType Type, VkFormat Format,
            VkImageSubresourceRange Range);

  uint32_t getBaseArrayLayer() const { return BaseArrayLayer; }

  uint32_t getBaseMipLevel() const { return BaseMipLevel; }

  uint32_t getDepth(uint32_t Level = 0) const;

  VkFormat getFormat() const { return Format; }

  uint32_t getHeight(uint32_t Level = 0) const;

  const Image &getImage() const { return Img; }

  uint32_t getNumArrayLayers() const { return NumArrayLayers; }

  uint32_t getNumMipLevels() const { return NumMipLevels; }

  uint64_t getTexelAddress(uint32_t X, uint32_t Y = 0, uint32_t Z = 0,
                           uint32_t Layer = 0, uint32_t MipLevel = 0) const;

  VkImageViewType getType() const { return Type; }

  uint32_t getWidth(uint32_t Level = 0) const;

  bool is1D() const;

  bool is2D() const;

  bool is3D() const;

  bool isCube() const;

  void read(Image::Texel &T, uint32_t X, uint32_t Y = 0, uint32_t Z = 0,
            uint32_t Layer = 0, uint32_t MipLevel = 0) const;

  void write(const Image::Texel &T, uint32_t X, uint32_t Y = 0, uint32_t Z = 0,
             uint32_t Layer = 0, uint32_t MipLevel = 0) const;

private:
  const Image &Img; 

  VkImageViewType Type; 
  VkFormat Format;      

  uint32_t BaseArrayLayer; 
  uint32_t NumArrayLayers; 
  uint32_t BaseMipLevel;   
  uint32_t NumMipLevels;   
};

class Sampler
{
public:
  Sampler(const VkSamplerCreateInfo &CreateInfo) { Info = CreateInfo; }

  void sample(const ImageView *Image, Image::Texel &Texel, float S, float T = 0,
              float R = 0, float A = 0, float Lod = 0) const;

private:
  VkSamplerCreateInfo Info;
};

struct SampledImage
{
  const class ImageView *Image;
  const class Sampler *Sampler;
};

uint32_t getElementSize(VkFormat Format);

bool hasAlphaChannel(VkFormat Format);

} // namespace talvos

#endif