#include "DX12Shader.h"

#include "d3dx12.h"
#include "DX12CommandQueue.h"

using namespace Framework;

DX12Shader::DX12Shader(ID3D12Device* device,
    DX12CopyCommandQueue* copy,
    DX12DirectCommandQueue* direct)
    : Shader()
{
    shaderByteBuffer = 0;
    byteBufferSize = 0;
    this->device = device;
    this->copy = copy;
    this->direct = direct;
}

DX12Shader::~DX12Shader()
{
    delete[] shaderByteBuffer;
}

// erstellt ein constanten Buffer, der constante daten an den Shader übergibt
// es können maximal 14 Buffer erstellt werden
//  zD3d11Device: Das Device, mit dem der Buffer erstellt werden soll
//  size: Die größe des buffers in byte
//  index: Die position des Buffers im Buffer Array. Bereits vorhanderner Buffer
//  wird ersetzt. Buffer 1 kann nicht erstellt werden, wenn Buffer 0 noch nicht
//  erstellt wurde usw.
bool DX12Shader::erstelleConstBuffer(int size, int index)
{
    if (index < 0 || index >= 14) return 0;
    while ((size / 256) * 256 != size)
        size++;
    while (!constBuffers->hat(index))
        constBuffers->add(0);
    constBuffers->set(new DX12VertexBuffer(1, device, copy, direct), index);
    constBuffers->z(index)->setLength(size);
    constBuffers->z(index)->copieren();
    return 1;
}

// Setzt den Compilierten Shader
//  zD3d11Device: Das Device, mit welchem der Shader erstellt werden soll
//  bytes: Die Bytes des compilierten codes
//  length: die Länge des bytearrays
//  return: true, wenn bytes gültig ist, false sonst
bool DX12Shader::setCompiledByteArray(unsigned char* bytes, int length)
{
    delete[] shaderByteBuffer;
    shaderByteBuffer = new unsigned char[length];
    memcpy(shaderByteBuffer, bytes, length);
    byteBufferSize = length;
    return 1;
}

// Nach dem Aufruf dieser Funktion wird dieser Shader als Pixel Shader benutzt
//  zD3d11Context: Das Context Objekt, mit dem der Shader verwendet werden soll
void DX12Shader::benutzeShader()
{
    // not needet in DirectX 12
}

// gibt die compilierten bytes zurück
unsigned char* DX12Shader::getCompiledShader() const
{
    return shaderByteBuffer;
}

// gitbt die anzahl der compilierten bytes zurück
int DX12Shader::getCompiledLength() const
{
    return byteBufferSize;
}

// Erstellt den RootParameter zu einem constanten buffer
//  index: Der Index des Buffers
//  view: enthält nach dem Aufruf die position und größe des buffers im speicher
void DX12Shader::getViewDesc(int index, D3D12_CONSTANT_BUFFER_VIEW_DESC& view)
{
    DX12Buffer* zB = (DX12Buffer*)constBuffers->z(index);
    if (!zB) return;
    view.SizeInBytes = zB->getElementAnzahl() * zB->getElementLength();
    view.BufferLocation = zB->zBuffer()->GetGPUVirtualAddress();
}

DX12PixelShader::DX12PixelShader(ID3D12Device* device,
    DX12CopyCommandQueue* copy,
    DX12DirectCommandQueue* direct)
    : DX12Shader(device, copy, direct)
{}

// Konstruktor
DX12VertexShader::DX12VertexShader(ID3D12Device* device,
    DX12CopyCommandQueue* copy,
    DX12DirectCommandQueue* direct)
    : DX12Shader(device, copy, direct)
{
    inputLayout = 0;
    inputLayoutSize = 0;
}

// Destruktor
DX12VertexShader::~DX12VertexShader()
{
    delete[] inputLayout;
}

// erstellt ein InputLayout für den Shader
// Darf erst nach compile aufgerufen werden
//  zD3d11Device: Das Device, mit dem das Layout erstellt werden soll
//  descArray: Ein Array mit initialisierungsdaten
//  anz: Die Anzahl der Elemente im Array
bool DX12VertexShader::erstelleInputLayout(
    D3D12_INPUT_ELEMENT_DESC* descArray, int anz)
{
    delete[] inputLayout;
    inputLayout = new D3D12_INPUT_ELEMENT_DESC[anz];
    memcpy(inputLayout, descArray, anz * sizeof(D3D12_INPUT_ELEMENT_DESC));
    inputLayoutSize = anz;
    return 1;
}

// Gint die Anzahl an eingabeparametern des Shaders zurück
int DX12VertexShader::getInputLayoutSize() const
{
    return inputLayoutSize;
}

// Gibt eine Liste mit formaten für jeden Eingabewert zurück
D3D12_INPUT_ELEMENT_DESC* DX12VertexShader::zInputLayout() const
{
    return inputLayout;
}