DirectX11-Sample-Tutorial06-光照

最新推荐文章于 2023-04-14 15:58:53 发布
最新推荐文章于 2023-04-14 15:58:53 发布
阅读量793 收藏
点赞数
分类专栏： DirectX 11
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hdhfighting/article/details/45221403
版权

本文主要是对旋转立方体加光照。完整代码看这里。



Tutorial06.fx

//--------------------------------------------------------------------------------------
// Constant Buffer Variables
//--------------------------------------------------------------------------------------
cbuffer ConstantBuffer : register( b0 )
{
	matrix World;
	matrix View;
	matrix Projection;
	float4 vLightDir[2];
	float4 vLightColor[2];
	float4 vOutputColor;
}


//--------------------------------------------------------------------------------------
struct VS_INPUT
{
    float4 Pos : POSITION;
    float3 Norm : NORMAL;
};

struct PS_INPUT
{
    float4 Pos : SV_POSITION;
    float3 Norm : TEXCOORD0;
};


//--------------------------------------------------------------------------------------
// Vertex Shader
//--------------------------------------------------------------------------------------
PS_INPUT VS( VS_INPUT input )
{
    PS_INPUT output = (PS_INPUT)0;
    output.Pos = mul( input.Pos, World );
    output.Pos = mul( output.Pos, View );
    output.Pos = mul( output.Pos, Projection );
    output.Norm = mul( input.Norm, World );
    
    return output;
}


//--------------------------------------------------------------------------------------
// Pixel Shader
//--------------------------------------------------------------------------------------
float4 PS( PS_INPUT input) : SV_Target
{
    float4 finalColor = 0;
    
    //do NdotL lighting for 2 lights
    for(int i=0; i<2; i++)
    {
        finalColor += saturate( dot( (float3)vLightDir[i],input.Norm) * vLightColor[i] );
    }
    finalColor.a = 1;
    return finalColor;
}


//--------------------------------------------------------------------------------------
// PSSolid - render a solid color
//--------------------------------------------------------------------------------------
float4 PSSolid( PS_INPUT input) : SV_Target
{
    return vOutputColor;
}

main.cpp 

#include <Windows.h>
#include <d3d11.h>
#include <D3DX11.h>
#include <D3Dcompiler.h>
#include <xnamath.h>
#include <tchar.h>

//顶点结构
struct SimpleVertex 
{
	XMFLOAT3 Pos;
	XMFLOAT3 Normal;
};

//常缓存结构，包括相机矩阵，和光照等
struct ConstantBuffer
{
	XMMATRIX world;
	XMMATRIX view;
	XMMATRIX projection;//相机矩阵

	XMFLOAT4 vLightDir[2];//光照方向
	XMFLOAT4 vLightColor[2];//光照颜色
	XMFLOAT4 vOutputColor;//输出颜色
};

//全局变量
HINSTANCE g_hInstance	=	NULL;//进程句柄
HWND g_hWnd	=	NULL;//窗口句柄

D3D_DRIVER_TYPE g_driverType	=	D3D_DRIVER_TYPE_HARDWARE;//驱动类型
D3D_FEATURE_LEVEL g_featureLevel	=	D3D_FEATURE_LEVEL_11_0;//SDK版本

ID3D11Device* g_device	=	NULL;//设备，显卡
ID3D11DeviceContext* g_deviceContext	=	NULL;//设备上下文
IDXGISwapChain* g_swapChain	=	NULL;//交换链
ID3D11RenderTargetView* g_renderTargetView	=	NULL;//渲染目标视图

ID3D11Texture2D* g_depthBuffer	=	NULL;//深度缓存
ID3D11DepthStencilView* g_depthStencilView	=	NULL;//深度模板视图

ID3D11VertexShader* g_vertexShader	=	NULL;//顶点着色器
ID3D11PixelShader* g_pixelShader	=	NULL;//像素着色器
ID3D11PixelShader* g_pixelShaderSolid	=	NULL;

ID3D11InputLayout* g_inputLayout	=	NULL;//输入布局
ID3D11Buffer* g_vertexBuffer	=	NULL;//顶点缓存
ID3D11Buffer* g_indexBuffer	=	NULL;//索引缓存

