[DX10] Direct Input

error C2661: 'Vertex::Vertex' : no overloaded function takes 7 arguments
[/quote]

The main file

#include <Windows.h>
#include <d3d10.h>
#include <d3dx10.h>
#include <string>

////////////////////new//////////////////////////////////////////////////////////////////////
#include <dinput.h>
#pragma comment (lib, "dinput8.lib")
#pragma comment (lib, "dxguid.lib")
////////////////////new//////////////////////////////////////////////////////////////////////
#pragma comment(lib, "D3D10.lib")
#pragma comment(lib, "d3dx10d.lib")

LPCTSTR WndClassName = L"firstwindow";
HWND hwnd = NULL;

const int Width = 800;
const int Height = 600;

bool InitializeWindow(HINSTANCE hInstance,
int ShowWnd,
int width, int height,
bool windowed);

HRESULT hr;
ID3D10Device* d3dDevice;
IDXGISwapChain* SwapChain;
ID3D10RenderTargetView* RenderTargetView;
ID3D10Effect* FX;
ID3D10InputLayout* VertexLayout;
ID3D10Buffer* VertexBuffer;
ID3D10Buffer* IndexBuffer;
ID3D10EffectTechnique* Technique;
ID3D10DepthStencilView* DepthStencilView;
ID3D10Texture2D* DepthStencilBuffer;
ID3D10ShaderResourceView* DiffuseMapResourceView;
ID3D10EffectShaderResourceVariable* fxDiffuseMapVar;
ID3D10EffectMatrixVariable* fxWVPVar;
D3DXMATRIX WVP;
D3DXMATRIX World;
D3DXMATRIX View;
D3DXMATRIX Projection;
D3DXVECTOR3 Position;
D3DXVECTOR3 Target;
D3DXVECTOR3 Up;
ID3D10EffectVariable* fxLightVar;
//////////////////////////////new/////////////////////////////////////////////////////////
IDirectInputDevice8* DIKeyboard;
IDirectInputDevice8* DIMouse;
DIMOUSESTATE mouseLastState;
LPDIRECTINPUT8 DirectInput;

float rotx = 0;
float rotz = 0;
float moveUD = 0;
float moveLR = 0;

D3DXMATRIX Rotationx;
D3DXMATRIX Rotationz;
////////////////////new//////////////////////////////////////////////////////////////////////

D3DXMATRIX Rotation;
D3DXMATRIX Scale;
D3DXMATRIX Translation;
D3DXMATRIX Transformations;
float rot = 0.01f;

bool InitializeDirect3dApp(HINSTANCE hInstance);
bool InitDirectInput(HINSTANCE hInstance);
void DetectInput();
bool InitScene();
void DrawScene();
bool ReleaseObjects();
int messageloop();

LRESULT CALLBACK WndProc(HWND hWnd,
UINT msg,
WPARAM wParam,
LPARAM lParam);


struct Vertex
{
Vertex(){}
Vertex(float x, float y, float z,
float u, float v, float nx, float ny, float nz)
: pos(x,y,z), texCoord(u,v), normal(nx,ny,nz){}

D3DXVECTOR3 pos;
D3DXVECTOR2 texCoord;
D3DXVECTOR3 normal;
};

struct Light
{
Light()
{
ZeroMemory(this, sizeof(Light));
}
D3DXVECTOR3 dir;
float pad;
D3DXCOLOR ambient;
D3DXCOLOR diffuse;
};

Light light;


int WINAPI WinMain(HINSTANCE hInstance, //Main windows function
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nShowCmd)
{

if(!InitializeWindow(hInstance, nShowCmd, Width, Height, true))
{
MessageBox(0, L"Window Initialization - Failed",
L"Error", MB_OK);
return 0;
}

if(!InitializeDirect3dApp(hInstance))
{
MessageBox(0, L"Direct3D Initialization - Failed",
L"Error", MB_OK);
return 0;
}

if(!InitDirectInput(hInstance))
{
MessageBox(0, L"Direct Input Initialization - Failed",
L"Error", MB_OK);
return 0;
}

if(!InitScene())
{
MessageBox(0, L"Scene Initialization - Failed",
L"Error", MB_OK);
return 0;
}

messageloop();

if(!ReleaseObjects())
{
MessageBox(0, L"Object Releasing - Failed",
L"Error", MB_OK);
return 0;
}

return 0;
}

