// Файл: diffuse.txt
// Описание: Вершинный шейдер, реализующий рассеянное освещение.

//
// Глобальные переменные используемые для хранения
// матрицы вида, матрицы проекции, фоновой составляющей материала,
// рассеиваемой составляющей материала и вектора освещения,
// указывающего в направлении на источник света.
// Все эти переменные инициализируются из приложения. 
//

matrix ViewMatrix;
matrix ViewProjMatrix;

vector AmbientMtrl;
vector DiffuseMtrl;

vector LightDirection;

//
// Глобальные переменные, используемые для хранения
// интенсивности фонового света (фоновая составляющая
// испускаемого источником света) и интенсивности рассеиваемого
// света (рассеиваемая составляющая испускаемого источником света).
// Эти переменные инициализируются в шейдере.
//

vector DiffuseLightIntensity = {0.0f, 0.0f, 1.0f, 1.0f};
vector AmbientLightIntensity = {0.0f, 0.0f, 0.2f, 1.0f};

//
// Входная и выходная структуры
//

struct VS_INPUT
{
     vector position : POSITION;
     vector normal   : NORMAL;
};
struct VS_OUTPUT
{
     vector position : POSITION;
     vector diffuse  : COLOR;
};

//
// Точка входа
//

VS_OUTPUT Main(VS_INPUT input)
{
     // Обнуляем все члены экземпляра выходной структуры
     VS_OUTPUT output = (VS_OUTPUT)0;

     //
     // Преобразуем местоположение вершины в однородное пространство
     // отсечения и сохраняем его в члене output.position
     //
     output.position = mul(input.position, ViewProjMatrix);

     //
     // Преобразуем вектор освещения и нормаль в пространство вида.
     // Присваиваем компоненте w значение 0, поскольку мы преобразуем
     // векторы, а не точки.
     //
     LightDirection.w = 0.0f;
     input.normal.w   = 0.0f;
     LightDirection   = mul(LightDirection, ViewMatrix);
     input.normal     = mul(input.normal,   ViewMatrix);

     //
     // Вычисляем косинус угла между вектором света и нормалью
     //
     float s = dot(LightDirection, input.normal);

     //
     // Вспомните, что если угол между нормалью поверхности
     // и вектором освещения больше 90 градусов, поверхность
     // не получает света. Следовательно, если угол больше
     // 90 градусов, мы присваиваем s ноль, сообщая тем самым,
     // что поверхность не освещена.
     //
     if(s < 0.0f)
          s = 0.0f;

     //
     // Отраженный фоновый свет вычисляется путем покомпонентного
     // умножения вектора фоновой составляющей материала и вектора
     // интенсивности фонового света.
     //
     // Отраженный рассеиваемый свет вычисляется путем покомпонентного
     // умножения вектора рассеиваемой составляющей материала на вектор
     // интенсивности рассеиваемого света. Затем мы масштабируем полученный
     // вектор, умножая каждую его компоненту на коэффициент затенения s,
     // чтобы затемнить цвет в зависимости от того, сколько света получает
     // вершина от источника.
     //
     // Сумма фоновой и рассеиваемой компонент дает нам
     // итоговый цвет вершины.
     //
     output.diffuse = (AmbientMtrl * AmbientLightIntensity) +
                          (s * (DiffuseLightIntensity * DiffuseMtrl));

     return output;
}

IDirect3DVertexShader9* DiffuseShader = 0;
ID3DXConstantTable* DiffuseConstTable = 0;

ID3DXMesh* Teapot               = 0;

D3DXHANDLE ViewMatrixHandle     = 0;
D3DXHANDLE ViewProjMatrixHandle = 0;
D3DXHANDLE AmbientMtrlHandle    = 0;
D3DXHANDLE DiffuseMtrlHandle    = 0;
D3DXHANDLE LightDirHandle       = 0;

D3DXMATRIX Proj;

