#include "GXD3Dshader.h"

namespace GearXD3D
{

    GXD3Dshader::GXD3Dshader()
    {
    }

    GXD3Dshader::~GXD3Dshader()
    {
  if (VertexLayout) VertexLayout->Release();
  if (VertexShader) VertexShader->Release();
  if (PixelShader)  PixelShader->Release();
  if (VSBlob)  VSBlob->Release();
    }

    HRESULT GXD3Dshader::CompileShader(WCHAR* fileName, GXD3D& gx)
    {
  HRESULT hr = S_OK;
  

  hr = CompileShaderFromFile(fileName, "VS", "vs_4_0", &VSBlob);
  if (FAILED(hr))
  {
   MessageBox(NULL, L"Файл не найден", L"Ошибка", MB_OK);
   return hr;
  }

  hr = gx.Device->CreateVertexShader(VSBlob->GetBufferPointer(), VSBlob->GetBufferSize(), NULL, &VertexShader);
  if (FAILED(hr))
  {
   VSBlob->Release();
   return hr;
  }  
  
  
  ID3DBlob* pPSBlob = NULL;
  hr = CompileShaderFromFile(fileName, "PS", "ps_4_0", &pPSBlob);
  if (FAILED(hr))
  {
   MessageBox(NULL, L"Файл не найден", L"Ошибка", MB_OK);
   return hr;
  }

  hr = gx.Device->CreatePixelShader(pPSBlob->GetBufferPointer(), pPSBlob->GetBufferSize(), NULL, &PixelShader);
  pPSBlob->Release();
  if (FAILED(hr)) return hr;

  
  return S_OK;
    }

    void GXD3Dshader::SetShader(GXD3D & gx)
    {
  gx.DrawContext->IASetInputLayout(VertexLayout);
     gx.DrawContext->VSSetShader(VertexShader, NULL, 0);
  gx.DrawContext->PSSetShader(PixelShader, NULL, 0);

    }

    void GXD3Dshader::SetConstantBuffer(UINT structSize, GXD3D & gx)
    {
  D3D11_BUFFER_DESC bd;
  ZeroMemory(&bd, sizeof(bd));
  bd.Usage = D3D11_USAGE_DEFAULT;
  bd.ByteWidth = sizeof(ConstantBuffer);  // ������ ������ = ������� ���������
  bd.BindFlags = D3D11_BIND_CONSTANT_BUFFER;    // ��� - ����������� �����
  bd.CPUAccessFlags = 0;

  if (FAILED(gx.Device->CreateBuffer(&bd, NULL, &ConstantBuffer)))
   MessageBox(NULL, L"Чёртов буфер", L"Ошибка", MB_OK);

    }

    void GXD3Dshader::UpdateConstantBuffer(void* data, GXD3D& gx)
    {
  gx.DrawContext->UpdateSubresource(ConstantBuffer, 0, NULL, data, 0, 0);
    }

    void GXD3Dshader::SetConstantBuffer(void * data, GXD3D & gx)
    {
  gx.DrawContext->VSSetConstantBuffers(0, 1, &ConstantBuffer);
    }

    HRESULT GXD3Dshader::AddVertexParam(char* name, GXD3D & gx)
    {
  HRESULT hr = S_OK;

  UINT sizeByte = PosCount * 12 + ColorCount * 16;
  D3D11_INPUT_ELEMENT_DESC* buffer = Layout;  //Копируем ссылку на первый элемент
  Layout = NULL;                    //Сбрасываем указатель на основной массив
  VertexParamCount++;

  Layout = new D3D11_INPUT_ELEMENT_DESC[VertexParamCount];

  for (int i = 0; i < VertexParamCount - 1; i++) {
   *(Layout + i) = *(buffer + i);
  }

  delete[] buffer;

  Layout[VertexParamCount - 1].SemanticName = name;
  Layout[VertexParamCount - 1].SemanticIndex = 0;
  if (!strcmp(name, "POSITION"))
  {
   Layout[VertexParamCount - 1].Format = DXGI_FORMAT_R32G32B32_FLOAT;
   Layout[VertexParamCount - 1].InputSlot = PosCount;
   PosCount++;
  }

  if (!strcmp(name, "COLOR"))
  {
   Layout[VertexParamCount - 1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
   Layout[VertexParamCount - 1].InputSlot = ColorCount;
   ColorCount++;
  }

  
  Layout[VertexParamCount - 1].AlignedByteOffset = sizeByte;
  Layout[VertexParamCount - 1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
  Layout[VertexParamCount - 1].InstanceDataStepRate = 0;

  

  hr = gx.Device->CreateInputLayout(Layout, VertexParamCount, VSBlob->GetBufferPointer(),
   VSBlob->GetBufferSize(), &VertexLayout);
    if (FAILED(hr)) return hr;

    }

    HRESULT GXD3Dshader::CompileShaderFromFile(WCHAR* szFileName, LPCSTR szEntryPoint, LPCSTR szShaderModel, ID3DBlob** ppBlobOut)
    {
  HRESULT hr = S_OK;
  DWORD dwShaderFlags = D3DCOMPILE_ENABLE_STRICTNESS;
  ID3DBlob* pErrorBlob;
  hr = D3DX11CompileFromFile(szFileName, NULL, NULL, szEntryPoint, szShaderModel,
   dwShaderFlags, 0, NULL, ppBlobOut, &pErrorBlob, NULL);
  if (FAILED(hr))
  {
   if (pErrorBlob != NULL)
    OutputDebugStringA((char*)pErrorBlob->GetBufferPointer());
   if (pErrorBlob) pErrorBlob->Release();
   return hr;
  }
  if (pErrorBlob) pErrorBlob->Release();

  return S_OK;
    }
}