ID3D11Buffer* g_constantBuffer	=	NULL;//常缓存
XMMATRIX g_world;
XMMATRIX g_view;
XMMATRIX g_projection;

//全局函数
HRESULT InitWindow( HINSTANCE hInstance, int nCmdShow );//初始化窗口
HRESULT InitDevice();//初始化d3d设备
HRESULT CompileFromFile( WCHAR* filename, LPCSTR entrypoint, LPCSTR shaderModel, ID3DBlob** ppBlob );//编译着色器文件
LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam );//窗口过程函数
void Render();//渲染
void ShutdownDevice();//关闭设备

//主函数
int WINAPI wWinMain( HINSTANCE hInstance, HINSTANCE hPreInstance, LPWSTR nCmdLine, int nCmdShow )
{
	//初始化窗口
	if ( FAILED( InitWindow( hInstance, nCmdShow ) ) )
	{
		return 0;
	}

	//初始化设备
	if ( FAILED( InitDevice() ) )
	{
		return 0;
	}

	//循环接收消息
	MSG msg;
	ZeroMemory( &msg, sizeof( msg ) );
	while( msg.message != WM_QUIT )
	{
		if ( PeekMessage( &msg, g_hWnd, 0, 0, PM_REMOVE ) )
		{
			TranslateMessage( &msg );
			DispatchMessage( &msg );
		}
		else
		{
			Render();
		}
	}

	ShutdownDevice();

	return ( int )msg.wParam;
}

HRESULT InitWindow( HINSTANCE hInstance, int nCmdShow )
{
	//初始化窗口类
	WNDCLASSEX wcex;
	wcex.cbClsExtra		=	0;
	wcex.cbSize			=	sizeof( WNDCLASSEX );
	wcex.cbWndExtra		=	0;
	wcex.hbrBackground	=	( HBRUSH )GetStockObject( BLACK_BRUSH );
	wcex.hCursor		=	LoadCursor( hInstance, IDC_CROSS );
	wcex.hIcon			=	LoadIcon( hInstance, IDI_WINLOGO );
	wcex.hIconSm		=	wcex.hIcon;
	wcex.hInstance		=	hInstance;
	wcex.lpfnWndProc	=	WndProc;
	wcex.lpszClassName	=	_T("Tutorial06-Class");
	wcex.lpszMenuName	=	NULL;
	wcex.style			=	CS_HREDRAW | CS_VREDRAW;

	//注册窗口类
	if ( !RegisterClassEx( &wcex ) )
	{
		return E_FAIL;
	}

	//创建窗口
	g_hWnd	=	CreateWindow( _T("Tutorial06-Class"),
							  _T("Tutorial06-Window"),
							  WS_OVERLAPPEDWINDOW,
							  CW_USEDEFAULT,
							  CW_USEDEFAULT,
							  640,
							  480,
							  NULL,
							  NULL,
							  hInstance,
							  NULL );
	if ( !g_hWnd )
	{
		return E_FAIL;
	}

	//显示窗口
	ShowWindow( g_hWnd, nCmdShow );

	g_hInstance	=	hInstance;

	return S_OK;
}

HRESULT CompileFromFile( WCHAR* filename, LPCSTR entrypoint, LPCSTR shaderModel, ID3DBlob** ppBlob )
{
	HRESULT hResult;
	ID3DBlob* pErrorBlob;
	hResult	=	D3DX11CompileFromFile( filename, NULL, NULL, entrypoint, shaderModel,
									   D3DCOMPILE_ENABLE_STRICTNESS, 0, NULL, ppBlob, &pErrorBlob, NULL );
	if ( FAILED( hResult ) )
	{
		if ( pErrorBlob != NULL )
		{
			OutputDebugStringA( ( char* )pErrorBlob->GetBufferPointer() );
			pErrorBlob->Release();
			pErrorBlob	=	NULL;
		}
		return hResult;
	}

	if ( pErrorBlob )
	{
		pErrorBlob->Release();
	}

	return S_OK;
}

