#include "PlatformBase.hpp"

#include "TextureSubPluginAPI.hpp"

#if SUPPORT_D3D11

#include <assert.h>

#include <d3d11.h>

#include <ostream>

#include <sstream>

#include <string>

#include <unordered_map>

#include "IUnityGraphicsD3D11.h"

#include "IUnityLog.h"

class TextureSubPluginAPI_D3D11 : public TextureSubPluginAPI {

public:

TextureSubPluginAPI_D3D11();

virtual ~TextureSubPluginAPI_D3D11() {}

virtual void CreateTexture3D(uint32_t texture_id, uint32_t width,

uint32_t height, uint32_t depth, Format format);

virtual void* RetrieveCreatedTexture3D(uint32_t texture_id);

virtual void DestroyTexture3D(uint32_t texture_id);

virtual void TextureSubImage2D(void* texture_handle, int32_t xoffset,

int32_t yoffset, int32_t width, int32_t height,

void* data_ptr, int32_t level, Format format);

virtual void TextureSubImage3D(void* texture_handle, int32_t xoffset,

int32_t yoffset, int32_t zoffset,

int32_t width, int32_t height, int32_t depth,

void* data_ptr, int32_t level, Format format);

virtual void ProcessDeviceEvent(UnityGfxDeviceEventType type,

IUnityInterfaces* interfaces);

private:

ID3D11Device* m_Device;

std::unordered_map<uint32_t, ID3D11Texture3D*> m_CreatedTextures;

};

TextureSubPluginAPI* CreateTextureSubPluginAPI_D3D11() {

return new TextureSubPluginAPI_D3D11();

}

TextureSubPluginAPI_D3D11::TextureSubPluginAPI_D3D11() : m_Device(NULL) {}

void TextureSubPluginAPI_D3D11::ProcessDeviceEvent(

UnityGfxDeviceEventType type, IUnityInterfaces* interfaces) {

switch (type) {

case kUnityGfxDeviceEventInitialize: {

IUnityGraphicsD3D11* d3d = interfaces->Get<IUnityGraphicsD3D11>();

m_Device = d3d->GetDevice();

break;

}

default:

break;

}

}

void TextureSubPluginAPI_D3D11::TextureSubImage2D(

void* texture_handle, int32_t xoffset, int32_t yoffset, int32_t width,

int32_t height, void* data_ptr, int32_t level, Format format) {

// determine row pitch/depth from provided format

uint32_t row_pitch;

switch (format) {

case Format::R8_UINT:

row_pitch = width; // width * sizeof(uint8_t)

break;

case Format::R16_UINT:

row_pitch = width * 2; // width * sizeof(uint16_t)

break;

default: {

std::ostringstream ss;

ss << __FUNCTION__ << " unsupported texture format: " << format;

UNITY_LOG_ERROR(g_Log, ss.str().c_str());

return;

}

}

ID3D11Texture2D* d3dtex = (ID3D11Texture2D*)texture_handle;

assert(d3dtex);

ID3D11DeviceContext* ctx = NULL;

m_Device->GetImmediateContext(&ctx);

// make sure to set front and back such that front < back

// even if they are not needed so that this works

D3D11_BOX box{};

box.left = xoffset;

box.top = yoffset;

box.front = 0;

box.right = xoffset + width;

box.bottom = yoffset + height;

box.back = 1;

ctx->UpdateSubresource(d3dtex, 0, &box, data_ptr, row_pitch, 0);

ctx->Release();

}

