This is an incredibly short lesson. Here we will learn how to change our update camera function to a free-cam. We only need to change 3 lines to do this.

First thing we need to do is go to our UpdateCamera() function and either comment out or delete these lines

    	/*    
    	D3DXMATRIX RotateYTempMatrix;
    	D3DXMatrixRotationY(&RotateYTempMatrix, yaw);
    
    	// First-Person Camera	
    	D3DXVec3TransformNormal(&Right, &DefaultRight, &RotateYTempMatrix);
    	D3DXVec3TransformNormal(&Up, &Up, &RotateYTempMatrix);
    	D3DXVec3TransformNormal(&Forward, &DefaultForward, &RotateYTempMatrix);
    	*/

After that, we add these three lines in the commented out or deleted lines place.

The first line here is updating the camera's "right" vector. same as above, but this time instead of updating it based on the rotation around the y axis, we are going to be rotating around all the cameras x and y axis (z axis would result in a "roll").

Next line is updating our forward vector using the rotationMatrix like the previous line.

Finally, the last line is updating the up vector for the camera. to find the up vector, we just need to cross the right and forward vectors.

    	D3DXVec3TransformNormal(&Right, &DefaultRight, &rotationMatrix);
    	D3DXVec3TransformNormal(&Forward, &DefaultForward, &rotationMatrix);
    	D3DXVec3Cross(&Up, &Forward, &Right);

Simple as that!

Here's the final code:

