#include "Texture.h"

#include "VulkanContext.h"

#include "VulkanImageBuffer.h"

#include "Core/ThreadSyncManager.h"

#define STB_IMAGE_WRITE_IMPLEMENTATION

#include <External/stb/stb_image_write.h>

#include <cstring>

namespace sh::render

{

Texture::Texture(TextureFormat format, uint32_t width, uint32_t height, bool bUseMipmap) :

context(nullptr),

format(format), width(width), height(height),

aniso(1)

{

bSRGB = CheckSRGB();

bGenerateMipmap = bUseMipmap;

uint32_t mipLevels = bUseMipmap ? static_cast<uint32_t>(std::floor(std::log2(std::max(width, height)))) + 1 : 1;

pixels.resize(mipLevels);

int mipWidth = width;

int mipHeight = height;

for (int i = 0; i < mipLevels; ++i)

{

pixels[i].resize(mipWidth * mipHeight * GetTextureFormatPixelSize(format));

mipWidth = std::max(1, mipWidth / 2);

mipHeight = std::max(1, mipHeight / 2);

}

}

Texture::Texture(Texture&& other) noexcept :

context(other.context),

format(other.format), width(other.width), height(other.height),

pixels(std::move(other.pixels)), textureBuffer(std::move(other.textureBuffer)),

onBufferUpdate(std::move(other.onBufferUpdate)),

aniso(other.aniso),

bSRGB(other.bSRGB), bSetDataDirty(other.bSetDataDirty)

{

if (other.bDirty.test_and_set(std::memory_order::memory_order_acquire))

bDirty.test_and_set(std::memory_order::memory_order_relaxed);

}

Texture::~Texture() = default;

SH_RENDER_API void Texture::SyncDirty()

{

if (!bDirty.test_and_set(std::memory_order::memory_order_acquire))

core::ThreadSyncManager::PushSyncable(*this);

}

SH_RENDER_API void Texture::Sync()

{

if (bSetDataDirty)

{

CreateTextureBuffer();

bSetDataDirty = false;

}

bDirty.clear(std::memory_order::memory_order_relaxed);

}

SH_RENDER_API void Texture::OnPropertyChanged(const core::reflection::Property& prop)

{

if (prop.GetName() == core::Util::ConstexprHash("aniso"))

{

SetAnisoLevel(aniso);

}

else if (prop.GetName() == core::Util::ConstexprHash("bSRGB"))

{

SetSRGB(bSRGB);

}

else if (prop.GetName() == core::Util::ConstexprHash("bGenerateMipmap"))

{

SetGenerateMipmap(bGenerateMipmap);

}

else if (prop.GetName() == core::Util::ConstexprHash("filtering"))

{

SetFiltering(filtering);

}

}

SH_RENDER_API void Texture::SetPixelData(std::vector<uint8_t> pixels, uint32_t mipLevel)

{

assert(this->pixels[mipLevel].size() == pixels.size());

this->pixels[mipLevel] = std::move(pixels);

if (textureBuffer != nullptr)

{

bSetDataDirty = true;

SyncDirty();

}

}

SH_RENDER_API void Texture::SetPixelData(const uint8_t* pixels, std::size_t size, uint32_t mipLevel)

{

assert(this->pixels[mipLevel].size() == size);

this->pixels[mipLevel].resize(size);

std::memcpy(this->pixels[mipLevel].data(), pixels, size);

if (textureBuffer != nullptr)

{

bSetDataDirty = true;

SyncDirty();

}

}

SH_RENDER_API auto Texture::GetPixelData(uint32_t mipLevel) const -> const std::vector<Byte>&

{

assert(pixels.size() > mipLevel);

return pixels[mipLevel];

}

SH_RENDER_API void Texture::Build(const IRenderContext& context)

{

if (textureBuffer == nullptr)

{

this->context = &context;

CreateTextureBuffer();

}

}

SH_RENDER_API auto Texture::GetTextureBuffer() const -> ITextureBuffer*

{

return textureBuffer.get();

}

SH_RENDER_API void Texture::ChangeTextureFormat(TextureFormat target)

{

if (format == target)

return;

format = target;

bSRGB = CheckSRGB();

if (textureBuffer != nullptr)

{

bSetDataDirty = true;

SyncDirty();

}

}

SH_RENDER_API auto Texture::GetMipLevel() const -> uint32_t

{

if (!bGenerateMipmap)

return 1;

return pixels.size();

}

SH_RENDER_API void sh::render::Texture::SetAnisoLevel(uint32_t aniso)

{

this->aniso = aniso;

if (textureBuffer != nullptr)

{

bSetDataDirty = true;

SyncDirty();

}

}

SH_RENDER_API void Texture::SetGenerateMipmap(bool bGenerate)

{

bGenerateMipmap = bGenerate;

bSetDataDirty = true;

SyncDirty();

}

SH_RENDER_API void Texture::SetSRGB(bool bSRGB)

{

if (bSRGB)

{

if (format == TextureFormat::RGB24)

ChangeTextureFormat(TextureFormat::SRGB24);

else if (format == TextureFormat::RGBA32)

ChangeTextureFormat(TextureFormat::SRGBA32);

}

else

{

if (format == TextureFormat::SRGB24)

ChangeTextureFormat(TextureFormat::RGB24);

else if (format == TextureFormat::SRGBA32)

ChangeTextureFormat(TextureFormat::RGBA32);

}

}

SH_RENDER_API void Texture::SetFiltering(Filtering filter)

{

filtering = filter;

if (textureBuffer != nullptr)

{

bSetDataDirty = true;

SyncDirty();

}

}

SH_RENDER_API void Texture::ExportToPNG(const std::filesystem::path& path)

{

stbi_write_png(path.u8string().c_str(), width, height, GetTextureFormatChannel(format), pixels[0].data(), width * GetTextureFormatChannel(format));

}

void Texture::CreateTextureBuffer()

{

if (textureBuffer == nullptr)

{

if (context->GetRenderAPIType() == RenderAPI::Vulkan)

textureBuffer = std::make_unique<vk::VulkanImageBuffer>();

}

ITextureBuffer::CreateInfo ci{};

ci.width = width;

ci.height = height;

ci.format = format;

ci.aniso = aniso;

ci.filtering = static_cast<uint32_t>(filtering);

ci.mipLevel = pixels.size();

ci.bMSAAImg = false;

ci.bRenderTarget = false;

textureBuffer->Create(*context, ci);

const int mipLevel = bGenerateMipmap ? pixels.size() : 1;

for (int m = 0; m < mipLevel; ++m)

textureBuffer->SetData(pixels[m].data(), m);

onBufferUpdate.Notify(this);

}

auto Texture::CheckSRGB() const -> bool

{

if (format == TextureFormat::SRGB24 || format == TextureFormat::SRGBA32)

return true;

return false;

}

}//namespace