HRESULT InitDevice()
{
	HRESULT hResult;
	//-----------------------------------------------------------------------------------------
	//初始化交换链描述
	DXGI_SWAP_CHAIN_DESC swapChainDesc;
	ZeroMemory( &swapChainDesc, sizeof( swapChainDesc ) );

	UINT nScreenWidth	=	640;
	UINT nScreenHeight	=	480;
	D3D_DRIVER_TYPE driverTypes[]	=	{
		D3D_DRIVER_TYPE_HARDWARE,
		D3D_DRIVER_TYPE_WARP,
		D3D_DRIVER_TYPE_REFERENCE
	};
	UINT nNumDriverTypes	=	ARRAYSIZE( driverTypes );
	D3D_FEATURE_LEVEL featureLevels[]	=	{
		D3D_FEATURE_LEVEL_11_0,
		D3D_FEATURE_LEVEL_10_1,
		D3D_FEATURE_LEVEL_10_0
	};
	UINT nNumFeatureLevels	=	ARRAYSIZE( featureLevels );

	swapChainDesc.BufferCount	=	1;
	swapChainDesc.BufferDesc.Format		=	DXGI_FORMAT_B8G8R8A8_UNORM;
	swapChainDesc.BufferDesc.Width		=	nScreenWidth;
	swapChainDesc.BufferDesc.Height		=	nScreenHeight;
	swapChainDesc.BufferDesc.RefreshRate.Numerator		=	60;
	swapChainDesc.BufferDesc.RefreshRate.Denominator	=	1;
	swapChainDesc.BufferUsage	=	DXGI_USAGE_RENDER_TARGET_OUTPUT;
	swapChainDesc.OutputWindow	=	g_hWnd;
	swapChainDesc.SampleDesc.Count		=	1;
	swapChainDesc.SampleDesc.Quality	=	0;
	swapChainDesc.Windowed				=	true;

	//创建交换链
	for ( UINT i=0; i<nNumDriverTypes; i++ )
	{
		g_driverType	=	driverTypes[i];
		hResult	=	D3D11CreateDeviceAndSwapChain( NULL,
												   g_driverType,
												   NULL,
												   0,
												   featureLevels,
												   nNumFeatureLevels,
												   D3D11_SDK_VERSION,
												   &swapChainDesc,
												   &g_swapChain,
												   &g_device,
												   &g_featureLevel,
												   &g_deviceContext );
		if ( SUCCEEDED( hResult ) )
		{
			break;
		}
	}

	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	//创建渲染目标视图
	ID3D11Texture2D* backBufer;
	hResult	=	g_swapChain->GetBuffer( 0,
										__uuidof( ID3D11Texture2D ),
										( LPVOID* )&backBufer );//获取后备缓存
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	hResult	=	g_device->CreateRenderTargetView( backBufer,
												  NULL, 
												  &g_renderTargetView );//创建于后备缓存链接的渲染目标视图
	if ( backBufer )
	{
		backBufer->Release();
		backBufer	=	NULL;
	}
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	//-----------------------------------------------------------------------------------------------
	//创建深度缓存
	D3D11_TEXTURE2D_DESC depthBufferDesc;
	ZeroMemory( &depthBufferDesc, sizeof( depthBufferDesc ) );
	depthBufferDesc.Width		=	nScreenWidth;
	depthBufferDesc.Height		=	nScreenHeight;
	depthBufferDesc.ArraySize	=	1;
	depthBufferDesc.BindFlags	=	D3D11_BIND_DEPTH_STENCIL;
	depthBufferDesc.CPUAccessFlags	=	0;
	depthBufferDesc.Format		=	DXGI_FORMAT_D24_UNORM_S8_UINT;
	depthBufferDesc.MipLevels	=	1;
	depthBufferDesc.MiscFlags	=	0;
	depthBufferDesc.SampleDesc.Count	=	1;
	depthBufferDesc.SampleDesc.Quality	=	0;
	depthBufferDesc.Usage		=	D3D11_USAGE_DEFAULT;
	
	hResult	=	g_device->CreateTexture2D( &depthBufferDesc,
										   NULL,
										   &g_depthBuffer );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	//创建深度模板视图
	D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc;
	ZeroMemory( &depthStencilViewDesc, sizeof( depthStencilViewDesc ) );
	depthStencilViewDesc.Format	=	depthBufferDesc.Format;
	depthStencilViewDesc.ViewDimension	=	D3D11_DSV_DIMENSION_TEXTURE2D;
	depthStencilViewDesc.Texture2D.MipSlice	=	0;
	hResult	=	g_device->CreateDepthStencilView( g_depthBuffer,
												  &depthStencilViewDesc,
												  &g_depthStencilView );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}
	g_deviceContext->OMSetRenderTargets( 1, &g_renderTargetView, g_depthStencilView );

	//-------------------------------------------------------------------------------------------------
	//创建视口
	D3D11_VIEWPORT viewport;
	viewport.Width	=	(FLOAT)nScreenWidth;
	viewport.Height	=	(FLOAT)nScreenHeight;
	viewport.MinDepth	=	0.0f;
	viewport.MaxDepth	=	1.0f;
	viewport.TopLeftX	=	0;
	viewport.TopLeftY	=	0;
	g_deviceContext->RSSetViewports( 1, &viewport );

	//----------------------------------------------------------------------------------------------------
	//编译顶点着色器
	ID3DBlob* pVSBlob;
	hResult	=	CompileFromFile( _T("Tutorial06.fx"),
								 "VS",
								 "vs_4_0",
								 &pVSBlob );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	hResult	=	g_device->CreateVertexShader( pVSBlob->GetBufferPointer(),
											  pVSBlob->GetBufferSize(),
											  NULL,
											  &g_vertexShader );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	//定义输入布局
	D3D11_INPUT_ELEMENT_DESC layout[]	=	{
		{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },//顶点
		{ "NORMAL", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },//法线
	};
	UINT nNumElements	=	ARRAYSIZE( layout );

	hResult	=	g_device->CreateInputLayout( layout,
											 nNumElements,
											 pVSBlob->GetBufferPointer(),
											 pVSBlob->GetBufferSize(),
											 &g_inputLayout );
	if ( pVSBlob )
	{
		pVSBlob->Release();
		pVSBlob	=	NULL;
	}
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	g_deviceContext->IASetInputLayout( g_inputLayout );

	//编译像素着色器
	ID3DBlob* pPSBlob;
	hResult	=	CompileFromFile( _T("Tutorial06.fx"),
								 "PS",
								 "ps_4_0",
								 &pPSBlob );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	hResult	=	g_device->CreatePixelShader( pPSBlob->GetBufferPointer(),
											 pPSBlob->GetBufferSize(),
											 NULL,
											 &g_pixelShader );
	if ( pPSBlob )
	{
		pPSBlob->Release();
		pPSBlob	=	NULL;
	}
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	hResult	=	CompileFromFile( _T("Tutorial06.fx"),
								 "PSSolid",
								 "ps_4_0",
								 &pPSBlob );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	hResult	=	g_device->CreatePixelShader( pPSBlob->GetBufferPointer(),
											 pPSBlob->GetBufferSize(),
											 NULL,
											 &g_pixelShaderSolid );
	if ( pPSBlob )
	{
		pPSBlob->Release();
		pPSBlob	=	NULL;
	}
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	//------------------------------------------------------------------------------------------------------------
	//创建顶点缓存
	SimpleVertex vertices[] =
	{
		{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT3( 0.0f, 1.0f, 0.0f ) },
		{ XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT3( 0.0f, 1.0f, 0.0f ) },
		{ XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT3( 0.0f, 1.0f, 0.0f ) },
		{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT3( 0.0f, 1.0f, 0.0f ) },

		{ XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT3( 0.0f, -1.0f, 0.0f ) },
		{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT3( 0.0f, -1.0f, 0.0f ) },
		{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT3( 0.0f, -1.0f, 0.0f ) },
		{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT3( 0.0f, -1.0f, 0.0f ) },

		{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT3( -1.0f, 0.0f, 0.0f ) },
		{ XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT3( -1.0f, 0.0f, 0.0f ) },
		{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT3( -1.0f, 0.0f, 0.0f ) },
		{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT3( -1.0f, 0.0f, 0.0f ) },

		{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT3( 1.0f, 0.0f, 0.0f ) },
		{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT3( 1.0f, 0.0f, 0.0f ) },
		{ XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT3( 1.0f, 0.0f, 0.0f ) },
		{ XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT3( 1.0f, 0.0f, 0.0f ) },

		{ XMFLOAT3( -1.0f, -1.0f, -1.0f ), XMFLOAT3( 0.0f, 0.0f, -1.0f ) },
		{ XMFLOAT3( 1.0f, -1.0f, -1.0f ), XMFLOAT3( 0.0f, 0.0f, -1.0f ) },
		{ XMFLOAT3( 1.0f, 1.0f, -1.0f ), XMFLOAT3( 0.0f, 0.0f, -1.0f ) },
		{ XMFLOAT3( -1.0f, 1.0f, -1.0f ), XMFLOAT3( 0.0f, 0.0f, -1.0f ) },

		{ XMFLOAT3( -1.0f, -1.0f, 1.0f ), XMFLOAT3( 0.0f, 0.0f, 1.0f ) },
		{ XMFLOAT3( 1.0f, -1.0f, 1.0f ), XMFLOAT3( 0.0f, 0.0f, 1.0f ) },
		{ XMFLOAT3( 1.0f, 1.0f, 1.0f ), XMFLOAT3( 0.0f, 0.0f, 1.0f ) },
		{ XMFLOAT3( -1.0f, 1.0f, 1.0f ), XMFLOAT3( 0.0f, 0.0f, 1.0f ) },
	};

	D3D11_BUFFER_DESC bufferDesc;
	ZeroMemory( &bufferDesc, sizeof( bufferDesc ) );
	bufferDesc.Usage		=	D3D11_USAGE_DEFAULT;
	bufferDesc.ByteWidth	=	sizeof( SimpleVertex ) * 24;
	bufferDesc.BindFlags	=	D3D11_BIND_VERTEX_BUFFER;//顶点缓存
	bufferDesc.CPUAccessFlags	=	0;

	D3D11_SUBRESOURCE_DATA initData;
	initData.pSysMem	=	vertices;

	hResult	=	g_device->CreateBuffer( &bufferDesc, &initData, &g_vertexBuffer );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	UINT stride	=	sizeof( SimpleVertex );
	UINT offset	=	0;
	g_deviceContext->IASetVertexBuffers( 0, 1, &g_vertexBuffer, &stride, &offset );

	//创建索引缓存
	WORD indices[] =
	{
		3,1,0,
		2,1,3,

		6,4,5,
		7,4,6,

		11,9,8,
		10,9,11,

		14,12,13,
		15,12,14,

		19,17,16,
		18,17,19,

		22,20,21,
		23,20,22
	};

	bufferDesc.Usage	=	D3D11_USAGE_DEFAULT;
	bufferDesc.ByteWidth	=	sizeof( WORD ) * 36; //36个索引，12个三角面片
	bufferDesc.BindFlags	=	D3D11_BIND_INDEX_BUFFER;
	bufferDesc.CPUAccessFlags	=	0;

	initData.pSysMem	=	indices;

	hResult	=	g_device->CreateBuffer( &bufferDesc, &initData, &g_indexBuffer );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	g_deviceContext->IASetIndexBuffer( g_indexBuffer, DXGI_FORMAT_R16_UINT, 0 );
	g_deviceContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );

	//创建常缓存
	bufferDesc.Usage	=	D3D11_USAGE_DEFAULT;
	bufferDesc.ByteWidth	=	sizeof( ConstantBuffer );
	bufferDesc.BindFlags	=	D3D11_BIND_CONSTANT_BUFFER;
	bufferDesc.CPUAccessFlags	=	0;

	hResult	=	g_device->CreateBuffer( &bufferDesc, NULL, &g_constantBuffer );
	if ( FAILED( hResult ) )
	{
		return hResult;
	}

	//创建相机矩阵
	g_world	=	XMMatrixIdentity();

	XMVECTOR Eye = XMVectorSet( 0.0f, 4.0f, -10.0f, 0.0f );
	XMVECTOR At = XMVectorSet( 0.0f, 1.0f, 0.0f, 0.0f );
	XMVECTOR Up = XMVectorSet( 0.0f, 1.0f, 0.0f, 0.0f );
	g_view = XMMatrixLookAtLH( Eye, At, Up );

	g_projection = XMMatrixPerspectiveFovLH( XM_PIDIV4, nScreenWidth / (FLOAT)nScreenHeight, 0.01f, 100.0f );
	
	return S_OK;
}