main.cpp
    #include <Windows.h>
    #include <d3d10.h>
    #include <d3dx10.h>
    #include <string>
    #include <vector>
    #include <dinput.h>
    #include <fstream>
    #include <istream>
    #pragma comment (lib, "dinput8.lib")
    #pragma comment (lib, "dxguid.lib")
    #pragma comment(lib, "D3D10.lib")
    #pragma comment(lib, "d3dx10d.lib")
    
    using namespace std;
    
    LPCTSTR WndClassName = L"firstwindow";
    HWND hwnd = NULL;
    
    const int Width  = 300;
    const int Height = 300;
    
    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;
    
    ID3D10EffectShaderResourceVariable* fxDiffuseMapVar;
    ID3D10EffectMatrixVariable* fxWVPVar;
    D3DXMATRIX WVP;
    D3DXMATRIX World;
    D3DXMATRIX View;
    D3DXMATRIX Projection;
    ID3D10EffectVariable* fxLightVar;
    IDirectInputDevice8* DIKeyboard;
    IDirectInputDevice8* DIMouse;
    DIMOUSESTATE mouseLastState;
    LPDIRECTINPUT8 DirectInput;
    vector<ID3DX10Mesh*> meshes;
    int meshCount;
    bool LoadMesh(wstring filename);
    int meshTextures = 0;
    vector<ID3D10ShaderResourceView*> TextureResourceViews;
    vector<UINT> meshSubsets;
    
    DWORD NumVertices;
    DWORD NumFaces;
    
    ID3D10EffectShaderResourceVariable* fxSkyMapVar;
    ID3D10ShaderResourceView* smrv = 0;
    ID3D10EffectTechnique* SkyMapTechnique;
    void CreateSphere(int LatLines, int LongLines);
    
    float moveLeftRight = 0.0f;
    float moveBackForward = 0.0f;
    
    D3DXVECTOR3 Position = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
    D3DXVECTOR3 Target = D3DXVECTOR3( 0.0f, 0.0f, 1.0f);
    D3DXVECTOR3 Up = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );
    D3DXVECTOR3 DefaultForward = D3DXVECTOR3(0.0f,0.0f,1.0f);
    D3DXVECTOR3 DefaultRight = D3DXVECTOR3(1.0f,0.0f,0.0f);
    D3DXVECTOR3 Forward = D3DXVECTOR3(0.0f,0.0f,1.0f);
    D3DXVECTOR3 Right = D3DXVECTOR3(1.0f,0.0f,0.0f);
    
    D3DXMATRIX rotationMatrix;
    
    float yaw = 0.0f;
    float pitch = 0.0f;
    
    void UpdateCamera();
    
    D3DXMATRIX Scale;
    D3DXMATRIX Translation;
    D3DXMATRIX Transformations;
    
    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;
    };
    
    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}
    };
    
    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, 4.0f, -10.0f );
    	Target = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
    	Up = D3DXVECTOR3( 0.0f, 1.0f, 0.0f );	
    	D3DXMatrixLookAtLH( &View, &Position, &Target, &Up );
    
    	return true;
    }
    
    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 UpdateCamera()
    {
    	D3DXMatrixRotationYawPitchRoll( &rotationMatrix, yaw, pitch, 0 );
    	D3DXVec3TransformCoord( &Target, &DefaultForward, &rotationMatrix );
    	D3DXVec3Normalize( &Target, &Target );
    
    	/*
    	D3DXMATRIX RotateYTempMatrix;
    	D3DXMatrixRotationY(&RotateYTempMatrix, yaw);
    
    	// First-Person Camera
    	D3DXVec3TransformNormal(&Right, &DefaultRight, &RotateYTempMatrix);
    	D3DXVec3TransformNormal(&Up, &Up, &RotateYTempMatrix);
    	D3DXVec3TransformNormal(&Forward, &DefaultForward, &RotateYTempMatrix);
    	*/
    
    /************************************New Stuff****************************************************/
    	// Free-Look Camera
    	D3DXVec3TransformNormal(&Right, &DefaultRight, &rotationMatrix);
    	D3DXVec3TransformNormal(&Forward, &DefaultForward, &rotationMatrix);
    	D3DXVec3Cross(&Up, &Forward, &Right);
    /*******************************************************************************************************/
    	
    	Position += moveLeftRight*Right;
    	Position += moveBackForward*Forward;
    
    	moveLeftRight = 0.0f;
    	moveBackForward = 0.0f;
    
    	Target = Position + Target;	
    
    	D3DXMatrixLookAtLH( &View, &Position, &Target, &Up );
    }
    
    
    void DetectInput()
    {
    	float speed = 0.005f;
        
    	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_A] & 0x80)
    	{
    		moveLeftRight -= speed;
    	}
    	if(keyboardState[DIK_D] & 0x80)
    	{
    		moveLeftRight += speed;
    	}
    	if(keyboardState[DIK_W] & 0x80)
    	{
    		moveBackForward += speed;
    	}
    	if(keyboardState[DIK_S] & 0x80)
    	{
    		moveBackForward -= speed;
    	}
    	if((mouseCurrState.lX != mouseLastState.lX) || (mouseCurrState.lY != mouseLastState.lY))
    	{
    		yaw += mouseLastState.lX * 0.001f;
    
    		pitch += mouseCurrState.lY * 0.001f;
    
    		mouseLastState = mouseCurrState;
    	}
    
    	UpdateCamera();
    
    	return;
    }
    
    
    bool LoadMesh(wstring filename)
    {
    	HRESULT hr = 0;
    
    	ID3DX10Mesh* tempMesh; 
    
    	UINT tempMeshSubsets;
    
    	wifstream fileIn (filename.c_str());
    	wstring skipString;
    
    	UINT meshVertices  = 0;
    	UINT meshTriangles = 0;
    
    	if (fileIn)
    	{
    		fileIn >> skipString; // #Subsets
    		fileIn >> tempMeshSubsets;
    		fileIn >> skipString; // #Vertices
    		fileIn >> meshVertices;
    		fileIn >> skipString; // #Faces (Triangles)
    		fileIn >> meshTriangles;
    
    		meshSubsets.push_back(tempMeshSubsets);
    
    		hr = D3DX10CreateMesh(d3dDevice,
    			layout, 
    			3, 
    			layout[0].SemanticName, 
    			meshVertices, 
    			meshTriangles, 
    			D3DX10_MESH_32_BIT, 
    			&tempMesh);
    
    		if(FAILED(hr))
    		{
    			MessageBox(0, L"Mesh Creation - Failed",
    				L"Error", MB_OK);
    			return false;
    		}
    
    		fileIn >> skipString;	//#Subset_info
    		for(UINT i = 0; i < tempMeshSubsets; ++i)
    		{
    			std::wstring diffuseMapFilename;
    
    			fileIn >> diffuseMapFilename;
    
    			ID3D10ShaderResourceView* DiffuseMapResourceView;
    
    			D3DX10CreateShaderResourceViewFromFile(d3dDevice,
    				diffuseMapFilename.c_str(), 0, 0, &DiffuseMapResourceView, 0 );
    
    			TextureResourceViews.push_back(DiffuseMapResourceView);
    
    			meshTextures++;
    		}
    
    		Vertex* verts = new Vertex[meshVertices];
    		fileIn >> skipString;	//#Vertex_info
    		for(UINT i = 0; i < meshVertices; ++i)
    		{
    			fileIn >> skipString;	//Vertex Position
    			fileIn >> verts[i].pos.x;
    			fileIn >> verts[i].pos.y;
    			fileIn >> verts[i].pos.z;
    
    			fileIn >> skipString;	//Vertex Normal
    			fileIn >> verts[i].normal.x;
    			fileIn >> verts[i].normal.y;
    			fileIn >> verts[i].normal.z;
    
    			fileIn >> skipString;	//Vertex Texture Coordinates
    			fileIn >> verts[i].texCoord.x;
    			fileIn >> verts[i].texCoord.y;
    		}
    		tempMesh->SetVertexData(0, verts);
    
    		delete[] verts;
    
    		DWORD* indices = new DWORD[meshTriangles*3];
    		UINT* attributeIndex = new UINT[meshTriangles];
    		fileIn >> skipString;	//#Face_Index
    		for(UINT i = 0; i < meshTriangles; ++i)
    		{
    			fileIn >> indices[i*3+0];
    			fileIn >> indices[i*3+1];
    			fileIn >> indices[i*3+2];
    			fileIn >> attributeIndex[i];	//Current Subset
    		}
    		tempMesh->SetIndexData(indices, meshTriangles*3);
    		tempMesh->SetAttributeData(attributeIndex);
    
    		delete[] indices;
    		delete[] attributeIndex;
    
    		tempMesh->GenerateAdjacencyAndPointReps(0.001f);
    		tempMesh->Optimize(D3DX10_MESHOPT_ATTR_SORT|D3DX10_MESHOPT_VERTEX_CACHE,0,0);
    		tempMesh->CommitToDevice();
    
    		meshCount++;
    		meshes.push_back(tempMesh);
    	}
    	else
    	{
    		MessageBox(0, L"Load Mesh File - Failed",
    			L"Error", MB_OK);
    		return false;
    	}
    
    	return true;
    }
    
    
    void CreateSphere(int LatLines, int LongLines)
    {
    	NumVertices = LatLines * LongLines;
    	NumFaces  = (LatLines-1)*(LongLines-1)*2;
    
    	float sphereYaw = 0.0f;
    	float spherePitch = 0.0f;
    
    	std::vector<Vertex> vertices(NumVertices);
    
    	D3DXVECTOR3 currVertPos = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
    
    	for(DWORD i = 0; i < LatLines; ++i)
    	{
    		sphereYaw = i * (3.14/LatLines);
    		for(DWORD j = 0; j < LongLines; ++j)
    		{
    			spherePitch = j * (3.14/LongLines);
    			D3DXMatrixRotationYawPitchRoll( &rotationMatrix, sphereYaw, spherePitch, 0 );
    			D3DXVec3TransformCoord( &currVertPos, &DefaultForward, &rotationMatrix );	
    			D3DXVec3Normalize( &currVertPos, &currVertPos );
    			vertices[i*LongLines+j].pos = currVertPos;
    		}
    	}
    
    	D3D10_BUFFER_DESC bd;
    	bd.Usage = D3D10_USAGE_IMMUTABLE;
    	bd.ByteWidth = sizeof( Vertex ) * NumVertices;
    	bd.BindFlags = D3D10_BIND_VERTEX_BUFFER;
    	bd.CPUAccessFlags = 0;
    	bd.MiscFlags = 0;
    	D3D10_SUBRESOURCE_DATA InitData;
    	InitData.pSysMem = &vertices[0];
    	d3dDevice->CreateBuffer( &bd, &InitData, &VertexBuffer );
    
    	std::vector<DWORD> indices(NumFaces * 3);
    
    	int k = 0;
    	for(DWORD i = 0; i < LatLines-1; ++i)
    	{
    		for(DWORD j = 0; j < LongLines-1; ++j)
    		{
    			indices[k]   = i*LongLines+j;
    			indices[k+1] = i*LongLines+j+1;
    			indices[k+2] = (i+1)*LongLines+j;
    
    			indices[k+3] = (i+1)*LongLines+j;
    			indices[k+4] = i*LongLines+j+1;
    			indices[k+5] = (i+1)*LongLines+j+1;
    
    			k += 6; // next quad
    		}
    	}
    
    	D3D10_BUFFER_DESC ibd;
    	ibd.Usage = D3D10_USAGE_IMMUTABLE;
    	ibd.ByteWidth = sizeof(DWORD) * NumFaces * 3;
    	ibd.BindFlags = D3D10_BIND_INDEX_BUFFER;
    	ibd.CPUAccessFlags = 0;
    	ibd.MiscFlags = 0;
    	D3D10_SUBRESOURCE_DATA iinitData;
    	iinitData.pSysMem = &indices[0];
    	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);
    
    }
    
    bool InitScene()
    {
    	HRESULT hr = 0;
    	ID3D10Blob* compilationErrors = 0;	
    
    	LoadMesh(L"plane.dat");		//meshes[1]
    
    	LoadMesh(L"sphere.dat");	//meshes[0]
    
    	CreateSphere(10, 10);
    
    	D3DX10_IMAGE_LOAD_INFO loadSMInfo;
    	loadSMInfo.MiscFlags = D3D10_RESOURCE_MISC_TEXTURECUBE;
    
    	ID3D10Texture2D* SMTexture = 0;
    	hr = D3DX10CreateTextureFromFile(d3dDevice, L"skymap.dds", 
    		&loadSMInfo, 0, (ID3D10Resource**)&SMTexture, 0);
    
    	if(FAILED(hr))
    	{
    		MessageBox(0, L"Load cube texture - Failed",
    			L"Error", MB_OK);
    		return false;
    	}
    
    	D3D10_TEXTURE2D_DESC SMTextureDesc;
    	SMTexture->GetDesc(&SMTextureDesc);
    
    	D3D10_SHADER_RESOURCE_VIEW_DESC SMViewDesc;
    	SMViewDesc.Format = SMTextureDesc.Format;
    	SMViewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURECUBE;
    	SMViewDesc.TextureCube.MipLevels = SMTextureDesc.MipLevels;
    	SMViewDesc.TextureCube.MostDetailedMip = 0;
    
    	hr = d3dDevice->CreateShaderResourceView(SMTexture, &SMViewDesc, &smrv);
    
    	if(FAILED(hr))
    	{
    		MessageBox(0, L"Create Cube Texture RV - Failed",
    			L"Error", MB_OK);
    		return false;
    	}
    	SMTexture->Release();
    
    	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);
    
    
    
    	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;
    	}
    
    	Technique = FX->GetTechniqueByName( "Tech" );
    
    	SkyMapTechnique = FX->GetTechniqueByName("SkyMapTech");
    
    	fxWVPVar = FX->GetVariableByName("WVP")->AsMatrix();
    	fxDiffuseMapVar = FX->GetVariableByName("DiffuseMap")->AsShaderResource();
    	fxLightVar  = FX->GetVariableByName("light");
    	fxSkyMapVar = FX->GetVariableByName("SkyMap")->AsShaderResource();
    
    	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();
    
    	DIKeyboard->Unacquire();
    	DIMouse->Unacquire();
    	if( DirectInput ) DirectInput->Release();
    
    	for(int i = 0; i < meshCount; i++)
    		if( meshes[i] ) meshes[i]->Release();
    
    	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, (float)Width/Height, 1.0f, 1000.0f);
    
    	fxLightVar->SetRawValue(&light, 0, sizeof(Light));
    	D3D10_TECHNIQUE_DESC skymaptechDesc;
    	SkyMapTechnique->GetDesc( &skymaptechDesc );
    
    	D3D10_TECHNIQUE_DESC techDesc;
    	Technique->GetDesc( &techDesc );
    
    	D3DXMatrixScaling( &Scale, 1.0f, 1.0f, 1.0f );
    	D3DXMatrixTranslation( &Translation, 0.0f, -3.0f, 0.0f );
    
    	Transformations = Scale * Translation;
    
    	WVP = World * Transformations * View * Projection;
    	fxWVPVar->SetMatrix((float*)&WVP);
    
    	//draw plane
    	for( UINT p = 0; p < techDesc.Passes; ++p )
    	{
    		for(UINT subsetID = 0; subsetID < meshSubsets[0]; ++subsetID)
    		{
    			fxDiffuseMapVar->SetResource(TextureResourceViews[subsetID]);	
    			Technique->GetPassByIndex( p )->Apply( 0 );
    			meshes[0]->DrawSubset(subsetID);
    		}
    	}
    
    	D3DXMatrixScaling( &Scale, 2.0f, 2.0f, 2.0f );
    	D3DXMatrixTranslation( &Translation, 0.0f, 1.0f, 5.0f );
    
    	Transformations = Scale * Translation;
    
    	WVP = World * Transformations * View * Projection;
    	fxWVPVar->SetMatrix((float*)&WVP);
    
    	//draw sphere
    	for( UINT p = 0; p < techDesc.Passes; ++p )
    	{
    		for(UINT subsetID = 0; subsetID < meshSubsets[1]; ++subsetID)
    		{
    			fxDiffuseMapVar->SetResource(TextureResourceViews[subsetID + meshSubsets[0]]);	
    			Technique->GetPassByIndex( p )->Apply( 0 );
    			meshes[1]->DrawSubset(subsetID);
    		}
    	}
    
    	D3DXMatrixScaling( &Scale, 100.0f, 100.0f,100.0f );
    	D3DXMatrixTranslation( &Translation, Position.x, Position.y, Position.z );
    
    	Transformations = Scale * Translation;
    
    	WVP = World * Transformations * View * Projection;
    	fxWVPVar->SetMatrix((float*)&WVP);
    
    	//draw skymap based off loaded mesh sphere
    	fxSkyMapVar->SetResource(smrv);	
    	for( UINT p = 0; p < skymaptechDesc.Passes; ++p )
    	{
    		SkyMapTechnique->GetPassByIndex( p )->Apply( 0 );	
    		d3dDevice->DrawIndexed(NumFaces * 3, 0, 0);
    	}
    
    	SwapChain->Present( 0, 0 );
    }
    
    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;
    }
    
    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);
    }