void TextureSubPluginAPI_D3D11::TextureSubImage3D(

void* texture_handle, int32_t xoffset, int32_t yoffset, int32_t zoffset,

int32_t width, int32_t height, int32_t depth, void* data_ptr, int32_t level,

Format format) {

// determine row pitch/depth from provided format

uint32_t row_pitch;

switch (format) {

case Format::R8_UINT:

row_pitch = width; // width * sizeof(uint8_t)

break;

case Format::R16_UINT:

row_pitch = width * 2; // width * sizeof(uint16_t)

break;

default: {

std::ostringstream ss;

ss << __FUNCTION__ << " unsupported texture format: " << format;

UNITY_LOG_ERROR(g_Log, ss.str().c_str());

return;

}

}

uint32_t depth_pitch = height * row_pitch;

ID3D11Texture3D* d3dtex = (ID3D11Texture3D*)texture_handle;

assert(d3dtex);

ID3D11DeviceContext* ctx = NULL;

m_Device->GetImmediateContext(&ctx);

D3D11_BOX box{};

box.left = xoffset;

box.top = yoffset;

box.front = zoffset;

box.right = xoffset + width;

box.bottom = yoffset + height;

box.back = zoffset + depth;

ctx->UpdateSubresource(d3dtex, 0, &box, data_ptr, row_pitch, depth_pitch);

ctx->Release();

}

// google: direct3d 11 resources limits

void TextureSubPluginAPI_D3D11::CreateTexture3D(uint32_t texture_id,

uint32_t width, uint32_t height,

uint32_t depth, Format format) {

uint32_t size_in_mbs;

D3D11_TEXTURE3D_DESC desc{};

desc.Width = width;

desc.Height = height;

desc.Depth = depth;

desc.MipLevels = 1;

switch (format) {

case R8_UINT:

desc.Format = DXGI_FORMAT_R8_UNORM;

size_in_mbs = width * height * depth / (1024 * 1024);

break;

case R16_UINT:

desc.Format = DXGI_FORMAT_R16_UNORM;

size_in_mbs = width * height * depth * 2 / (1024 * 1024);

break;

default: {

std::ostringstream ss;

ss << __FUNCTION__

<< "failed to create 3D texture, unsupported texture format: "

<< format;

UNITY_LOG_ERROR(g_Log, ss.str().c_str());

return;

}

}

desc.Usage = D3D11_USAGE_DEFAULT;

desc.BindFlags = D3D11_BIND_SHADER_RESOURCE;

desc.CPUAccessFlags = 0;

desc.MiscFlags = 0;

if (size_in_mbs > D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM) {

std::ostringstream msg;

msg << "Texture size exceeds Direct3D 11/12 max resource size. Texture "

"Size: "

<< size_in_mbs << "MB"

<< " Max: " << D3D11_REQ_RESOURCE_SIZE_IN_MEGABYTES_EXPRESSION_C_TERM

<< "MB";

UNITY_LOG_ERROR(g_Log, msg.str().c_str());

return;

}

ID3D11DeviceContext* ctx = NULL;

m_Device->GetImmediateContext(&ctx);

ID3D11Texture3D* d3dtex;

HRESULT result = m_Device->CreateTexture3D(&desc, NULL, &d3dtex);

if (S_OK != result) {

std::ostringstream msg;

msg << "CreateTexture3D failed, return code: 0x" << std::hex << result;

UNITY_LOG_ERROR(g_Log, msg.str().c_str());

return;

}

std::ostringstream address;

address << "created texture 3D ID3D11Texture3D ptr: 0x" << std::hex << d3dtex;

UNITY_LOG(g_Log, address.str().c_str());

// store created texture handle

m_CreatedTextures.insert({texture_id, d3dtex});

ctx->Release();

}

void* TextureSubPluginAPI_D3D11::RetrieveCreatedTexture3D(uint32_t texture_id) {

if (auto search = m_CreatedTextures.find(texture_id);

search != m_CreatedTextures.end()) {

return search->second;

}

UNITY_LOG_ERROR(g_Log, "no texture was created with the provided texture ID");

return nullptr;

}

void TextureSubPluginAPI_D3D11::DestroyTexture3D(uint32_t texture_id) {

if (auto search = m_CreatedTextures.find(texture_id);

search != m_CreatedTextures.end()) {

search->second->Release();

return;

}

UNITY_LOG_ERROR(g_Log,

"failed to destroy texture 3D (texture ID does not refer to "

"a created texture 3D)");

}

#endif // #if SUPPORT_D3D11