LRESULT CALLBACK WndProc( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
	PAINTSTRUCT ps;
	HDC hdc;

	switch( uMsg )
	{
	case WM_PAINT:
		hdc = BeginPaint( hWnd, &ps );
		EndPaint( hWnd, &ps );
		break;

	case WM_DESTROY:
		PostQuitMessage( 0 );
		break;

	default:
		return DefWindowProc( hWnd, uMsg, wParam, lParam );
	}

	return 0;
}

void Render()
{
	//-----------------------------------------------------------------
	//清除背景
	float ClearColor[4] = { 0.0f, 0.125f, 0.3f, 1.0f };
	g_deviceContext->ClearRenderTargetView( g_renderTargetView, ClearColor );
	g_deviceContext->ClearDepthStencilView( g_depthStencilView, D3D11_CLEAR_DEPTH, 1.0f, 0 );

	//--------------------------------------------------------------------
	//设置相机矩阵
	static float t = 0.0f;
	if( g_driverType == D3D_DRIVER_TYPE_REFERENCE )
	{
		t += ( float )XM_PI * 0.0125f;
	}
	else
	{
		static DWORD dwTimeStart = 0;
		DWORD dwTimeCur = GetTickCount();
		if( dwTimeStart == 0 )
			dwTimeStart = dwTimeCur;
		t = ( dwTimeCur - dwTimeStart ) / 1000.0f;
	}

	g_world	=	XMMatrixRotationY( t );

	XMFLOAT4 vLightDirs[2] =
	{
		XMFLOAT4( -0.577f, 0.577f, -0.577f, 1.0f ),
		XMFLOAT4( 0.0f, 0.0f, -1.0f, 1.0f ),
	};

	XMFLOAT4 vLightColors[2] =
	{
		XMFLOAT4( 0.5f, 0.5f, 0.5f, 1.0f ),
		XMFLOAT4( 0.5f, 0.0f, 0.0f, 1.0f )
	};

	XMMATRIX mRotate = XMMatrixRotationY( -2.0f * t );
	XMVECTOR vLightDir = XMLoadFloat4( &vLightDirs[1] );
	vLightDir = XMVector3Transform( vLightDir, mRotate );
	XMStoreFloat4( &vLightDirs[1], vLightDir );

	ConstantBuffer cb1;
	cb1.world	=	XMMatrixTranspose( g_world );
	cb1.view	=	XMMatrixTranspose( g_view );
	cb1.projection	=	XMMatrixTranspose( g_projection );
	cb1.vLightDir[0]	=	vLightDirs[0];
	cb1.vLightDir[1]	=	vLightDirs[1];
	cb1.vLightColor[0]	=	vLightColors[0];
	cb1.vLightColor[1]	=	vLightColors[1];
	cb1.vOutputColor	=	XMFLOAT4( 0,0,0,0 );
	
	g_deviceContext->UpdateSubresource( g_constantBuffer, 0, NULL, &cb1, 0, 0 );
	g_deviceContext->VSSetShader( g_vertexShader, NULL, 0 );
	g_deviceContext->VSSetConstantBuffers( 0, 1, &g_constantBuffer );
	g_deviceContext->PSSetShader( g_pixelShader, NULL, 0 );
	g_deviceContext->PSSetConstantBuffers( 0, 1, &g_constantBuffer );
	g_deviceContext->DrawIndexed( 36, 0, 0);

	//---------------------------------------------------------------
	for ( int m=0; m<2; m++ )
	{
		XMMATRIX mLight	=	XMMatrixTranslationFromVector( 5.0f * XMLoadFloat4( &vLightDirs[m] ) );
		XMMATRIX mLightScale = XMMatrixScaling( 0.2f, 0.2f, 0.2f );
		mLight = mLightScale * mLight;

		cb1.world = XMMatrixTranspose( mLight );
		cb1.vOutputColor = vLightColors[m];
		g_deviceContext->UpdateSubresource( g_constantBuffer, 0, NULL, &cb1, 0, 0 );

		g_deviceContext->PSSetShader( g_pixelShaderSolid, NULL, 0 );
		g_deviceContext->DrawIndexed( 36, 0, 0 );
	}

	//---------------------------------------------------------------------------------
	g_swapChain->Present( 0, 0 );
	return ;
}