bool InitializeWindow(HINSTANCE hInstance,
int ShowWnd,
int width, int height,
bool windowed)
{
typedef struct _WNDCLASS {
UINT cbSize;
UINT style;
WNDPROC lpfnWndProc;
int cbClsExtra;
int cbWndExtra;
HANDLE hInstance;
HICON hIcon;
HCURSOR hCursor;
HBRUSH hbrBackground;
LPCTSTR lpszMenuName;
LPCTSTR lpszClassName;
} WNDCLASS;

WNDCLASSEX wc;

wc.cbSize = sizeof(WNDCLASSEX);
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = NULL;
wc.cbWndExtra = NULL;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 2);
wc.lpszMenuName = NULL;
wc.lpszClassName = WndClassName;
wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);

if (!RegisterClassEx(&wc))
{
MessageBox(NULL, L"Error registering class",
L"Error", MB_OK | MB_ICONERROR);
return 1;
}

hwnd = CreateWindowEx(
NULL,
WndClassName,
L"Window Title",
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT,
width, height,
NULL,
NULL,
hInstance,
NULL
);

if (!hwnd)
{
MessageBox(NULL, L"Error creating window",
L"Error", MB_OK | MB_ICONERROR);
return 1;
}

ShowWindow(hwnd, ShowWnd);
UpdateWindow(hwnd);


return true;
}

bool InitializeDirect3dApp(HINSTANCE hInstance)
{
UINT createDeviceFlags = 0;

D3D10_DRIVER_TYPE driverTypes[] =
{
D3D10_DRIVER_TYPE_HARDWARE,
D3D10_DRIVER_TYPE_REFERENCE,
};
UINT numDriverTypes = sizeof( driverTypes ) / sizeof( driverTypes[0] );

DXGI_SWAP_CHAIN_DESC scd;
scd.BufferDesc.Width = Width;
scd.BufferDesc.Height = Height;
scd.BufferDesc.RefreshRate.Numerator = 60;
scd.BufferDesc.RefreshRate.Denominator = 1;
scd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
scd.BufferDesc.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;
scd.BufferDesc.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;

//no multisampling
scd.SampleDesc.Count = 1;
scd.SampleDesc.Quality = 0;

scd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
scd.BufferCount = 1;
scd.OutputWindow = hwnd;
scd.Windowed = true;
scd.SwapEffect = DXGI_SWAP_EFFECT_DISCARD;
scd.Flags = 0;

D3D10CreateDeviceAndSwapChain(0, D3D10_DRIVER_TYPE_HARDWARE, 0, 0, D3D10_SDK_VERSION, &scd, &SwapChain, &d3dDevice);

ID3D10Texture2D* backBuffer;
SwapChain->GetBuffer(0, _uuidof(ID3D10Texture2D), reinterpret_cast<void**>(&backBuffer));
d3dDevice->CreateRenderTargetView(backBuffer, 0, &RenderTargetView);
backBuffer->Release();

D3D10_TEXTURE2D_DESC depthStencilDesc;

depthStencilDesc.Width = Width;
depthStencilDesc.Height = Height;
depthStencilDesc.MipLevels = 1;
depthStencilDesc.ArraySize = 1;
depthStencilDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT;
depthStencilDesc.SampleDesc.Count = 1;
depthStencilDesc.SampleDesc.Quality = 0;
depthStencilDesc.Usage = D3D10_USAGE_DEFAULT;
depthStencilDesc.BindFlags = D3D10_BIND_DEPTH_STENCIL;
depthStencilDesc.CPUAccessFlags = 0;
depthStencilDesc.MiscFlags = 0;

d3dDevice->CreateTexture2D(&depthStencilDesc, NULL, &DepthStencilBuffer);
d3dDevice->CreateDepthStencilView(DepthStencilBuffer, NULL, &DepthStencilView);

d3dDevice->OMSetRenderTargets(1, &RenderTargetView, DepthStencilView);

// Setup the viewport
D3D10_VIEWPORT vp;
vp.Width = Width;
vp.Height = Height;
vp.MinDepth = 0.0f;
vp.MaxDepth = 1.0f;
vp.TopLeftX = 0;
vp.TopLeftY = 0;
d3dDevice->RSSetViewports( 1, &vp );

D3DXMatrixIdentity( &World );

Position = D3DXVECTOR3( 0.0f, 6.0f, -14.0f );
Target = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
Up = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
D3DXMatrixLookAtLH( &View, &Position, &Target, &Up );

return true;
}