bool Setup()
{
     HRESULT hr = 0;

     //
     // Создание геометрии:
     //

     D3DXCreateTeapot(Device, &Teapot, 0);

     //
     // Компиляция шейдера
     //

     ID3DXBuffer* shader      = 0;
     ID3DXBuffer* errorBuffer = 0;

     hr = D3DXCompileShaderFromFile(
              "diffuse.txt",
              0,
              0,
              "Main", // имя точки входа
              "vs_1_1",
              D3DXSHADER_DEBUG,
              &shader,
              &errorBuffer,
              &DiffuseConstTable);

     // Выводим сообщения об ошибках
     if(errorBuffer)
     {
          ::MessageBox(0, (char*)errorBuffer->GetBufferPointer(), 0, 0);
          d3d::Release<ID3DXBuffer*>(errorBuffer);
     }

     if(FAILED(hr))
     {
          ::MessageBox(0, "D3DXCompileShaderFromFile() - FAILED", 0, 0);
          return false;
     }

     //
     // Создаем шейдер
     //

     hr = Device->CreateVertexShader(
             (DWORD*)shader->GetBufferPointer(),
             &DiffuseShader);

     if(FAILED(hr))
     {
          ::MessageBox(0, "CreateVertexShader - FAILED", 0, 0);
          return false;
     }

     d3d::Release<ID3DXBuffer*>(shader);

     //
     // Получаем дескрипторы
     //
     ViewMatrixHandle     = DiffuseConstTable->GetConstantByName(
                                                  0, "ViewMatrix");
     ViewProjMatrixHandle = DiffuseConstTable->GetConstantByName(
                                                  0, "ViewProjMatrix");
     AmbientMtrlHandle    = DiffuseConstTable->GetConstantByName(
                                                  0, "AmbientMtrl");
     DiffuseMtrlHandle    = DiffuseConstTable->GetConstantByName(
                                                  0, "DiffuseMtrl");
     LightDirHandle       = DiffuseConstTable->GetConstantByName(
                                                  0, "LightDirection");

     //
     // Устанавливаем константы шейдера:
     //

     // Направление на источник света:
     D3DXVECTOR4 directionToLight(-0.57f, 0.57f, -0.57f, 0.0f);
     DiffuseConstTable->SetVector(Device, LightDirHandle,
                                            &directionToLight);

     // Материалы:
     D3DXVECTOR4 ambientMtrl(0.0f, 0.0f, 1.0f, 1.0f);
     D3DXVECTOR4 diffuseMtrl(0.0f, 0.0f, 1.0f, 1.0f);
     DiffuseConstTable->SetVector(Device, AmbientMtrlHandle, &ambientMtrl);
     DiffuseConstTable->SetVector(Device, DiffuseMtrlHandle, &diffuseMtrl);
     DiffuseConstTable->SetDefaults(Device);

     // Вычисляем матрицу проекции
     D3DXMatrixPerspectiveFovLH(
          &Proj, D3DX_PI * 0.25f,
          (float)Width / (float)Height, 1.0f, 1000.0f);

     return true;
}

bool Display(float timeDelta)
{
     if(Device)
     {
          //
          // Код обновления матрицы вида пропущен...
          //

          D3DXMATRIX V;
          D3DXMatrixLookAtLH(&V, &position, &target, &up);

          DiffuseConstTable->SetMatrix(Device, ViewMatrixHandle, &V);

          D3DXMATRIX ViewProj = V * Proj;
          DiffuseConstTable->SetMatrix(Device, ViewProjMatrixHandle,
                                       &ViewProj);

          //
          // Визуализация
          //

          Device->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
                        0xffffffff, 1.0f, 0);
          Device->BeginScene();

          Device->SetVertexShader(DiffuseShader);

          Teapot->DrawSubset(0);

          Device->EndScene();
          Device->Present(0, 0, 0, 0);
     }
     return true;
}

void Cleanup()
{
     d3d::Release<ID3DXMesh*>(Teapot);
     d3d::Release<IDirect3DVertexShader9*>(DiffuseShader);
     d3d::Release<ID3DXConstantTable*>(DiffuseConstTable);
}