Jump to content
  • Advertisement
Sign in to follow this  
wabbz111

[DX10] Direct Input

This topic is 2545 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Hi guys, im trying to get direct input to control my scene with a mouse and keyboard.
The source code is based of my previous topic on pyramid creation(which was solved thanks to iedoc and Tsus).
Find the link to the topic here
The source code im using is based on www.braynzarsoft.net (tutorial 16)
Independetly both source codes work fine but upon replacement (I replaced my pyramid creation source code with
his cube creation code.)
I keep getting the following error

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



Share this post


Link to post
Share on other sites
Advertisement
thats because your vertex structure, defined like this:

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;
};


expects 8 arguments, but you are defining your vertices like this:

v[0] = Vertex( 0.0f, 2.5f, 0.0f, 0.0f, 0.5f, 0.5f, 0.0f);

with only 7 arguments, you have 3 for position it looks like, then your are either using 1 for texture coordinates and 3 for the normal, or you are using 2 for texture coords and only 2 for the normal . you should have an extra number in there, like this:

v[0] = Vertex( 0.0f, 2.5f, 0.0f, 0.0f, 0.5f, 0.5f, 0.0f, 0.0f);

where the first three are for the position, second two are for the texture coordinates, and last 3 are for the normal

Share this post


Link to post
Share on other sites
Hi iedoc thanks for the quick reply.
Well i have implemented your changes
it compiles no problem but it shows nothing.
Also i wanted to know if the two texture coordinates
should be the same for all vertices. Thanks.

Share this post


Link to post
Share on other sites
If you haven't figured out why it's not rendering, try uncommenting your draw call laugh.gif

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


to this

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


About the texture coordinates, you could check out lesson 12 and just read the top part. But the two texture coords, u and v, could be looked at like x and y (where x is across and y is up and down). the top left of an image would be (0, 0), and the bottom right (1, 1). top right is (1, 0), and bottom left is (0, 1). so if you were mapping an image to a square, and wanted the image to be stretched across the square, the top left vertex of the square should be (0,0) bottom right (1,1) top right (1,0) and bottom left (0,1). if you wanted the image to be repeated twice across the square, and twice down (total of 4 of the images on the square), you could change the 1's to 2's. i hope that makes sense, haha

Share this post


Link to post
Share on other sites
Thanks iedoc its working (not 100percent) but i think i can
tweak the values to get the texture just right. I will be
moving to the skybox tutorial next. As usual your help
is much appreciated.:rolleyes:

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!