void ShutdownDevice()
{
	if ( g_deviceContext )
	{
		g_deviceContext->ClearState();
	}

	if ( g_constantBuffer )
	{
		g_constantBuffer->Release();
		g_constantBuffer	=	NULL;
	}

	if ( g_vertexBuffer )
	{
		g_vertexBuffer->Release();
		g_vertexBuffer	=	NULL;
	}

	if ( g_indexBuffer )
	{
		g_indexBuffer->Release();
		g_indexBuffer	=	NULL;
	}

	if ( g_inputLayout )
	{
		g_inputLayout->Release();
		g_inputLayout	=	NULL;
	}

	if ( g_vertexShader )
	{
		g_vertexShader->Release();
		g_vertexShader	=	NULL;
	}

	if ( g_pixelShaderSolid )
	{
		g_pixelShaderSolid->Release();
		g_pixelShaderSolid	=	NULL;
	}

	if ( g_pixelShader )
	{
		g_pixelShader->Release();
		g_pixelShader	=	NULL;
	}

	if ( g_depthBuffer )
	{
		g_depthBuffer->Release();
		g_depthBuffer	=	NULL;
	}

	if ( g_depthStencilView )
	{
		g_depthStencilView->Release();
		g_depthStencilView	=	NULL;
	}

	if ( g_renderTargetView )
	{
		g_renderTargetView->Release();
		g_renderTargetView	=	NULL;
	}

	if ( g_swapChain )
	{
		g_swapChain->Release();
		g_swapChain	=	NULL;
	}

	if ( g_deviceContext )
	{
		g_deviceContext->Release();
		g_deviceContext	=	NULL;
	}

	if ( g_device )
	{
		g_device->Release();
		g_device	=	NULL;
	}
	return ;
}