////////////////////new//////////////////////////////////////////////////////////////////////
bool InitDirectInput(HINSTANCE hInstance)
{
DirectInput8Create(hInstance,
DIRECTINPUT_VERSION,
IID_IDirectInput8,
(void**)&DirectInput,
NULL);

DirectInput->CreateDevice(GUID_SysKeyboard,
&DIKeyboard,
NULL);

DirectInput->CreateDevice(GUID_SysMouse,
&DIMouse,
NULL);

DIKeyboard->SetDataFormat(&c_dfDIKeyboard);
DIKeyboard->SetCooperativeLevel(hwnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE);

DIMouse->SetDataFormat(&c_dfDIMouse);
DIMouse->SetCooperativeLevel(hwnd, DISCL_EXCLUSIVE | DISCL_NOWINKEY | DISCL_FOREGROUND);

return true;
}

void DetectInput()
{
DIMOUSESTATE mouseCurrState;

BYTE keyboardState[256];

DIKeyboard->Acquire();
DIMouse->Acquire();

DIMouse->GetDeviceState(sizeof(DIMOUSESTATE), &mouseCurrState);

DIKeyboard->GetDeviceState(sizeof(keyboardState),(LPVOID)&keyboardState);


if(keyboardState[DIK_ESCAPE] & 0x80)
PostMessage(hwnd, WM_DESTROY, 0, 0);

if(keyboardState[DIK_LEFT] & 0x80)
{
rotz -= 0.0005f;
}
if(keyboardState[DIK_RIGHT] & 0x80)
{
rotz += 0.0005f;
}
if(keyboardState[DIK_UP] & 0x80)
{
rotx += 0.0005f;
}
if(keyboardState[DIK_DOWN] & 0x80)
{
rotx -= 0.0005f;
}
if(mouseCurrState.lX != mouseLastState.lX)
{
moveLR -= (mouseCurrState.lX * 0.001f);
}
if(mouseCurrState.lY != mouseLastState.lY)
{
moveUD += (mouseCurrState.lY * 0.001f);
}

if ( rotx > (float) 6.283185 )
rotx -= (float)6.283185;
else if ( rotx < 0 )
rotx = (float)6.283185 + rotx;

if ( rotz > (float)6.283185 )
rotz -= (float)6.283185;
else if ( rotz < 0 )
rotz = (float)6.283185 + rotz;

mouseLastState = mouseCurrState;

return;
}
////////////////////new//////////////////////////////////////////////////////////////////////

bool InitScene()
{

light.dir = D3DXVECTOR3(0.25f, 0.5f, -1.0f);
light.ambient = D3DXCOLOR(0.2f, 0.2f, 0.2f, 1.0f);
light.diffuse = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);

Vertex v[5];
/*

{D3DXVECTOR3( 0.0f, 2.5f, 0.0f ), D3DXVECTOR4( 0.0f, 0.5f, 0.5f, 0.0f )}, // Position, Color
{D3DXVECTOR3( 2.5f, -2.5f, 2.5f ), D3DXVECTOR4( 1.0f, 0.0f, 0.0f, 0.0f )}, // Position, Color
{D3DXVECTOR3( -2.5f, -2.5f, 2.5f ), D3DXVECTOR4( 0.0f, 1.0f, 0.0f, 0.0f )}, // Position, Color
{D3DXVECTOR3( 2.5f, -2.5f,-2.5f ), D3DXVECTOR4( 0.0f, 0.0f, 1.0f, 0.0f )}, // Position, Color
{D3DXVECTOR3( -2.5f, -2.5f,-2.5f ), D3DXVECTOR4( 1.0f, 1.0f, 0.0f, 0.0f )} // Position, Color

*/
v[0] = Vertex( 0.0f, 2.5f, 0.0f, 0.0f, 0.5f, 0.5f, 0.0f);
v[1] = Vertex( 2.5f, -2.5f, 2.5f, 1.0f, 0.0f, 0.0f, 0.0f);
v[2] = Vertex( -2.5f, -2.5f, 2.5f, 0.0f, 1.0f, 0.0f, 0.0f);
v[3] = Vertex( 2.5f, -2.5f,-2.5f, 0.0f, 0.0f, 1.0f, 0.0f);

// Back Face
v[4] = Vertex( -2.5f, -2.5f,-2.5f, 1.0f, 1.0f, 0.0f, 0.0f);


