spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

HLSL-Quelltext

///////////// 
// DEFINES // 
///////////// 
#define NUM_MAX_LIGHTS 20 


///////////// 
// GLOBALS // 
///////////// 
cbuffer MatrixBuffer 
{ 
matrix worldMatrix; 
matrix viewMatrix; 
matrix projectionMatrix; 
}; 
Texture2D shaderTexture; 
SamplerState SampleType; 

cbuffer LightPositionBuffer 
{ 
float4 lightPosition[NUM_MAX_LIGHTS]; 
float4 numLights; 
}; 
cbuffer LightColorBuffer 
{ 
float4 diffuseColor[NUM_MAX_LIGHTS]; 
}; 

////////////// 
// TYPEDEFS // 
////////////// 
struct VertexInputType 
{ 
float4 position : POSITION; 
float2 tex : TEXCOORD0; 
float3 normal : NORMAL; 
}; 

struct PixelInputType 
{ 
float4 position : SV_POSITION; 
float2 tex : TEXCOORD0; 
float3 normal : NORMAL; 
float3 lightPos[NUM_MAX_LIGHTS] : TEXCOORD1; 
}; 

//////////////////////////////////////////////////////////////////////////////// 
// Vertex Shader 
//////////////////////////////////////////////////////////////////////////////// 
PixelInputType LightVertexShader(VertexInputType input) 
{ 
PixelInputType output; 
float4 worldPosition; 

input.position.w = 1.0f; 

output.position = mul(input.position, worldMatrix); 
output.position = mul(output.position, viewMatrix); 
output.position = mul(output.position, projectionMatrix); 
output.tex = input.tex; 

output.normal = mul(input.normal, (float3x3)worldMatrix); 

output.normal = normalize(output.normal); 

worldPosition = mul(input.position, worldMatrix); 

uint nl = asuint( numLights.x ); 
for(int i=0;i< 
nl 
;i++) 
{ 

output.lightPos[i].xyz = lightPosition[i].xyz - worldPosition.xyz; 

output.lightPos[i] = normalize(output.lightPos[i]); 
} 

return output; 
} 



//////////////////////////////////////////////////////////////////////////////// 
// Pixel Shader 
//////////////////////////////////////////////////////////////////////////////// 
float4 LightPixelShader(PixelInputType input) : SV_TARGET 
{ 
float4 textureColor; 
float lightIntensity[NUM_MAX_LIGHTS]; 
float4 color[NUM_MAX_LIGHTS]; 
float4 colorSum = (float4)0; 

uint nl = asuint( numLights.x ); 

for(int i=0;i { 
lightIntensity[i] = saturate(dot(input.normal, input.lightPos[i])); 

// Determine the diffuse color amount of each of the four lights. 
color[i] = diffuseColor[i] * lightIntensity[i]; 
} 

// Sample the texture pixel at this location. 
textureColor = shaderTexture.Sample(SampleType, input.tex); 

// Multiply the texture pixel by the combination of all four light colors to get the final result. 
for(int i=0;i< 
nl 
;i++) 
{ 
colorSum += color[i]; 
} 
colorSum = saturate(colorSum) * textureColor; 
return colorSum; 
}

C-/C++-Quelltext

bool cLightshader::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture) 
{ 
HRESULT result; 
D3D11_MAPPED_SUBRESOURCE mappedResource; 
MatrixBufferType* dataPtr; 
LightPositionBufferType* dataPtr2; 
LightColorBufferType* dataPtr3; 
unsigned int bufferNumber; 


// Transpose the matrices to prepare them for the shader. 
D3DXMatrixTranspose(&worldMatrix, &worldMatrix); 
D3DXMatrixTranspose(&viewMatrix, &viewMatrix); 
D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); 

// Lock the matrix constant buffer so it can be written to. 
result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); 
if(FAILED(result)) 
{ 
return false; 
} 

// Get a pointer to the data in the constant buffer. 
dataPtr = (MatrixBufferType*)mappedResource.pData; 

// Copy the matrices into the constant buffer. 
dataPtr->world = worldMatrix; 
dataPtr->view = viewMatrix; 
dataPtr->projection = projectionMatrix; 

// Unlock the matrix constant buffer. 
deviceContext->Unmap(m_matrixBuffer, 0); 

// Set the position of the matrix constant buffer in the vertex shader. 
bufferNumber = 0; 

// Now set the matrix constant buffer in the vertex shader with the updated values. 
deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); 

// Lock the light position constant buffer so it can be written to. 
result = deviceContext->Map(m_lightPositionBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); 
if(FAILED(result)) 
{ 
return false; 
} 

// Get a pointer to the data in the constant buffer. 
dataPtr2 = (LightPositionBufferType*)mappedResource.pData; 

// Copy the light position variables into the constant buffer. 
for(int i=0; i { 
dataPtr2->lightPosition = m_lights->GetPosition(); 
} 
dataPtr2->numLights = D3DXVECTOR4(m_lights.size(),m_lights.size(),m_lights.size(),m_lights.size()); 

// Unlock the constant buffer. 
deviceContext->Unmap(m_lightPositionBuffer, 0); 

// Finally set the constant buffer in the vertex shader with the updated values. 
deviceContext->VSSetConstantBuffers(1, 1, &m_lightPositionBuffer); 

// Set shader texture resource in the pixel shader. 
deviceContext->PSSetShaderResources(0, 1, &texture); 

// Lock the light color constant buffer so it can be written to. 
result = deviceContext->Map(m_lightColorBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); 
if(FAILED(result)) 
{ 
return false; 
} 

// Get a pointer to the data in the constant buffer. 
dataPtr3 = (LightColorBufferType*)mappedResource.pData; 

// Copy the light color variables into the constant buffer. 
for(int i=0;i { 
dataPtr3->diffuseColor = m_lights->GetColor(); 
} 

// Unlock the constant buffer. 
deviceContext->Unmap(m_lightColorBuffer, 0); 

// Set the position of the constant buffer in the pixel shader. 
bufferNumber = 0; 

// Finally set the constant buffer in the pixel shader with the updated values. 
deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightColorBuffer); 

return true; 

}