狼之魂QQ
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
DirectX11-Sample-Tutorial01-初始化窗口-利用d3d清除窗口背景颜色
hdhfighting的专栏
04-14 2943
1）按照这里的方法配置好DirectX11 2）流程简介 >首先，要初始化窗口，用于显示图形图像。 >其次，创建图形模型（InitModel），如一个三角片，由三个顶点组成，每个顶点有对应的颜色或纹理；然后，创建着色器（InitShader），包括顶点着色器和像素着色器，用于将模型与GPU关联，将模型放入渲染管道线中处理。 >然后，利用Windows的消息循环机制，不断接收
DirectX11-Sample-Tutorial02-初始化窗口-利用d3d绘制三角面片
hdhfighting的专栏
04-15 749
完整代码下载，看这里。 Tutorial02.fx //顶点着色器 float4 VS( float4 Pos : POSITION ) : SV_POSITION { return Pos; } //像素着色器 float4 PS( float4 Pos : SV_POSITION ) : SV_Target { return float4( 1.0f, 1.0f, 0.0f
DirectX11 纹理采样
梦幻DUO的游戏开发之路
10-03 2177
纹理采样1. HLSL纹理采样表示我们知道，Texture2D对象用于在effect文件中表示纹理。不过，还有一种与纹理相关的SamplerState（采样器）对象。它用于描述如何使用过滤器访问纹理资源。下面是它的一些例子：// 在倍增、缩减、多级渐进纹理上使用线性过滤。 SamplerState mySampler0 { Filter = MIN_MAG_MIP_LINEAR; };//
DX11实现纹理采样流程
hnbxs的博客
04-14 980
/纹理采样测试用纹理//TestCrate用于wall纹理。
DX11 纹理
qq_62090651的博客
04-19 748
DX11 纹理 目录 文章目录DX11 纹理题目&要求存在问题学习情况&整体思路一、顶点输入布局二、纹理坐标系三、纹理采样四、其他资源绑定作业相关代码&代码分析思考&小结 题目&要求 题目 给一个立方体六个面贴不同的纹理，并且使用方向光光照 利用纹理数组实现2D纹理动画（09项目中的火焰动画） 给一个立方体六个面贴上同一个纹理，这个纹理利用给定的两张纹理进行合成，并且实现纹理在立方体面上的旋转（提示：顶点着色器），关闭光照，还可以
DirectX11-Sample-Tutorial07-纹理+光照
hdhfighting的专栏
04-23 1013
完整代码看这里。 Tutorial07.fx Texture2D txDiffuse : register( t0 ); SamplerState samLinear : register( s0 ); cbuffer cbNeverChanges : register( b0 ) { matrix view; }; cbuffer cbChangeOnResize
test-sample-for-tutorial
05-30
【压缩包子文件的文件名称列表】"test-sample-for-tutorial-master" 指出这是一个Git仓库的主分支（master分支）的副本。在软件开发中，Git是一种版本控制系统，用于跟踪和管理代码的变化。"master"分支通常被视为...
DirectXSamples06-sample
06-11
In the previous tutorial, we built a minimal Direct3D 10 application that outputs a single color to the window. In this tutorial, we will extend the application to render a single triangle on the ...
Objective-C-Tutorial.md
最新发布
06-24
Objective-C_Tutorial Objective-C_Tutorial Objective-C_Tutorial Objective-C_Tutorial
ANSYS-Fluent-Tutorial-Guide_r170
07-11
ANSYS-Fluent-Tutorial-Guide_r170
DirectX11 Toturial 源代码(整理)
10-08
外国有一本学习DirectX 11的chm教程， 上面有几十篇教程，每一个教程后面都有project code, 分别下载每一个教程后面的code是一件麻烦的事，我将其全部下载并整理 （去掉了vs2010生成的一些没有用的数据文件） 压缩，上传致msdn,方便大家下载教程以及code
Tutorial06_1.rar
08-19
Tutorial06_1 is a directx11 lighting demo, you can use it.
python-sample-vscode-flask-tutorial
04-11
适用于Visual Studio代码的Python / Flask教程此示例包含本教程中完整的程序，请确保访问链接： 。 不包括中间步骤。 它还包含使用生产服务器构建容器所需的Dockerfile和uwsgi.ini文件。 生成的图像既可以在本地使用...
DirectX 11 Tutorial 6 中文翻译版教程: 漫射照明
lanlankong的博客
05-15 380
原英文版地址：http://www.rastertek.com/dx11tut06.html 在本教程中，我将介绍如何使用漫反射照明和Directx11来照亮三维对象。我们将从前面的教程中的代码开始并修改它。 我们将实现的漫射照明类型称为定向照明。定向照明与太阳照亮地球的方式相似。它是一个远离很远的光源，根据它发出光的方向，你可以确定任何物体上的光的数量。然而，与环境照明（另一种照明模式，我们将很...
DirectX11-Sample-Tutorial02-初始化窗口-利用d3d绘制旋转立方体
hdhfighting的专栏
04-16 1397
完整代码看这里。 Tutorial04.fx //-------------------------------------------------------------------------------------- //常缓存结构变量 //----------------------------------------------------------------------
tutorial05.c 和tutorial06.c
tedyxuan的专栏
01-14 973
tutorial05 是要把音频可以同步到视频，也为下一步快进，快退做准备。 因为是音频所以不是简单的delay，需要进行音频缓冲的管理，synchronize_audio 返回的是一个同步好的缓冲区。 tutorial06.c 是要用一些API，实现快进或者快退。注意我们要清空我们自己的缓存。     if(is->seek_req) {      int stream_
改进粒子系统-动态编译Shader
热门推荐
游戏编程实践
06-22 1万+
改进粒子系统-动态编译Shader动态决定需要编译的FX代码       请教了几个朋友，最后决定用使用FX支持的宏定义解决这个问题。       根据粒子使用的发射器和效果器定义不同的宏，在FX文件中通过判断相应的宏是否定义（#ifdef…#endif）来决定是否编译某段代码。       FX代码如下： struct VS_INPUT{    float3

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值