/*
// Front Face
v[0] = Vertex(-1.0f, -1.0f, -1.0f, 0.0f, 1.0f,-1.0f, -1.0f, -1.0f);
v[1] = Vertex(-1.0f, 1.0f, -1.0f, 0.0f, 0.0f,-1.0f, 1.0f, -1.0f);
v[2] = Vertex( 1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f);
v[3] = Vertex( 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f, -1.0f, -1.0f);

// Back Face
v[4] = Vertex(-1.0f, -1.0f, 1.0f, 1.0f, 1.0f,-1.0f, -1.0f, 1.0f);
v[5] = Vertex( 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f);
v[6] = Vertex( 1.0f, 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);
v[7] = Vertex(-1.0f, 1.0f, 1.0f, 1.0f, 0.0f,-1.0f, 1.0f, 1.0f);

// Top Face
v[8] = Vertex(-1.0f, 1.0f, -1.0f, 0.0f, 1.0f,-1.0f, 1.0f, -1.0f);
v[9] = Vertex(-1.0f, 1.0f, 1.0f, 0.0f, 0.0f,-1.0f, 1.0f, 1.0f);
v[10] = Vertex( 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f);
v[11] = Vertex( 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f);

// Bottom Face
v[12] = Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f,-1.0f, -1.0f, -1.0f);
v[13] = Vertex( 1.0f, -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, -1.0f);
v[14] = Vertex( 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, -1.0f, 1.0f);
v[15] = Vertex(-1.0f, -1.0f, 1.0f, 1.0f, 0.0f,-1.0f, -1.0f, 1.0f);

// Left Face
v[16] = Vertex(-1.0f, -1.0f, 1.0f, 0.0f, 1.0f,-1.0f, -1.0f, 1.0f);
v[17] = Vertex(-1.0f, 1.0f, 1.0f, 0.0f, 0.0f,-1.0f, 1.0f, 1.0f);
v[18] = Vertex(-1.0f, 1.0f, -1.0f, 1.0f, 0.0f,-1.0f, 1.0f, -1.0f);
v[19] = Vertex(-1.0f, -1.0f, -1.0f, 1.0f, 1.0f,-1.0f, -1.0f, -1.0f);

// Right Face
v[20] = Vertex( 1.0f, -1.0f, -1.0f, 0.0f, 1.0f, 1.0f, -1.0f, -1.0f);
v[21] = Vertex( 1.0f, 1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f, -1.0f);
v[22] = Vertex( 1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 1.0f);
v[23] = Vertex( 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f);*/

D3D10_BUFFER_DESC vbd;
vbd.Usage = D3D10_USAGE_IMMUTABLE;
vbd.ByteWidth = sizeof(Vertex) * 5;
vbd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
vbd.CPUAccessFlags = 0;
vbd.MiscFlags = 0;
D3D10_SUBRESOURCE_DATA vinitData;
vinitData.pSysMem = v;
d3dDevice->CreateBuffer(&vbd, &vinitData, &VertexBuffer);

/*
DWORD indices[] = {
// front face
0, 2, 1,

// back face
0, 3, 4,

// left face
0, 1, 3,

// right face
0, 4, 2,

// top face -> why was here a top face?
//0, 4, 3,
//1, 6, 2,

// bottom face
4, 1, 2,
3, 1, 4
};*/


DWORD i[18];

// Front Face
i[0] = 0; i[1] = 2; i[2] = 1;

//Back
i[3] = 0; i[4] = 3; i[5] = 4;

// Left Face
i[6] = 0; i[7] = 1; i[8] = 3;

//Right
i[9] = 0; i[10] = 4; i[11] = 2;

// Bottom Face
i[12] = 4; i[13] = 1; i[14] = 2;
i[15] = 3; i[16] = 1; i[17] = 4;



/*DWORD i[36];

// Front Face
i[0] = 0; i[1] = 1; i[2] = 2;
i[3] = 0; i[4] = 2; i[5] = 3;

// Back Face
i[6] = 4; i[7] = 5; i[8] = 6;
i[9] = 4; i[10] = 6; i[11] = 7;

// Top Face
i[12] = 8; i[13] = 9; i[14] = 10;
i[15] = 8; i[16] = 10; i[17] = 11;

// Bottom Face
i[18] = 12; i[19] = 13; i[20] = 14;
i[21] = 12; i[22] = 14; i[23] = 15;

// Left Face
i[24] = 16; i[25] = 17; i[26] = 18;
i[27] = 16; i[28] = 18; i[29] = 19;

// Right Face
i[30] = 20; i[31] = 21; i[32] = 22;
i[33] = 20; i[34] = 22; i[35] = 23;*/