vertex.fx
    struct Light
    {
    	float3 dir;
    	float4 ambient;
    	float4 diffuse;
    };
    
    cbuffer cbPerFrame
    {
    	Light light;
    };
    
    cbuffer cbPerObject
    {
    	float4x4 WVP;
    };
    
    Texture2D DiffuseMap;
    TextureCube SkyMap;
    
    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;
    };
    
    struct SKYMAP_VS_OUTPUT	//output structure for skymap vertex shader
    {
        float4 Pos : SV_POSITION;
    	float3 texCoord : TEXCOORD;
    };
    
    // Vertex Shader
    VS_OUTPUT VS(float3 inPos : POSITION, float2 inTexCoord : TEXCOORD, float3 normal : NORMAL)
    {
    	VS_OUTPUT output = (VS_OUTPUT)0;
    
    	output.Pos = mul(float4(inPos, 1.0f), WVP);
    
    	output.normal = mul(normal, WVP);
    
    	output.texCoord = inTexCoord;
    
        return output;		//send color and position to pixel shader
    }
    
    SKYMAP_VS_OUTPUT SKYMAP_VS(float3 inPos : POSITION, float2 inTexCoord : TEXCOORD, float3 normal : NORMAL)
    {
    	SKYMAP_VS_OUTPUT output = (SKYMAP_VS_OUTPUT)0;
    
    	output.Pos = mul(float4(inPos, 1.0f), WVP).xyww;
    
    	output.texCoord = inPos;
    
        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);
    }
    
    float4 SKYMAP_PS(SKYMAP_VS_OUTPUT input) : SV_Target
    {
    	return SkyMap.Sample(TriLinearSample, input.texCoord);
    }
    
    RasterizerState NoCulling
    {
    	CullMode = None;
    };
    
    DepthStencilState LessEqualDSS
    {
    	DepthFunc = LESS_EQUAL;
    };
    
    technique10 Tech
    {
        pass P0
        {
            SetVertexShader( CompileShader( vs_4_0, VS() ) );
            SetPixelShader( CompileShader( ps_4_0, PS() ) );
        }
    }
    
    technique10 SkyMapTech
    {
        pass P0
        {
            SetVertexShader( CompileShader( vs_4_0, SKYMAP_VS() ) );
            SetPixelShader( CompileShader( ps_4_0, SKYMAP_PS() ) );
    
    		SetRasterizerState(NoCulling);
    		SetDepthStencilState(LessEqualDSS, 0);
        }
    }