bool ShaderClass::createVertexShader(ID3D11Device* pDevice, WCHAR* fileName, CHAR* EntryPoint, ID3D11VertexShader** ppVShader)
{
HRESULT hr;
// Initialie Pixel shader
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* errorMessages;
hr = D3DCompileFromFile(
fileName,
NULL,
NULL,
EntryPoint,
"vs_5_0",
0,
0,
&vertexShaderBuffer,
&errorMessages);
if (FAILED(hr))
{
// If the shader failed to compile it should have writen something to the error message.
if (errorMessages)
{
OutputShaderErrorMessage(errorMessages, fileName);
return false;
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(0, fileName, L"Missing Shader File", MB_OK);
return false;
}
}
// Create the pixel shader from the buffer.
hr = pDevice->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, ppVShader);
if (FAILED(hr))
{
MessageBox(0, L"Failed to create vertex shader", 0, MB_OK);
return false;
}
vertexShaderBuffer->Release();
return true;
}
GLuint ShaderCompiler::CreateProgram(std::vector<GLuint> vShaderList)
{
for (unsigned int i = 0; i < vShaderList.size(); i++)
{
this->vShaderList.push_back(vShaderList[i]);
if (!this->m_OpenGL->CompileShader(vShaderList[i]))
return OutputShaderErrorMessage(vShaderList[i]);
}
this->m_OpenGL->CreateProgram(this->uiShaderProgram);
this->m_OpenGL->AttachShaders(this->uiShaderProgram, this->vShaderList);
if (!this->m_OpenGL->LinkProgram(this->uiShaderProgram))
return OutputLinkerErrorMessage(this->uiShaderProgram);
return this->uiShaderProgram;
}
int ShaderClass::CreateGeometryShader(ID3D11GeometryShader** ppGS, WCHAR* fileName, char* EntryPoint)
{
HRESULT hr;
// Initialie Geometry shader
ID3D10Blob* geometryShaderBuffer;
ID3D10Blob* errorMessages;
hr = D3DCompileFromFile(
fileName,
NULL,
NULL,
EntryPoint,
"gs_5_0",
0,
0,
&geometryShaderBuffer,
&errorMessages);
if (FAILED(hr))
{
// If the shader failed to compile it should have writen something to the error message.
if (errorMessages)
{
OutputShaderErrorMessage(errorMessages, fileName);
return -29;
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(0, fileName, L"Missing Shader File", MB_OK);
return -30;
}
}
// Create the geometry shader from the buffer.
hr = SystemClass::GetInstance()->mGrapInst->GetDevice()->CreateGeometryShader(geometryShaderBuffer->GetBufferPointer(), geometryShaderBuffer->GetBufferSize(), NULL, ppGS);
if (FAILED(hr))
{
MessageBox(0, L"Failed to create geometry shader", 0, MB_OK);
return -31;
}
geometryShaderBuffer->Release();
return 0;
}
bool ColorShader::InitializeShader(ID3D11Device* device, HWND hwnd, LPCSTR vsFilename, LPCSTR psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "main", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&vertexShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
else
{
MessageBox(hwnd, (LPCSTR)vsFilename, "Missing Shader File", MB_OK);
}
return false;
}
result = D3DX11CompileFromFile(psFilename, NULL, NULL, "main", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&pixelShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
else
{
MessageBox(hwnd, (LPCSTR)psFilename, "Missing Shader File", MB_OK);
}
return false;
}
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
return false;
}
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
return false;
}
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "COLOR";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
return false;
}
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// matrix desc
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
return false;
}
return true;
}
bool CFontShader::InitShader(ID3D10Device* device, HWND hwnd, WCHAR* filename)
{
HRESULT result;
ID3D10Blob* errorMessage;
D3D10_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D10_PASS_DESC passDesc;
// Met a zero le message d'erreur
errorMessage = 0;
// Charge le shader
result = D3DX10CreateEffectFromFile(filename, NULL, NULL, "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
device, NULL, NULL, &m_effect, &errorMessage, NULL);
if(FAILED(result)){
// Si la compilation a echouee, elle devrait renvoyer un message d'erreur
if(errorMessage){
OutputShaderErrorMessage(errorMessage, hwnd, filename);}
// Si la compilation a echouee au point de meme pas renvoyer d'erreur
else{
MessageBox(hwnd, filename, L"Missing Shader File", MB_OK);}
return false;
}
// Attrape le pointeur vers la technique a l'interieur du shader
m_technique = m_effect->GetTechniqueByName("FontTechnique");
if(!m_technique){
#ifdef _SPHDEBUG_H
SPHDebug::Msg("\t /!\\ CFontShader::InitShader() : Failed to get technique.");
#endif
return false;}
// Met en place le format des donnees a envoyer au shader
// Ca doit etre compatible avec la structure VertexTyoe de la classe ET du shader
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D10_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
// Calcul le nombre d'element
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Attrape la description de la premiere pass de la technique
m_technique->GetPassByIndex(0)->GetDesc(&passDesc);
// Cree l'input layout
result = device->CreateInputLayout(polygonLayout, numElements, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize,
&m_layout);
if(FAILED(result)){
#ifdef _SPHDEBUG_H
SPHDebug::Msg("\t /!\\ CFontShader::InitShader() : Failed to create input layout.");
#endif
return false;}
// Attrape les pointeurs des trois matrices du shader
m_worldMatrixPtr = m_effect->GetVariableByName("worldMatrix")->AsMatrix();
m_viewMatrixPtr = m_effect->GetVariableByName("viewMatrix")->AsMatrix();
m_projectionMatrixPtr = m_effect->GetVariableByName("projectionMatrix")->AsMatrix();
// Attrape le pointeur de la ressource de texture du shader
m_texturePtr = m_effect->GetVariableByName("shaderTexture")->AsShaderResource();
// Attrape le pointeur de la couleur du shader
m_pixelColorPtr = m_effect->GetVariableByName("pixelColor")->AsVector();
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 1. Comple Shaders VS, GS for StreamOut Stage (m_vertexShader_StreamOut|m_geometryShader_StreamOut)
// 2. Create InputLayout for VS stage as struct Particle |vertex buffer bind type|(m_layout_streamOut)
// 3. Create Vertex Buffer m_initBuffer m_DrawBuffer m_StreamOutBuffer
// 4. Create Constant/Uniform Buffer for m_particle_parameter_buffer|m_sampleState_Shader|m_RandomTexSRV_Shader.
bool FireParticalSystemShader::InitializeShader_StreamOut(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename,
WCHAR* gsFilename ,WCHAR* psFilename )
{
HRESULT result;
ID3D10Blob* errorMessage;
////////////////////////////////////////////////////////////////////////////////////////////////////////
// 1. Comple Shaders VS, GS for StreamOut Stage (m_vertexShader_StreamOut|m_geometryShader_StreamOut)
////////////////////////////////////////////////////////////////////////////////////////////////////////
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* geometryShaderBuffer;
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "StreamOutVS", "vs_5_0",
D3D10_SHADER_DEBUG | D3D10_SHADER_SKIP_OPTIMIZATION, 0, NULL,
&vertexShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
result = D3DX11CompileFromFile(L"GeometryShaderFire.hlsl", NULL, NULL, "main", "gs_5_0", D3D10_SHADER_DEBUG | D3D10_SHADER_SKIP_OPTIMIZATION, 0, NULL,
&geometryShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, gsFilename);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
MessageBox(hwnd, gsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(),
NULL, &m_vertexShader_StreamOut);
if(FAILED(result))
{
return false;
}
////////////////////////////////////////////////////////////////////
///Create Geometry Shader with Stream-out
///////////////////////////////////////////////////////////////////
D3D11_SO_DECLARATION_ENTRY pDecl[] =
{
//// semantic name, semantic index, start component, component count, output slot
{ 0 ,"POSITION" , 0, 0, 3, 0 }, // output all components of position
{ 0 ,"VELOCITY" , 0, 0, 3, 0 }, // output the first 2 texture coordinates
{ 0 ,"SIZE" , 0, 0, 2, 0 }, // output the first 2 texture coordinates
{ 0 ,"AGE" , 0, 0, 1, 0 }, // output the first 2 texture coordinates
{ 0 ,"TYPE" , 0, 0, 1, 0 }, // output the first 2 texture coordinates
// semantic name, semantic index, start component, component count, output slot
//{ 0 ,"POSITION", 0, 0, 3, 0 }, // output all components of position
//{ 0 ,"VELOCITY" , 0, 0, 3, 0 }, // output the first 2 texture coordinates
};
result = device->CreateGeometryShaderWithStreamOutput( geometryShaderBuffer->GetBufferPointer(),
geometryShaderBuffer->GetBufferSize(), pDecl, 5, NULL,
0, D3D11_SO_NO_RASTERIZED_STREAM, NULL, &m_geometryShader_StreamOut );
if(FAILED(result))
{
return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
// 2. Create InputLayout for VS stage as struct Particle |vertex buffer bind type|(m_layout_streamOut)
/////////////////////////////////////////////////////////////////////////////////////////////////////////
result = createInputLayoutDesc_StreamOut(device, vertexShaderBuffer);
if(FAILED(result))
{
return false;
}
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
geometryShaderBuffer->Release();
geometryShaderBuffer = 0;
//////////////////////////////////////////////////////////////////////////////////
// 3. Create Vertex Buffer m_initBuffer m_DrawBuffer m_StreamOutBuffer
//////////////////////////////////////////////////////////////////////////////////
FireParticalSystemShader::InitVertextBuffers(device);
////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 4. Create Constant/Uniform Buffer for m_particle_parameter_buffer|m_sampleState_Shader|m_RandomTexSRV_Shader.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
createConstantBuffer_StreamOut(device);
/////////////////////////////////////////////////////////////////////////////////////
return true;
}
bool DepthShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "DepthVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&vertexShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Compile the pixel shader code.
result = D3DX11CompileFromFile(psFilename, NULL, NULL, "DepthPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&pixelShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if(FAILED(result))
{
return false;
}
// Create the pixel shader from the buffer.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if(FAILED(result))
{
return false;
}
// Create the vertex input layout description.
// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "NORMAL";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[1].InputSlot = 1;
polygonLayout[1].AlignedByteOffset = 0;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_INSTANCE_DATA;
polygonLayout[1].InstanceDataStepRate = 1;
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Create the vertex input layout.
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
if(FAILED(result))
{
return false;
}
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// Setup the description of the dynamic matrix constant buffer that is in the vertex shader.
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if(FAILED(result))
{
return false;
}
return true;
}
// |----------------------------------------------------------------------------|
// | InitializeShader |
// |----------------------------------------------------------------------------|
bool Shader::InitializeShader(ID3D11Device* device, WCHAR* vsFilename,
WCHAR* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, m_vertexShaderName,
"vs_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer,
&errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, vsFilename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
DebugPopup(L"Missing shader file.");
}
return false;
}
// Compile the pixel shader code.
result = D3DX11CompileFromFile(psFilename, NULL, NULL, m_pixelShaderName,
"ps_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer,
&errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, psFilename);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
DebugPopup(L"Missing shader file.");
}
return false;
}
// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if(FAILED(result))
{
DebugPopup(L"Could not CreateVertexShader from device.");
return false;
}
// Create the pixel shader from the buffer.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(),
pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if(FAILED(result))
{
DebugPopup(L"Could not CreateVertexShader from device.");
return false;
}
// Initialize input layout
InitializeInputLayout(device, vertexShaderBuffer);
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// Initialize vertex shader buffers
if (! InitializeVertexShaderBuffers(device) )
return false;
// Initialize pixel shader buffers
if (! InitializePixelShaderBuffers(device) )
return false;
return true;
}
bool FontShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR* vsFilename, const WCHAR* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage = nullptr;
// 버텍스 쉐이더 코드를 컴파일한다.
ID3D10Blob* vertexShaderBuffer = nullptr;
result = D3DCompileFromFile(vsFilename, NULL, NULL, "FontVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
if (FAILED(result))
{
// 셰이더 컴파일 실패시 오류메시지를 출력합니다.
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
// 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
else
{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// 픽셀 쉐이더 코드를 컴파일한다.
ID3D10Blob* pixelShaderBuffer = nullptr;
result = D3DCompileFromFile(psFilename, NULL, NULL, "FontPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
if (FAILED(result))
{
// 셰이더 컴파일 실패시 오류메시지를 출력합니다.
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
// 컴파일 오류가 아니라면 셰이더 파일을 찾을 수 없는 경우입니다.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// 버퍼로부터 정점 셰이더를 생성한다.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
return false;
}
// 버퍼에서 픽셀 쉐이더를 생성합니다.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
return false;
}
// 정점 입력 레이아웃 구조체를 설정합니다.
// 이 설정은 ModelClass와 셰이더의 VertexType 구조와 일치해야합니다.
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
// 레이아웃의 요소 수를 가져옵니다.
UINT numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// 정점 입력 레이아웃을 만듭니다.
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
return false;
}
// 더 이상 사용되지 않는 정점 셰이더 퍼버와 픽셀 셰이더 버퍼를 해제합니다.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// 정점 셰이더에 있는 행렬 상수 버퍼의 구조체를 작성합니다.
D3D11_BUFFER_DESC constantBufferDesc;
constantBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
constantBufferDesc.ByteWidth = sizeof(ConstantBufferType);
constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constantBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
constantBufferDesc.MiscFlags = 0;
constantBufferDesc.StructureByteStride = 0;
// 상수 버퍼 포인터를 만들어 이 클래스에서 정점 셰이더 상수 버퍼에 접근할 수 있게 합니다.
result = device->CreateBuffer(&constantBufferDesc, NULL, &m_constantBuffer);
if (FAILED(result))
{
return false;
}
// 텍스처 샘플러 상태 구조체를 생성 및 설정합니다.
D3D11_SAMPLER_DESC samplerDesc;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// 텍스처 샘플러 상태를 만듭니다.
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
return false;
}
// Setup the description of the dynamic pixel constant buffer that is in the pixel shader.
D3D11_BUFFER_DESC pixelBufferDesc;
pixelBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
pixelBufferDesc.ByteWidth = sizeof(PixelBufferType);
pixelBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
pixelBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
pixelBufferDesc.MiscFlags = 0;
pixelBufferDesc.StructureByteStride = 0;
// Create the pixel constant buffer pointer so we can access the pixel shader constant buffer from within this class.
result = device->CreateBuffer(&pixelBufferDesc, NULL, &m_pixelBuffer);
if (FAILED(result))
{
return false;
}
return true;
}
bool CBlurShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
unsigned int numElements;
D3D11_BUFFER_DESC MatrixBufferDesc;
D3D11_BUFFER_DESC LightBufferDesc;
D3D11_BUFFER_DESC ScreenSizeBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
D3D11_SAMPLER_DESC samplerDesc2;
//Inicializamos los valores
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
/************************************************************************/
/* Compilamos los Shaders */
/************************************************************************/
//Compilamos el vertex shader, si hay un error lo dira
result = D3DX11CompileFromFile( vsFilename, NULL, NULL, "BlurVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
0, NULL, &vertexShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
//Si hubo un error, lo debio de haber escrito
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
//Si no esribio nada, significa que no encontro el archivo
else
{
MessageBox(hwnd, L"no se encontro el archivo", L"Error", MB_OK);
}
return false;
}
//Compilamos el pixel shader, si ay un error lo dira
result = D3DX11CompileFromFile( psFilename, NULL, NULL, "BlurPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
0, NULL, &pixelShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
//Si hubo un error, lo debio de haber escrito
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
//Si no esribio nada, significa que no encontro el archivo
else
{
MessageBox(hwnd, L"no se encontro el archivo", L"Error", MB_OK);
}
return false;
}
/************************************************************************/
/* Creamos los buffers a partir de la compilacion */
/************************************************************************/
//creamos el vertex shader del buffer
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
return false;
}
//creamos el pixel shader del buffer
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
return false;
}
/************************************************************************/
/* Creamos el Layout */
/************************************************************************/
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
polygonLayout[2].SemanticName = "NORMAL";
polygonLayout[2].SemanticIndex = 0;
polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[2].InputSlot = 0;
polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[2].InstanceDataStepRate = 0;
//Obtenemos el numero de elementos del Layout
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
//Creamos el Layout del vertex
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
return false;
}
//Liberamos memoria
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
/************************************************************************/
/* creamos el buffer de constantes */
/************************************************************************/
//Creamos el descriptor del buffer de constantes
MatrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
MatrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
MatrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
MatrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
MatrixBufferDesc.MiscFlags = 0;
MatrixBufferDesc.StructureByteStride = 0;
//Creamos el buffer de contsntantes
result = device->CreateBuffer(&MatrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
return false;
}
/************************************************************************/
/* creamos el buffer de luces */
/************************************************************************/
//Creamos el descriptor del buffer de constantes
LightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
LightBufferDesc.ByteWidth = sizeof(LightBufferType);
LightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
LightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
LightBufferDesc.MiscFlags = 0;
LightBufferDesc.StructureByteStride = 0;
//Creamos el buffer de contsntantes
result = device->CreateBuffer(&LightBufferDesc, NULL, &m_lightBuffer);
if (FAILED(result))
{
return false;
}
/************************************************************************/
/* Creamos el sampler para la textura */
/************************************************************************/
//Describimos el comportamiento con la textura
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
//y creamos el sample state
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
return false;
}
//////////////////////////////////////////////////////////////////////////
return true;
}
bool LineShader::InitializeShader(ID3D11Device *pDevice,
HWND hwnd,
WCHAR *vsFilename,
WCHAR *psFilename)
{
HRESULT result;
ID3D10Blob *errorMessage;
ID3D10Blob *vertexShaderBuffer;
ID3D10Blob *pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[1];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DCompileFromFile(vsFilename,
NULL,
NULL,
"Main",
"vs_5_0",
NULL,
NULL,
&vertexShaderBuffer,
&errorMessage);
if (FAILED(result))
{
// If the shader failed to compile show the error message.
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
// If there was nothing in the error message then the file could not be found.
else
{
MessageBox(hwnd, vsFilename, L"Missing shader file", MB_OK);
}
return false;
}
// Compile the pixel shader code.
result = D3DCompileFromFile(psFilename,
NULL,
NULL,
"Main",
"ps_5_0",
NULL,
NULL,
&pixelShaderBuffer,
&errorMessage);
if (FAILED(result))
{
// If the shader failed to compile show error message.
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
// If there was nothing in the error message then the file could not be found.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
result = pDevice->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(),
NULL,
&m_pVertexShader);
if (FAILED(result))
{
return false;
}
result = pDevice->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(),
pixelShaderBuffer->GetBufferSize(),
NULL,
&m_pPixelShader);
if (FAILED(result))
{
return false;
}
// Setup the layout of shader data.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
result = pDevice->CreateInputLayout(polygonLayout,
numElements,
vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(),
&m_pLayout);
if (FAILED(result))
{
return false;
}
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// Description of the dynamic matrix constant buffer.
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
result = pDevice->CreateBuffer(&matrixBufferDesc, NULL, &m_pMatrixBuffer);
if (FAILED(result))
{
return false;
}
return true;
}
bool ColorShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psfilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
//Æ÷ÀÎÅÍ NULL ¼³Á¤
errorMessage = NULL;
vertexShaderBuffer = NULL;
pixelShaderBuffer = NULL;
//Á¤Á¡ ½¦ÀÌ´õ ÄÄÆÄÀÏ
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "ColorVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
else
{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
//Çʼ¿ ½¦ÀÌ´õ ÄÄÆÄÀÏ
result = D3DX11CompileFromFile(psfilename, NULL, NULL, "ColorPixelShader", "ps_5_0" ,D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psfilename);
}
else
{
MessageBox(hwnd, psfilename, L"Missing Shader File", MB_OK);
}
return false;
}
//Á¤Á¡ ¼¼ÀÌ´õ »ý¼º
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &_vertexShader);
if (FAILED(result))
{
return false;
}
//Çȼ¿ ½¦ÀÌ´õ »ý¼º
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &_pixelShader);
if (FAILED(result))
{
return false;
}
//LAYOUT DESC ÀÛ¼º
//ModelClass ÀÇ VertexType °ú ÀÏÄ¡ÇؾßÇÔ
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "COLOR";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
//·¹À̾ƿô ¿ä¼Ò °¹¼ö¸¦ °¡Á®¿È?
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
//¾Æ ¿©±â¼ Á¤Á¡ÀÔ·Â ·¹À̾ƿô »ý¼ºÀ§Çؼ ±×·³
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &_layout);
if (FAILED(result))
{
return false;
}
//ÇØÁ¦ ó¸®
vertexShaderBuffer->Release();
vertexShaderBuffer = NULL;
pixelShaderBuffer->Release();
pixelShaderBuffer = NULL;
//Á¤Á¡½¦ÀÌ´õ Çà·Ä »ó¼ö ¹öÆÛ DESC ÀÛ¼º
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
// »ó¼ö ¹öÆÛ Æ÷ÀÎÅ͸¦ ¸¸µé¾î ÀÌ Å¬·¡½º¿¡¼ Á¤Á¡ ¼¼ÀÌ´õ »ó¼ö ¹öÆÛ¿¡ Á¢±ÙÁA ¤ÌÀÖ°Ô ÇÑ´Ù´Â°Ô ¸Õ¼Ò¸®??
result = device->CreateBuffer(&matrixBufferDesc, NULL, &_matrixBuffer);
if (FAILED(result))
{
return false;
}
return true;
}
bool ShaderHandler::InitializeShader(ID3D11Device * device, HWND hwnd, WCHAR *vsFilename, WCHAR *gsFilename, WCHAR *psFilename)
{
HRESULT hResult;
ID3DBlob* errorMessage = nullptr;
ID3DBlob* pVS = nullptr;
ID3DBlob* pGS = nullptr;
ID3DBlob* pPS = nullptr;
D3D11_BUFFER_DESC matrixBufferDesc;
#pragma region
UINT flags = D3DCOMPILE_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
flags |= D3DCOMPILE_DEBUG;
#endif
// Prefer higher CS shader profile when possible as CS 5.0 provides better performance on 11 - class hardware.
LPCSTR profile = (device->GetFeatureLevel() >= D3D_FEATURE_LEVEL_11_0) ? "vs_5_0" : "cs_4_0";
const D3D_SHADER_MACRO defines[] =
{
"EXAMPLE_DEFINE", "1",
NULL, NULL
};
hResult = D3DCompileFromFile(
vsFilename, // filename VERTEXSHADER_NAME_WCHAR
defines, // optional macros
D3D_COMPILE_STANDARD_FILE_INCLUDE, // optional include files
"main", // entry point
"vs_4_0", // shader model (target)
flags, // shader compile options
0, // effect compile options
&pVS, // double pointer to ID3DBlob
&errorMessage // pointer for Error Blob messages.
// how to use the Error blob, see here
// https://msdn.microsoft.com/en-us/library/windows/desktop/hh968107(v=vs.85).aspx
);
if (FAILED(hResult))
{
//If it failed to complile we should be able to get the error from the data blob
if (errorMessage != nullptr)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
else //If it failed but there was nothing in the error blob, then that means the file could not be located
{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
hResult = D3DCompileFromFile(
psFilename, // filename
nullptr, // optional macros
D3D_COMPILE_STANDARD_FILE_INCLUDE, // optional include files
"main", // entry point
"ps_4_0", // shader model (target)
0, // shader compile options
0, // effect compile options
&pPS, // double pointer to ID3DBlob
&errorMessage // pointer for Error Blob messages.
// how to use the Error blob, see here
// https://msdn.microsoft.com/en-us/library/windows/desktop/hh968107(v=vs.85).aspx
);
if (FAILED(hResult))
{
//If it failed to complile we should be able to get the error from the data blob
if (errorMessage != nullptr)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
else //If it failed but there was nothing in the error blob, then that means the file could not be located
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
#pragma endregion compiling shaders
hResult = device->CreateVertexShader(pVS->GetBufferPointer(), pVS->GetBufferSize(), nullptr, &m_vertexShader);
if (FAILED(hResult))
{
return false;
}
hResult = device->CreatePixelShader(pPS->GetBufferPointer(), pPS->GetBufferSize(), nullptr, &m_pixelShader);
if (FAILED(hResult))
{
return false;
}
hResult = device->CreateInputLayout(INPUT_DESC_UV, ARRAYSIZE(INPUT_DESC_UV), pVS->GetBufferPointer(), pVS->GetBufferSize(), &m_layout);
if (FAILED(hResult))
{
return false;
}
pVS->Release();
pVS = nullptr;
pPS->Release();
pPS = nullptr;
//Setup the constant buffer for the vertices
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferStruct);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
hResult = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(hResult))
{
return false;
}
return true;
}
bool CFontShaderClass::InitalizeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* VertexShaderBuffer;
ID3D10Blob* PixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC ConstantBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
D3D11_BUFFER_DESC PixelBufferDesc;
//Ponemos a 0 los blobs
errorMessage = 0;
VertexShaderBuffer = 0;
PixelShaderBuffer = 0;
//Ahora Compilamos nuestro pixelShader para ver por errores
result = D3DX11CompileFromFile (vsFilename, NULL, NULL, "FontVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
0, NULL, &VertexShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
else
{
MessageBox(hwnd, vsFilename, L"Missing File", MB_OK);
}
return false;
}
//Ahora Compilamos nuestro pixelShader para ver por errores
result = D3DX11CompileFromFile (psFilename, NULL, NULL, "FontPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
0, NULL, &PixelShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
else
{
MessageBox(hwnd, psFilename, L"Missing File", MB_OK);
}
return false;
}
//ahora cremos el vertex Shader
result = device->CreateVertexShader(VertexShaderBuffer->GetBufferPointer(), VertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
return false;
}
//ahora cremos el pixel Shader
result = device->CreatePixelShader(PixelShaderBuffer->GetBufferPointer(), PixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
return false;
}
//Ahora describimos los buffers que estan en el vertex shader
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
//Vemos cuantos layouts tenemos con una division de Bytes
numElements = sizeof(polygonLayout)/sizeof(polygonLayout[0]);
//Creamos el vertex input Layout
result = device->CreateInputLayout(polygonLayout, numElements, VertexShaderBuffer->GetBufferPointer(), VertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
return false;
}
//Ahora liberamos toda la memoria salida para la creacion de buffers
VertexShaderBuffer->Release();
VertexShaderBuffer = 0;
PixelShaderBuffer->Release();
PixelShaderBuffer = 0;
//Especificamos la informacion para el constant buffer
ConstantBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
ConstantBufferDesc.ByteWidth = sizeof(ConstantBufferType);
ConstantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
ConstantBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
ConstantBufferDesc.MiscFlags = 0;
ConstantBufferDesc.StructureByteStride = 0;
//Creamos el buffer de constantes
result = device->CreateBuffer(&ConstantBufferDesc, NULL, &m_constantBuffer);
if (FAILED(result))
{
return false;
}
//describimos el sampler para la textura
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
//creamos el sampler
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
return false;
}
//ahora describimos el buffer pero para el color de pixel
PixelBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
PixelBufferDesc.ByteWidth = sizeof(PixelBufferType);
PixelBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
PixelBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
PixelBufferDesc.MiscFlags = 0;
PixelBufferDesc.StructureByteStride = 0;
//Y lo creamos
result = device->CreateBuffer(&PixelBufferDesc, NULL, &m_PixelBuffer);
if (FAILED(result))
{
return false;
}
return true;
}
bool FontShaderHandler::InitializeShader(ID3D11Device* device, WCHAR* vsFilename, WCHAR* psFilename)
{
HRESULT hresult;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
//init pointers to nullptr
errorMessage = nullptr;
vertexShaderBuffer = nullptr;
pixelShaderBuffer = nullptr;
//Compile the vertex shader code
hresult = D3DCompileFromFile(vsFilename, NULL, NULL, "main", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
if (FAILED(hresult)) {
if (errorMessage) {
OutputShaderErrorMessage(errorMessage, vsFilename);
}
return false;
}
//Compile the pixel shader code
hresult = D3DCompileFromFile(psFilename, NULL, NULL, "main", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
if (FAILED(hresult)) {
if (errorMessage) {
OutputShaderErrorMessage(errorMessage, psFilename);
}
return false;
}
//Create the vertex shader from buffer
hresult = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &this->vertexShader);
if (FAILED(hresult)) {
return false;
}
//Create the pixel shader from buffer
hresult = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &this->pixelShader);
if (FAILED(hresult)) {
return false;
}
//Fill the vertex input layout description
//This needs to match the Model and shader
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
//polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].AlignedByteOffset = 12;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
//Get the number of elements in the layout
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
//Create the vertex input layout.
hresult = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &this->layout);
if (FAILED(hresult)) {
return false;
}
//Release and nullptr the buffers as they are no longer needed
vertexShaderBuffer->Release();
vertexShaderBuffer = nullptr;
pixelShaderBuffer->Release();
pixelShaderBuffer = nullptr;
//Fill the description of the dynamic matrix constant buffer that is in the vertex shader
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferSimple);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
hresult = device->CreateBuffer(&matrixBufferDesc, NULL, &this->matrixBuffer);
if (FAILED(hresult)) {
return false;
}
//Fill the texture sampler state description
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
//Create the texture sampler state
hresult = device->CreateSamplerState(&samplerDesc, &this->samplerState);
if (FAILED(hresult))
{
return false;
}
D3D11_RENDER_TARGET_BLEND_DESC rtbd;
ZeroMemory(&rtbd, sizeof(rtbd));
rtbd.BlendEnable = true;
rtbd.SrcBlend = D3D11_BLEND_INV_SRC_ALPHA;
rtbd.DestBlend = D3D11_BLEND_SRC_ALPHA;
rtbd.BlendOp = D3D11_BLEND_OP_ADD;
rtbd.SrcBlendAlpha = D3D11_BLEND_INV_SRC_ALPHA;
rtbd.DestBlendAlpha = D3D11_BLEND_SRC_ALPHA;
rtbd.BlendOpAlpha = D3D11_BLEND_OP_ADD;
rtbd.RenderTargetWriteMask = D3D10_COLOR_WRITE_ENABLE_ALL;
D3D11_BLEND_DESC blendDesc;
ZeroMemory(&blendDesc, sizeof(blendDesc));
blendDesc.AlphaToCoverageEnable = false;
blendDesc.RenderTarget[0] = rtbd;
device->CreateBlendState(&blendDesc, &this->transparencyBlendState);
return true;
}
bool TextureShaderClass::InitializeShader(ID3D10Device* device, HWND hWnd, WCHAR* filename) {
HRESULT result;
ID3D10Blob* errorMessage;
/*ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;*/
D3D10_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
//D3D10_BUFFER_DESC matrixBufferDesc;
D3D10_PASS_DESC passDesc;
errorMessage = 0;
/*vertexShaderBuffer = 0;
pixelShaderBuffer = 0;*/
result = D3DX10CreateEffectFromFile(filename, NULL, NULL, "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS,
0, device, NULL, NULL, &m_effect, &errorMessage, NULL);
if (FAILED(result)) {
if (errorMessage) {
OutputShaderErrorMessage(errorMessage, hWnd, filename);
} else {
MessageBox(hWnd, filename, L"Missing Shader File", MB_OK);
}
return false;
}
m_technique = m_effect->GetTechniqueByName("TextureTechnique");
if (!m_technique) {
return false;
}
/*result = D3DX11CompileFromFile(psFilename, NULL, NULL, "ColorPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
0, NULL, &pixelShaderBuffer, &errorMessage, NULL);
if (FAILED(result)) {
if (errorMessage) {
OutputShaderErrorMessage(errorMessage, hWnd, psFilename);
} else {
MessageBox(hWnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(),
NULL, &m_vertexShader);
if (FAILED(result)) {
return false;
}
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(),
NULL, &m_pixelShader);
if (FAILED(result)) {
return false;
}*/
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D10_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
m_technique->GetPassByIndex(0)->GetDesc(&passDesc);
result = device->CreateInputLayout(polygonLayout, numElements, passDesc.pIAInputSignature,
passDesc.IAInputSignatureSize, &m_layout);
if (FAILED(result)) {
return false;
}
m_worldMatrixPtr = m_effect->GetVariableByName("worldMatrix")->AsMatrix();
m_viewMatrixPtr = m_effect->GetVariableByName("viewMatrix")->AsMatrix();
m_projectionMatrixPtr = m_effect->GetVariableByName("projectionMatrix")->AsMatrix();
/*vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result)) {
return false;
}*/
m_texturePtr = m_effect->GetVariableByName("shaderTexture")->AsShaderResource();
return true;
}
bool RefractionShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFile, WCHAR* psFile)
{
HRESULT result;
ID3D10Blob* errormsg;
ID3D10Blob* vertexShader;
ID3D10Blob* pixelShader;
D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
unsigned int numElements;
D3D11_SAMPLER_DESC samplerDesc;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_BUFFER_DESC clipPlaneBufferDesc;
D3D11_BUFFER_DESC lightBufferDesc;
errormsg = NULL;
vertexShader = NULL;
pixelShader = NULL;
result = D3DX11CompileFromFile(vsFile, NULL, NULL, "VS", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShader, &errormsg, NULL);
if (FAILED(result))
{
if (errormsg)
{
OutputShaderErrorMessage(errormsg, hwnd, vsFile);
}
else
{
MessageBox(hwnd, vsFile, L"Missing Shader File", MB_OK);
}
return false;
}
result = D3DX11CompileFromFile(psFile, NULL, NULL, "PS", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL
, &pixelShader, &errormsg, NULL);
if (FAILED(result))
{
if (errormsg)
{
OutputShaderErrorMessage(errormsg, hwnd, psFile);
}
else
{
MessageBox(hwnd, psFile, L"Missing ps shader", MB_OK);
}
return false;
}
result = device->CreateVertexShader(vertexShader->GetBufferPointer(), vertexShader->GetBufferSize(), NULL, &_vertexShader);
if (FAILED(result))
{
return false;
}
result = device->CreatePixelShader(pixelShader->GetBufferPointer(), pixelShader->GetBufferSize(), NULL, &_pixelShader);
if (FAILED(result))
{
return false;
}
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
polygonLayout[2].SemanticName = "NORMAL";
polygonLayout[2].SemanticIndex = 0;
polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[2].InputSlot = 0;
polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[2].InstanceDataStepRate = 0;
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
result = device->CreateInputLayout(polygonLayout, numElements, vertexShader->GetBufferPointer(), vertexShader->GetBufferSize(), &_layout);
if (FAILED(result))
{
return false;
}
vertexShader->Release();
vertexShader = NULL;
pixelShader->Release();
pixelShader = NULL;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
result = device->CreateSamplerState(&samplerDesc, &_sampleState);
if (FAILED(result))
{
return false;
}
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&matrixBufferDesc, NULL, &_matrixBuffer);
if (FAILED(result))
{
return false;
}
lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
lightBufferDesc.ByteWidth = sizeof(LightBufferType);
lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
lightBufferDesc.MiscFlags = 0;
lightBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&lightBufferDesc, NULL, &_lightBuffer);
if (FAILED(result))
{
return false;
}
clipPlaneBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
clipPlaneBufferDesc.ByteWidth = sizeof(ClipPlaneBufferType);
clipPlaneBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
clipPlaneBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
clipPlaneBufferDesc.MiscFlags = 0;
clipPlaneBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&clipPlaneBufferDesc, NULL, &_clipPlaneBuffer);
if (FAILED(result))
{
return false;
}
return true;
}
bool RenderShader::InitializeShader(char* vsFilename, char* fsFilename)
{
const char* vertexShaderBuffer;
const char* fragmentShaderBuffer;
int status;
// Load the vertex shader source file into a text buffer.
vertexShaderBuffer = LoadShaderSourceFile(vsFilename);
if(!vertexShaderBuffer)
{
return false;
}
// Load the fragment shader source file into a text buffer.
fragmentShaderBuffer = LoadShaderSourceFile(fsFilename);
if(!fragmentShaderBuffer)
{
return false;
}
// Create a vertex and fragment shader object.
m_vertexShader = g_openGL->glCreateShader(GL_VERTEX_SHADER);
m_fragmentShader = g_openGL->glCreateShader(GL_FRAGMENT_SHADER);
// Copy the shader source code strings into the vertex and fragment shader objects.
g_openGL->glShaderSource(m_vertexShader, 1, &vertexShaderBuffer, NULL);
g_openGL->glShaderSource(m_fragmentShader, 1, &fragmentShaderBuffer, NULL);
// Release the vertex and fragment shader buffers.
delete [] vertexShaderBuffer;
vertexShaderBuffer = 0;
delete [] fragmentShaderBuffer;
fragmentShaderBuffer = 0;
// Compile the shaders.
g_openGL->glCompileShader(m_vertexShader);
g_openGL->glCompileShader(m_fragmentShader);
// Check to see if the vertex shader compiled successfully.
g_openGL->glGetShaderiv(m_vertexShader, GL_COMPILE_STATUS, &status);
if(status != 1)
{
// If it did not compile then write the syntax error message out to a text file for review.
OutputShaderErrorMessage(m_vertexShader, vsFilename);
return false;
}
// Check to see if the fragment shader compiled successfully.
g_openGL->glGetShaderiv(m_fragmentShader, GL_COMPILE_STATUS, &status);
if(status != 1)
{
// If it did not compile then write the syntax error message out to a text file for review.
OutputShaderErrorMessage(m_fragmentShader, fsFilename);
return false;
}
// Create a shader program object.
m_shaderProgram = g_openGL->glCreateProgram();
// Attach the vertex and fragment shader to the program object.
g_openGL->glAttachShader(m_shaderProgram, m_vertexShader);
g_openGL->glAttachShader(m_shaderProgram, m_fragmentShader);
// Bind the shader input variables.
g_openGL->glBindAttribLocation(m_shaderProgram, 0, "inputPosition");
g_openGL->glBindAttribLocation(m_shaderProgram, 1, "inputNormal");
g_openGL->glBindAttribLocation(m_shaderProgram, 2, "inputColor");
g_openGL->glBindAttribLocation(m_shaderProgram, 3, "inputUV");
// Link the shader program.
g_openGL->glLinkProgram(m_shaderProgram);
// Check the status of the link.
g_openGL->glGetProgramiv(m_shaderProgram, GL_LINK_STATUS, &status);
if(status != 1)
{
// If it did not link then write the syntax error message out to a text file for review.
OutputLinkerErrorMessage(m_shaderProgram);
return false;
}
return true;
}
bool TextureShader::InitializeShader(ID3D11Device *device,
HWND hwnd,
WCHAR *vsFilename,
WCHAR *psFilename)
{
HRESULT result;
ID3D10Blob *errorMessage;
ID3D10Blob *vertexShaderBuffer;
ID3D10Blob *pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DCompileFromFile(vsFilename,
NULL,
NULL,
"Main",
"vs_5_0",
NULL,
NULL,
&vertexShaderBuffer,
&errorMessage);
if (FAILED(result))
{
// If the shader failed to compile show the error message.
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
// If there was nothing in the error message then the file could not be found.
else
{
MessageBox(hwnd, vsFilename, L"Missing shader file", MB_OK);
}
return false;
}
// Compile the pixel shader code.
result = D3DCompileFromFile(psFilename,
NULL,
NULL,
"Main",
"ps_5_0",
NULL,
NULL,
&pixelShaderBuffer,
&errorMessage);
if (FAILED(result))
{
// If the shader failed to compile show error message.
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
// If there was nothing in the error message then the file could not be found.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(),
NULL,
&m_pVertexShader);
if (FAILED(result))
{
return false;
}
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(),
pixelShaderBuffer->GetBufferSize(),
NULL,
&m_pPixelShader);
if (FAILED(result))
{
return false;
}
// Setup the layout of shader data.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
result = device->CreateInputLayout(polygonLayout,
numElements,
vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(),
&m_pLayout);
if (FAILED(result))
{
return false;
}
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// Description of the dynamic matrix constant buffer.
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_pMatrixBuffer);
if (FAILED(result))
{
return false;
}
// Per frame buffer for pixel shader
D3D11_BUFFER_DESC perFameBufferDescPS;
perFameBufferDescPS.Usage = D3D11_USAGE_DYNAMIC;
perFameBufferDescPS.ByteWidth = ((sizeof(PerFrameBufferTypePS) + 15) / 16 * 16);
perFameBufferDescPS.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
perFameBufferDescPS.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
perFameBufferDescPS.MiscFlags = 0;
perFameBufferDescPS.StructureByteStride = 0;
result = device->CreateBuffer(&perFameBufferDescPS, NULL, &m_perFameBufferPS);
if (FAILED(result))
{
return false;
}
// Texture sampler state description.
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// Create the texture sampler state.
result = device->CreateSamplerState(&samplerDesc, &m_pSamplerState);
if (FAILED(result))
{
return false;
}
return true;
}
bool FontShader::InitializeShader(ID3D11Device* device, HWND hwnd, LPCSTR vsFilename, LPCSTR psFilename)
{
//////////////// loads the shader files and makes it usable to DirectX and the GPU
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_BUFFER_DESC transparentBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
errorMessage = nullptr;
vertexShaderBuffer = nullptr;
pixelShaderBuffer = nullptr;
// shader compilation into buffers
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "FontVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&vertexShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
else
{
MessageBox(hwnd, vsFilename, "Missing Vertex Shader file!", MB_OK);
}
return false;
}
result = D3DX11CompileFromFile(psFilename, NULL, NULL, "FontPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&pixelShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
else
{
MessageBox(hwnd, psFilename, "Missing Pixel Shader file!", MB_OK);
}
return false;
}
// using buffers to create shader object themselves
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result)) return false;
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result)) return false;
// setting up LAYOUT of data that goes into shader - matches Vertex type in Model class and Shader
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0; // important!
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT; // "border" between position and color - automatically solved by DX11
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
// size of layout desc
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// creating input layout
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result)) return false;
vertexShaderBuffer->Release();
vertexShaderBuffer = nullptr;
pixelShaderBuffer->Release();
vertexShaderBuffer = nullptr;
// setting vertex buffer as constant buffer
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC; // because we want to refresh it every frame
matrixBufferDesc.ByteWidth = sizeof(MatrixBuffer);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER; // because I don't know :(
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
//creating pointer to constant buffer
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result)) return false;
// NEW - for texture sampler setup
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
//create texture sampler state
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result)) return false;
// setup the constant buffer in the transparency pixel shader
transparentBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
transparentBufferDesc.ByteWidth = sizeof(PixelBuffer);
transparentBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
transparentBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
transparentBufferDesc.MiscFlags = 0;
transparentBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&transparentBufferDesc, NULL, &m_pixelBuffer);
if (FAILED(result)) return false;
return true;
}
void BaseShader::loadVertexShader(WCHAR* filename)
{
HRESULT result;
ID3DBlob* errorMessage;
ID3DBlob* vertexShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
unsigned int numElements;
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DCompileFromFile(filename, NULL, NULL, "main", "vs_5_0", D3DCOMPILE_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
if (FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, m_hwnd, filename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(m_hwnd, filename, L"Missing Shader File", MB_OK);
}
exit(0);
}
// Create the vertex shader from the buffer.
result = m_device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
//return false;
}
// Create the vertex input layout description.
// This setup needs to match the VertexType stucture in the MeshClass and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
polygonLayout[2].SemanticName = "NORMAL";
polygonLayout[2].SemanticIndex = 0;
polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[2].InputSlot = 0;
polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[2].InstanceDataStepRate = 0;
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Create the vertex input layout.
result = m_device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(),
&m_layout);
if (FAILED(result))
{
//return false;
}
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
}
bool CLightShader::InitializeShader(ID3D11Device* device, HWND hwnd, char* vsFilename, char* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[3];
unsigned int numElements;
D3D11_SAMPLER_DESC samplerDesc;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_BUFFER_DESC cameraBufferDesc;
D3D11_BUFFER_DESC lightBufferDesc;
// Initialize the pointers
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader
result = D3DX11CompileFromFile(vsFilename,
NULL,
NULL,
"LightVertexShader",
"vs_5_0",
D3D10_SHADER_ENABLE_STRICTNESS,
0,
NULL,
&vertexShaderBuffer,
&errorMessage,
NULL);
if (FAILED(result))
{
if (errorMessage)
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
else
CLog::Write("CLightShader::InitializeShader() : could not compile the vertex shader");
return false;
}
// Compile the pixel shader
result = D3DX11CompileFromFile(psFilename,
NULL,
NULL,
"LightPixelShader",
"ps_5_0",
D3D10_SHADER_ENABLE_STRICTNESS,
0,
NULL,
&pixelShaderBuffer,
&errorMessage,
NULL);
if (FAILED(result))
{
if (errorMessage)
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
else
CLog::Write("CLightShader::InitializeShader() : could not compile the pixel shader");
return false;
}
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &vertexShader);
if (FAILED(result))
{
CLog::Write("CLightShader::InitializeShader() : could not create the vertex shader");
return false;
}
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &pixelShader);
if (FAILED(result))
{
CLog::Write("CLightShader::InitializeShader() : could not create the pixel shader");
return false;
}
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
polygonLayout[2].SemanticName = "NORMAL";
polygonLayout[2].SemanticIndex = 0;
polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[2].InputSlot = 0;
polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[2].InstanceDataStepRate = 0;
// Get the number of elements in the layout
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Create the vertex input layout
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &layout);
if (FAILED(result))
{
CLog::Write("CLightShader::InitializeShader() : could not create the input layout");
return false;
}
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// Create a texture sampler description
samplerDesc.Filter = Settings::TextureFilter;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
result = device->CreateSamplerState(&samplerDesc, &sampleState);
if (FAILED(result))
{
CLog::Write("CLightShader::InitializeShader() : could not create the sampler state");
return false;
}
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&matrixBufferDesc, NULL, &matrixBuffer);
if (FAILED(result))
{
CLog::Write("CLightShader::InitializeShader() : could not create the matrix buffer");
return false;
}
// Setup the camera buffer description
cameraBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
cameraBufferDesc.ByteWidth = sizeof(CameraBufferType);
cameraBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cameraBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cameraBufferDesc.MiscFlags = 0;
cameraBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&cameraBufferDesc, NULL, &cameraBuffer);
if (FAILED(result))
{
CLog::Write("CLightShader::InitializeShader() : could not create the matrix buffer");
return false;
}
// Setup the description of the light dynamic buffer in the pixel shader (what the f**k does that even mean)
// ByteWidth needs to be a multiple of 16. If not, CreateBuffer will fail
lightBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
lightBufferDesc.ByteWidth = sizeof(LightBufferType);
lightBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
lightBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
lightBufferDesc.MiscFlags = 0;
lightBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&lightBufferDesc, NULL, &lightBuffer);
if (FAILED(result))
{
CLog::Write("CLightShader::InitializeShader() : could not create the light buffer");
return false;
}
return true;
}
bool FogFX::InitialiseShader(ID3D11Device* device, HWND hwnd, WCHAR* sFilename)
{
bool result;
unsigned int numElements;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
D3D11_BUFFER_DESC constantBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
D3D11_BUFFER_DESC fogBufferDesc;
numElements = 0;
errorMessage = 0;
vertexShaderBuffer = nullptr;
pixelShaderBuffer = nullptr;
// Read Vertex Shader
result = D3DCompileFromFile(sFilename, NULL, NULL, "VS", "vs_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
if (FAILED(result))
{
if (errorMessage)
OutputShaderErrorMessage(errorMessage, hwnd, sFilename);
else
MessageBox(hwnd, sFilename, L"Missing VS", MB_OK);
return false;
}
//Create the vertex shader from the buffer
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &_pVertexShader);
if (FAILED(result))
return false;
// Read Pixel Shader
result = D3DCompileFromFile(sFilename, NULL, NULL, "PS", "ps_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
if (FAILED(result))
{
if (errorMessage)
OutputShaderErrorMessage(errorMessage, hwnd, sFilename);
else
MessageBox(hwnd, sFilename, L"Missing PS", MB_OK);
return false;
}
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &_pPixelShader);
if (FAILED(result))
return false;
// Create the Input Layour description
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = 0;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &_pInputLayout);
if (FAILED(result))
return false;
vertexShaderBuffer->Release();
pixelShaderBuffer->Release();
constantBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
constantBufferDesc.ByteWidth = sizeof(ConstantBuffer);
constantBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
constantBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
constantBufferDesc.MiscFlags = 0;
constantBufferDesc.StructureByteStride = 0;
if (FAILED(result))
return false;
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
result = device->CreateSamplerState(&samplerDesc, &_pSamplerState);
if (FAILED(result))
return false;
fogBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
fogBufferDesc.ByteWidth = sizeof(FogConstantBuffer);
fogBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
fogBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
fogBufferDesc.MiscFlags = 0;
fogBufferDesc.StructureByteStride = 0;
result = device->CreateBuffer(&fogBufferDesc, NULL, &_pFogBuffer);
if (FAILED(result))
return false;
return true;
}
bool TextureShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename){
HRESULT hr;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
D3D11_BUFFER_DESC transparentBufferDesc;
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
hr = D3DCompileFromFile(vsFilename, NULL, NULL, "TextureVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage);
if (FAILED(hr)){
if (errorMessage){
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
else{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
hr = D3DCompileFromFile(psFilename, NULL, NULL, "TexturePixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage);
if (FAILED(hr)){
if (errorMessage){
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
else{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
hr = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(hr)){
OutputErrorMessage(hwnd, hr, L"Could not create vertex shader with error: ");
return false;
}
hr = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(hr)){
OutputErrorMessage(hwnd, hr, L"Could not create pixel shader with error: ");
return false;
}
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
hr = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(hr)){
OutputErrorMessage(hwnd, hr, L"Could not create input layout with error: ");
return false;
}
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
ZeroMemory(&matrixBufferDesc, sizeof(matrixBufferDesc));
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
hr = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(hr)){
OutputErrorMessage(hwnd, hr, L"Could not create matrix buffer with error: ");
return false;
}
ZeroMemory(&transparentBufferDesc, sizeof(transparentBufferDesc));
transparentBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
transparentBufferDesc.ByteWidth = sizeof(PixelShaderBufferType);
transparentBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
transparentBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
transparentBufferDesc.MiscFlags = 0;
transparentBufferDesc.StructureByteStride = 0;
hr = device->CreateBuffer(&transparentBufferDesc, NULL, &m_pixelShaderCBuffer);
if (FAILED(hr)){
OutputErrorMessage(hwnd, hr, L"Could not create transparent buffer with error: ");
return false;
}
ZeroMemory(&samplerDesc, sizeof(samplerDesc));
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 1;
samplerDesc.BorderColor[2] = 2;
samplerDesc.BorderColor[3] = 3;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
hr = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(hr)){
OutputErrorMessage(hwnd, hr, L"Could not create sampler state with error: ");
return false;
}
return true;
}
bool AlphaMapShaderClass::InitializeShader(ID3D10Device* device, HWND hwnd, WCHAR* filename)
{
HRESULT result;
ID3D10Blob* errorMessage;
D3D10_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D10_PASS_DESC passDesc;
// Initialize the error message.
errorMessage = 0;
// Load the shader in from the file.
result = D3DX10CreateEffectFromFile(filename, NULL, NULL, "fx_4_0", D3D10_SHADER_ENABLE_STRICTNESS, 0,
device, NULL, NULL, &m_effect, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, filename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(hwnd, filename, L"Missing Shader File", MB_OK);
}
return false;
}
// Get a pointer to the technique inside the shader.
m_technique = m_effect->GetTechniqueByName("AlphaMapTechnique");
if(!m_technique)
{
return false;
}
// Now setup the layout of the data that goes into the shader.
// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D10_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Get the description of the first pass described in the shader technique.
m_technique->GetPassByIndex(0)->GetDesc(&passDesc);
// Create the input layout.
result = device->CreateInputLayout(polygonLayout, numElements, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize,
&m_layout);
if(FAILED(result))
{
return false;
}
// Get pointers to the three matrices inside the shader so we can update them from this class.
m_worldMatrixPtr = m_effect->GetVariableByName("worldMatrix")->AsMatrix();
m_viewMatrixPtr = m_effect->GetVariableByName("viewMatrix")->AsMatrix();
m_projectionMatrixPtr = m_effect->GetVariableByName("projectionMatrix")->AsMatrix();
// Get pointer to the texture array resource inside the shader.
m_textureArrayPtr = m_effect->GetVariableByName("shaderTextures")->AsShaderResource();
return true;
}
/* This function is what actually loads the shader file and makes it usable to DirectX and the GPU.
You will also see the setup of the layout and how the vertex buffer data is going to look
on the graphics pipeline in the GPU. The layout will need the match the Vertex struct in GameObject.h
as well as the one defined in the shader.fx file*/
bool Shader::InitializeShader(ID3D10Device* device, HWND hwnd, WCHAR* filename)
{
HRESULT result;
ID3D10Blob* errorMessage;
D3D10_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D10_PASS_DESC passDesc;
// Initialize the error message.
errorMessage = 0;
//Initialize shader flags
DWORD shaderFlags = D3D10_SHADER_ENABLE_STRICTNESS;
#if defined( DEBUG ) || defined( _DEBUG )
shaderFlags |= D3D10_SHADER_DEBUG;
shaderFlags |= D3D10_SHADER_SKIP_OPTIMIZATION;
#endif
/*Here is where we compile the shader program into an effect. We give it the name of the shader file,
the shader version (4.0 in DirectX 10), and the effect to compile the shader into.*/
// Load the shader in from the file.
result = D3DX10CreateEffectFromFile(filename, NULL, NULL, "fx_4_0", shaderFlags, 0,
device, NULL, NULL, &mEffect, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, filename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(hwnd, filename, L"Missing Shader File", MB_OK);
}
return false;
}
/*Once the shader code has successfully compiled into an effect we then use that effect to get
the technique inside the shader. We will use the technique to draw with the shader from this point forward.*/
// Get a pointer to the technique inside the shader.
mTechnique = mEffect->GetTechniqueByName("ColorTechnique");
if(!mTechnique)
{
return false;
}
// Now setup the layout of the data that goes into the shader.
// This setup needs to match the VertexType stucture in the GameObject class and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "COLOR";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D10_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D10_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
/*Once the layout description has been setup we can get the size of it and then create
the input layout using the D3D device.*/
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Get the description of the first pass described in the shader technique.
mTechnique->GetPassByIndex(0)->GetDesc(&passDesc);
// Create the input lay9out.
result = device->CreateInputLayout(polygonLayout, numElements, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize,
&mLayout);
if(FAILED(result)){
return false;
}
/*We will also grab pointers to the global matrices that are inside the shader file.
This way when we set a matrix from the main app inside the shader easily by just using these pointers.*/
// Get pointers to the three matrices inside the shader so we can update them from this class.
mWorldMatrix = mEffect->GetVariableByName("worldMatrix")->AsMatrix();
mViewMatrix = mEffect->GetVariableByName("viewMatrix")->AsMatrix();
mProjectionMatrix = mEffect->GetVariableByName("projectionMatrix")->AsMatrix();
mWVPMatrix = mEffect->GetVariableByName("wvpMatrix")->AsMatrix();
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////
// 1. Comple Shaders VS, GS for StreamOut Stage (m_vertexShader_Draw|m_geometryShader_Draw|m_PixelShader_Draw)
// 2. Create InputLayout for VS stage as struct Particle |vertex buffer bind type|(m_layout_Draw)
bool FireParticalSystemShader::InitializeShader_Draw(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename,
WCHAR* gsFilename ,WCHAR* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* geometryShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
////////////////////////////////////////////////////////////////////////////////////////////////////////
// 1. Comple Shaders VS, GS for StreamOut Stage (m_vertexShader_StreamOut|m_geometryShader_StreamOut)
////////////////////////////////////////////////////////////////////////////////////////////////////////
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
geometryShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DX11CompileFromFile(L"DrawFireParticleShader.hlsl", NULL, NULL, "DrawVS", "vs_5_0", D3D10_SHADER_DEBUG | D3D10_SHADER_SKIP_OPTIMIZATION, 0, NULL,
&vertexShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Compile the pixel shader code.
result = D3DX11CompileFromFile(L"DrawFireParticleShader.hlsl", NULL, NULL, "DrawGS", "gs_5_0", D3D10_SHADER_DEBUG | D3D10_SHADER_SKIP_OPTIMIZATION, 0, NULL,
&geometryShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Compile the pixel shader code.
result = D3DX11CompileFromFile(L"DrawFireParticleShader.hlsl", NULL, NULL, "DrawPS", "ps_5_0", D3D10_SHADER_DEBUG | D3D10_SHADER_SKIP_OPTIMIZATION, 0, NULL,
&pixelShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader_Draw);
if(FAILED(result))
{
return false;
}
// Create the pixel shader from the buffer.
result = device->CreateGeometryShader(geometryShaderBuffer->GetBufferPointer(), geometryShaderBuffer->GetBufferSize(), NULL, &m_geometryShader_Draw);
if(FAILED(result))
{
return false;
}
// Create the pixel shader from the buffer.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader_Draw);
if(FAILED(result))
{
return false;
}
////////////////////////////////////////////////////////////////////////////////////////////////
// 2. Create InputLayout for VS stage as struct Particle |vertex buffer bind type|(m_layout_Draw)
////////////////////////////////////////////////////////////////////////////////////////////////
result = createInputLayoutDesc_Draw(device, vertexShaderBuffer);
if(FAILED(result))
{
return false;
}
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
geometryShaderBuffer->Release();
geometryShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
result = createConstantBuffer_Draw(device);
if(FAILED(result))
{
return false;
}
return true;
}
//Initialise Shader Function
bool CParticleShader::InitialiseShader(ID3D11Device* device, HWND hwnd, LPCSTR vsFilename, LPCSTR psFilename, LPCSTR gsFilename)
{
//Implement multiple "Shader" classes.
//Define Variables
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
ID3D10Blob* geometryShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[5];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_BUFFER_DESC cameraBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
//Initialise Variables
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
//Complie Vertex Shader Code
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, this->m_VSName.c_str(), "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &vertexShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
//Submit Error on Compile Failure
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
//Submit Error Message on Unable to Find File
else
{
MessageBox(hwnd, vsFilename, "Missing Shader File", MB_OK);
}
return false;
}
//Compile Pixel Shader Code
result = D3DX11CompileFromFile(psFilename, NULL, NULL, this->m_PSName.c_str(), "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &pixelShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
//Submit Error on Compile Failure
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
//Submit Error Message on Unable to Find File
else
{
MessageBox(hwnd, psFilename, "Missing Shader File", MB_OK);
}
return false;
}
//Compile Geometry Shader Code
//result = D3DX11CompileFromFile(gsFilename, NULL, NULL, this->m_GSName.c_str(), "gs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL, &geometryShaderBuffer, &errorMessage, NULL);
if (FAILED(result))
{
//Submit Error on Compile Failure
if (errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, gsFilename);
}
//Submit Error Message on Unable to Find File
else
{
MessageBox(hwnd, gsFilename, "Missing Shader File", MB_OK);
}
return false;
}
//Create Vertex Shader from Buffer
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if (FAILED(result))
{
return false;
}
//Create Pixel Shader from Buffer
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if (FAILED(result))
{
return false;
}
//Create Geometry Shader
//result = device->CreateGeometryShader(geometryShaderBuffer->GetBufferPointer(), geometryShaderBuffer->GetBufferSize(), NULL, &m_geometryShader);
//Setup Layout Data going to Shader (Matching VertexType Structure in Model Class)
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
polygonLayout[2].SemanticName = "NORMAL";
polygonLayout[2].SemanticIndex = 0;
polygonLayout[2].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[2].InputSlot = 0;
polygonLayout[2].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[2].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[2].InstanceDataStepRate = 0;
polygonLayout[3].SemanticName = "TANGENT";
polygonLayout[3].SemanticIndex = 0;
polygonLayout[3].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[3].InputSlot = 0;
polygonLayout[3].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[3].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[3].InstanceDataStepRate = 0;
polygonLayout[4].SemanticName = "BITANGENT";
polygonLayout[4].SemanticIndex = 0;
polygonLayout[4].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[4].InputSlot = 0;
polygonLayout[4].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[4].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[4].InstanceDataStepRate = 0;
//Get Count of Elements
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
//Create Vertex Layout
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), &m_layout);
if (FAILED(result))
{
return false;
}
//Release Shader Buffers (No Longer Needed)
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
//Setup Description of Matrix Buffer (Vertex Shader)
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
//Create Constant Matrix Buffer
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if (FAILED(result))
{
return false;
}
//Setup Description of Camera Buffer (Vertex Shader)
cameraBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
cameraBufferDesc.ByteWidth = sizeof(CameraBufferType);
cameraBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
cameraBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
cameraBufferDesc.MiscFlags = 0;
cameraBufferDesc.StructureByteStride = 0;
//Create Constant Camera Buffer
result = device->CreateBuffer(&cameraBufferDesc, NULL, &m_cameraBuffer);
if (FAILED(result))
{
return false;
}
// Create a texture sampler state description.
samplerDesc.Filter = D3D11_FILTER_ANISOTROPIC;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// Create the texture sampler state.
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if (FAILED(result))
{
return false;
}
return true;
}
bool TransparentShaderClass::InitializeShader(ID3D11Device* device, HWND hwnd, WCHAR* vsFilename, WCHAR* psFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
D3D11_BUFFER_DESC matrixBufferDesc;
D3D11_SAMPLER_DESC samplerDesc;
D3D11_BUFFER_DESC transparentBufferDesc;
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "TransparentVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
0, NULL, &vertexShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Compile the pixel shader code.
result = D3DX11CompileFromFile(psFilename, NULL, NULL, "TransparentPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS,
0, NULL, &pixelShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL,
&m_vertexShader);
if(FAILED(result))
{
return false;
}
// Create the vertex shader from the buffer.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL,
&m_pixelShader);
if(FAILED(result))
{
return false;
}
// Create the vertex input layout description.
// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "TEXCOORD";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Create the vertex input layout.
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(), &m_layout);
if(FAILED(result))
{
return false;
}
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
vertexShaderBuffer->Release();
vertexShaderBuffer = 0;
pixelShaderBuffer->Release();
pixelShaderBuffer = 0;
// Setup the description of the dynamic constant buffer that is in the vertex shader.
matrixBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
matrixBufferDesc.ByteWidth = sizeof(MatrixBufferType);
matrixBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
matrixBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
matrixBufferDesc.MiscFlags = 0;
matrixBufferDesc.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
result = device->CreateBuffer(&matrixBufferDesc, NULL, &m_matrixBuffer);
if(FAILED(result))
{
return false;
}
// Create a texture sampler state description.
samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_LINEAR;
samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_WRAP;
samplerDesc.MipLODBias = 0.0f;
samplerDesc.MaxAnisotropy = 1;
samplerDesc.ComparisonFunc = D3D11_COMPARISON_ALWAYS;
samplerDesc.BorderColor[0] = 0;
samplerDesc.BorderColor[1] = 0;
samplerDesc.BorderColor[2] = 0;
samplerDesc.BorderColor[3] = 0;
samplerDesc.MinLOD = 0;
samplerDesc.MaxLOD = D3D11_FLOAT32_MAX;
// Create the texture sampler state.
result = device->CreateSamplerState(&samplerDesc, &m_sampleState);
if(FAILED(result))
{
return false;
}
// Setup the description of the transparent dynamic constant buffer that is in the pixel shader.
transparentBufferDesc.Usage = D3D11_USAGE_DYNAMIC;
transparentBufferDesc.ByteWidth = sizeof(TransparentBufferType);
transparentBufferDesc.BindFlags = D3D11_BIND_CONSTANT_BUFFER;
transparentBufferDesc.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE;
transparentBufferDesc.MiscFlags = 0;
transparentBufferDesc.StructureByteStride = 0;
// Create the constant buffer pointer so we can access the pixel shader constant buffer from within this class.
result = device->CreateBuffer(&transparentBufferDesc, NULL, &m_transparentBuffer);
if(FAILED(result))
{
return false;
}
return true;
}
////////////////////////////////////////
// PRIVATE UTILITY FUNCTIONS
////////////////////////////////////////
bool ParticleShader::InitializeShader(ID3D11Device* device, HWND hwnd, const WCHAR* vsFilename, const WCHAR* psFilename, const WCHAR* gsFilename)
{
HRESULT result;
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
ID3D10Blob* geometryShaderBuffer;
D3D11_INPUT_ELEMENT_DESC polygonLayout[2];
unsigned int numElements;
// Initialize the pointers this function will use to null.
errorMessage = 0;
vertexShaderBuffer = 0;
pixelShaderBuffer = 0;
// Compile the vertex shader code.
result = D3DX11CompileFromFile(vsFilename, NULL, NULL, "ColorVertexShader", "vs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&vertexShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, vsFilename);
}
// If there was nothing in the error message then it simply could not find the shader file itself.
else
{
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Compile the pixel shader code.
result = D3DX11CompileFromFile(psFilename, NULL, NULL, "ColorPixelShader", "ps_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&pixelShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, psFilename);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Create the vertex shader from the buffer.
result = device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(), vertexShaderBuffer->GetBufferSize(), NULL, &m_vertexShader);
if(FAILED(result))
{
return false;
}
// Create the pixel shader from the buffer.
result = device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(), pixelShaderBuffer->GetBufferSize(), NULL, &m_pixelShader);
if(FAILED(result))
{
return false;
}
if(gsFilename)
{
// Compile the geometry shader code.
result = D3DX11CompileFromFile(gsFilename, NULL, NULL, "GS_Billboard", "gs_5_0", D3D10_SHADER_ENABLE_STRICTNESS, 0, NULL,
&geometryShaderBuffer, &errorMessage, NULL);
if(FAILED(result))
{
// If the shader failed to compile it should have writen something to the error message.
if(errorMessage)
{
OutputShaderErrorMessage(errorMessage, hwnd, gsFilename);
}
// If there was nothing in the error message then it simply could not find the file itself.
else
{
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Create geometry shader from the buffer.
result = device->CreateGeometryShader(geometryShaderBuffer->GetBufferPointer(), geometryShaderBuffer->GetBufferSize(), NULL, &m_geometryShader);
if(FAILED(result))
{
return false;
}
}
// Now setup the layout of the data that goes into the shader.
// This setup needs to match the VertexType stucture in the ModelClass and in the shader.
polygonLayout[0].SemanticName = "POSITION";
polygonLayout[0].SemanticIndex = 0;
polygonLayout[0].Format = DXGI_FORMAT_R32G32B32_FLOAT;
polygonLayout[0].InputSlot = 0;
polygonLayout[0].AlignedByteOffset = 0;
polygonLayout[0].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[0].InstanceDataStepRate = 0;
polygonLayout[1].SemanticName = "COLOR";
polygonLayout[1].SemanticIndex = 0;
polygonLayout[1].Format = DXGI_FORMAT_R32G32B32A32_FLOAT;
polygonLayout[1].InputSlot = 0;
polygonLayout[1].AlignedByteOffset = D3D11_APPEND_ALIGNED_ELEMENT;
polygonLayout[1].InputSlotClass = D3D11_INPUT_PER_VERTEX_DATA;
polygonLayout[1].InstanceDataStepRate = 0;
// Get a count of the elements in the layout.
numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
// Create the vertex input layout.
result = device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(), &m_layout);
if(FAILED(result))
{
return false;
}
// Release the vertex shader buffer and pixel shader buffer since they are no longer needed.
/*vertexShaderBuffer->Release();
vertexShaderBuffer = 0;*/
SAFE_RELEASE(vertexShaderBuffer);
SAFE_RELEASE(pixelShaderBuffer);
SAFE_RELEASE(geometryShaderBuffer);
return true;
}