D3D10_BUFFER_DESC ibd;
ibd.Usage = D3D10_USAGE_IMMUTABLE;
ibd.ByteWidth = sizeof(DWORD) * 18;
ibd.BindFlags = D3D10_BIND_INDEX_BUFFER;
ibd.CPUAccessFlags = 0;
ibd.MiscFlags = 0;
D3D10_SUBRESOURCE_DATA iinitData;
iinitData.pSysMem = i;
d3dDevice->CreateBuffer(&ibd, &iinitData, &IndexBuffer);

UINT stride = sizeof( Vertex );
UINT offset = 0;
d3dDevice->IASetVertexBuffers( 0, 1, &VertexBuffer, &stride, &offset );
d3dDevice->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_UINT, 0);

D3D10_INPUT_ELEMENT_DESC layout[] =
{
{"POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
{"TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D10_INPUT_PER_VERTEX_DATA, 0},
{"NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 20, D3D10_INPUT_PER_VERTEX_DATA, 0}
};

ID3D10Blob* compilationErrors = 0;
HRESULT hr = 0;
hr = D3DX10CreateEffectFromFile( L"vertex.fx", NULL, NULL, "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
d3dDevice, NULL, NULL, &FX, &compilationErrors, NULL );
if(FAILED(hr))
{
MessageBoxA(0, (char*)compilationErrors->GetBufferPointer(), 0, 0);
compilationErrors->Release();
return false;
}

D3DX10CreateShaderResourceViewFromFile(d3dDevice,
L"PurpleGalaxy.jpg", 0, 0, &DiffuseMapResourceView, 0 );

Technique = FX->GetTechniqueByName( "Tech" );

fxWVPVar = FX->GetVariableByName("WVP")->AsMatrix();
fxDiffuseMapVar = FX->GetVariableByName("DiffuseMap")->AsShaderResource();
fxLightVar = FX->GetVariableByName("light");

D3D10_PASS_DESC PassDesc;
Technique->GetPassByIndex( 0 )->GetDesc( &PassDesc );
d3dDevice->CreateInputLayout( layout, 3, PassDesc.pIAInputSignature,
PassDesc.IAInputSignatureSize, &VertexLayout );

d3dDevice->IASetInputLayout( VertexLayout );

d3dDevice->IASetPrimitiveTopology( D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

return true;
}

bool ReleaseObjects()
{
if( d3dDevice ) d3dDevice->ClearState();

if( VertexBuffer ) VertexBuffer->Release();
if( IndexBuffer ) IndexBuffer->Release();
if( VertexLayout ) VertexLayout->Release();
if( FX ) FX->Release();
if( RenderTargetView ) RenderTargetView->Release();
if( SwapChain ) SwapChain->Release();
if( d3dDevice ) d3dDevice->Release();
if( DiffuseMapResourceView ) DiffuseMapResourceView->Release();

////////////////////new//////////////////////////////////////////////////////////////////////
DIKeyboard->Unacquire();
DIMouse->Unacquire();
DirectInput->Release();
////////////////////new//////////////////////////////////////////////////////////////////////

return true;
}

void DrawScene()
{
//Draw Scene Here
D3DXCOLOR bgColor( 0.0f, 0.0f, 0.0f, 1.0f);
d3dDevice->ClearRenderTargetView( RenderTargetView, bgColor );
d3dDevice->ClearDepthStencilView(DepthStencilView, D3D10_CLEAR_DEPTH|D3D10_CLEAR_STENCIL, 1.0f, 0);

D3DXMatrixPerspectiveFovLH(&Projection, 0.4f*3.14f, Width/Height, 1.0f, 1000.0f);

////////////////////new//////////////////////////////////////////////////////////////////////
D3DXVECTOR3 rotyaxis(0.0f, 1.0f, 0.0f);
D3DXVECTOR3 rotzaxis(0.0f, 0.0f, 1.0f);
D3DXVECTOR3 rotxaxis(1.0f, 0.0f, 0.0f);

D3DXMatrixRotationAxis(&Rotation, &rotyaxis, rot);
D3DXMatrixRotationAxis(&Rotationx, &rotxaxis, rotx);
D3DXMatrixRotationAxis(&Rotationz, &rotzaxis, rotz);
D3DXMatrixTranslation( &Translation, 0.0f, 0.0f, 4.0f );
Transformations = Translation * Rotation * Rotationx * Rotationz;

rot += .0005f;

if ( rot > (float)6.283185 )
rot -= (float)6.283185;
else if ( rot < 0 )
rot = (float)6.283185 + rot;
////////////////////new//////////////////////////////////////////////////////////////////////


WVP = World * Transformations * View * Projection;
fxWVPVar->SetMatrix((float*)&WVP);
fxDiffuseMapVar->SetResource(DiffuseMapResourceView);
fxLightVar->SetRawValue(&light, 0, sizeof(Light));

D3D10_TECHNIQUE_DESC techDesc;
Technique->GetDesc( &techDesc );

/*draw first cube
for( UINT p = 0; p < techDesc.Passes; ++p )
{
Technique->GetPassByIndex( p )->Apply( 0 );
d3dDevice->DrawIndexed(36, 0, 0);
}*/

D3DXMatrixRotationAxis(&Rotation, &rotyaxis, -rot);
D3DXMatrixScaling( &Scale, 1.3f, 1.3f, 1.3f );
D3DXMatrixTranslation( &Translation, moveLR, moveUD, 0.0f );

Transformations = Rotation * Scale * Translation;

WVP = World * Transformations * View * Projection;
fxWVPVar->SetMatrix((float*)&WVP);
/*draw second cube
for( UINT p = 0; p < techDesc.Passes; ++p )
{
Technique->GetPassByIndex( p )->Apply( 0 );
d3dDevice->DrawIndexed(36, 0, 0);
}*/

SwapChain->Present( 0, 0 );
}

////////////////////new//////////////////////////////////////////////////////////////////////
int messageloop(){
MSG msg;
ZeroMemory(&msg, sizeof(MSG));
while(true)
{
BOOL PeekMessageL(
LPMSG lpMsg,
HWND hWnd,
UINT wMsgFilterMin,
UINT wMsgFilterMax,
UINT wRemoveMsg
);

if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
{
if (msg.message == WM_QUIT)
break;
TranslateMessage(&msg);
DispatchMessage(&msg);
}
else{
// run game code
DetectInput();
DrawScene();
}
}
return msg.wParam;
}
////////////////////new//////////////////////////////////////////////////////////////////////

LRESULT CALLBACK WndProc(HWND hwnd,
UINT msg,
WPARAM wParam,
LPARAM lParam)
{
switch( msg )
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
}
return DefWindowProc(hwnd,
msg,
wParam,
lParam);
}



This is the vertex.fx file

//"vertex.fx" file

struct Light
{
float3 dir;
float4 ambient;
float4 diffuse;
};

cbuffer cbPerFrame
{
Light light;
};

cbuffer cbPerObject
{
float4x4 WVP;
};

Texture2D DiffuseMap;

SamplerState TriLinearSample
{
Filter = MIN_MAG_MIP_LINEAR;
};

struct VS_OUTPUT //output structure for vertex shader
{
float4 Pos : SV_POSITION;
float2 texCoord : TEXCOORD;
float3 normal : NORMAL;

};

// Vertex Shader
VS_OUTPUT VS(float4 inPos : POSITION, float2 inTexCoord : TEXCOORD, float3 normal : NORMAL)
{
VS_OUTPUT output = (VS_OUTPUT)0;

output.Pos = mul(inPos, WVP);

output.normal = mul(normal, WVP);

output.texCoord = inTexCoord;

return output; //send color and position to pixel shader
}

// Pixel Shader
float4 PS(VS_OUTPUT input) : SV_Target
{
input.normal = normalize(input.normal);

float4 diffuse = DiffuseMap.Sample( TriLinearSample, input.texCoord );

float3 finalColor;

finalColor = diffuse * light.ambient;
finalColor += saturate(dot(light.dir, input.normal) * light.diffuse * diffuse);

return float4(finalColor, diffuse.a);
}

technique10 Tech
{
pass P0
{
SetVertexShader( CompileShader( vs_4_0, VS() ) );
SetPixelShader( CompileShader( ps_4_0, PS() ) );
}
}



Any help will be greatly appreciated. Thanks