void GFXGLTextureObject::bind(U32 textureUnit)
{
glActiveTexture(GL_TEXTURE0 + textureUnit);
glBindTexture(mBinding, mHandle);
GFXGL->getOpenglCache()->setCacheBindedTex(textureUnit, mBinding, mHandle);
if( gglHasExtension(ARB_sampler_objects) )
return;
GFXGLStateBlockRef sb = mGLDevice->getCurrentStateBlock();
AssertFatal(sb, "GFXGLTextureObject::bind - No active stateblock!");
if (!sb)
return;
const GFXSamplerStateDesc ssd = sb->getDesc().samplers[textureUnit];
if(mNeedInitSamplerState)
{
initSamplerState(ssd);
return;
}
if(mSampler.minFilter != ssd.minFilter || mSampler.mipFilter != ssd.mipFilter)
glTexParameteri(mBinding, GL_TEXTURE_MIN_FILTER, minificationFilter(ssd.minFilter, ssd.mipFilter, mMipLevels));
if(mSampler.magFilter != ssd.magFilter)
glTexParameteri(mBinding, GL_TEXTURE_MAG_FILTER, GFXGLTextureFilter[ssd.magFilter]);
if(mSampler.addressModeU != ssd.addressModeU)
glTexParameteri(mBinding, GL_TEXTURE_WRAP_S, !mIsNPoT2 ? GFXGLTextureAddress[ssd.addressModeU] : GL_CLAMP_TO_EDGE);
if(mSampler.addressModeV != ssd.addressModeV)
glTexParameteri(mBinding, GL_TEXTURE_WRAP_T, !mIsNPoT2 ? GFXGLTextureAddress[ssd.addressModeV] : GL_CLAMP_TO_EDGE);
if(mBinding == GL_TEXTURE_3D && mSampler.addressModeW != ssd.addressModeW )
glTexParameteri(mBinding, GL_TEXTURE_WRAP_R, GFXGLTextureAddress[ssd.addressModeW]);
if(mSampler.maxAnisotropy != ssd.maxAnisotropy && static_cast< GFXGLDevice* >( GFX )->supportsAnisotropic() )
glTexParameterf(mBinding, GL_TEXTURE_MAX_ANISOTROPY_EXT, ssd.maxAnisotropy);
mSampler = ssd;
}
bool LightShader::initializeShader(ID3D11Device * device, HWND hwnd, const WCHAR * vsFilename, const WCHAR * psFilename) {
ID3D10Blob* errorBlob;
ID3D10Blob* vertexShaderBlob;
ID3D10Blob* pixelShaderBlob;
UINT flags = D3DCOMPILE_ENABLE_STRICTNESS;
#if _DEBUG
flags |= D3DCOMPILE_DEBUG;
#endif
// Compile the vertex shader code.
if (FAILED(D3DCompileFromFile(vsFilename, NULL, D3D_COMPILE_STANDARD_FILE_INCLUDE,
"DiffuseLightVertexShader", Globals::VERTEX_SHADER_VERSION,
flags, 0, &vertexShaderBlob, &errorBlob))) {
if (errorBlob) {
outputShaderErrorMessage(errorBlob, hwnd, vsFilename);
} else {
MessageBox(hwnd, vsFilename, L"Missing Vertex Shader File", MB_OK);
}
return false;
}
if (FAILED(D3DCompileFromFile(psFilename, NULL, D3D_COMPILE_STANDARD_FILE_INCLUDE,
"DiffuseLightPixelShader", Globals::PIXEL_SHADER_VERSION,
flags, 0, &pixelShaderBlob, &errorBlob))) {
if (errorBlob) {
outputShaderErrorMessage(errorBlob, hwnd, psFilename);
} else {
MessageBox(hwnd, psFilename, L"Missing Pixel Shader File", MB_OK);
}
return false;
}
// Create the vertex shader from the buffer.
if (FAILED(device->CreateVertexShader(vertexShaderBlob->GetBufferPointer(),
vertexShaderBlob->GetBufferSize(), NULL, &vertexShader))) {
MessageBox(NULL, L"Error creating Vertex Shader", L"ERROR", MB_OK);
return false;
}
// Create the pixel shader from the buffer.
if (FAILED(device->CreatePixelShader(pixelShaderBlob->GetBufferPointer(),
pixelShaderBlob->GetBufferSize(), NULL, &pixelShader))) {
MessageBox(NULL, L"Error creating Pixel Shader", L"ERROR", MB_OK);
return false;
}
if (FAILED(initInputLayout(device, vertexShaderBlob))) {
MessageBox(NULL, L"Error creating Input Layout Buffer", L"ERROR", MB_OK);
return false;
}
safeRelease(vertexShaderBlob);
safeRelease(pixelShaderBlob);
if (FAILED(initMatrixBuffer(device))) {
MessageBox(NULL, L"Error creating Constant (Matrix) Buffer", L"ERROR", MB_OK);
return false;
}
if (FAILED(initSamplerState(device))) {
MessageBox(NULL, L"Error creating Sampler Shader", L"ERROR", MB_OK);
return false;
}
if (FAILED(initLightBuffer(device))) {
return false;
}
return true;
}
bool TextureShader::initializeShader(ID3D11Device * device, HWND hwnd, const WCHAR * vsFilename, const WCHAR * psFilename) {
ID3D10Blob* errorMessage;
ID3D10Blob* vertexShaderBuffer;
ID3D10Blob* pixelShaderBuffer;
// Compile the vertex shader code.
if (FAILED(D3DCompileFromFile(vsFilename, NULL, NULL, "TextureVertexShader", Globals::VERTEX_SHADER_VERSION,
D3D10_SHADER_ENABLE_STRICTNESS, 0, &vertexShaderBuffer, &errorMessage))) {
if (errorMessage) {
outputShaderErrorMessage(errorMessage, hwnd, vsFilename);
} else {
MessageBox(hwnd, vsFilename, L"Missing Shader File", MB_OK);
}
return false;
}
if (FAILED(D3DCompileFromFile(psFilename, NULL, NULL, "TexturePixelShader", Globals::PIXEL_SHADER_VERSION,
D3D10_SHADER_ENABLE_STRICTNESS, 0, &pixelShaderBuffer, &errorMessage))) {
if (errorMessage) {
outputShaderErrorMessage(errorMessage, hwnd, psFilename);
} else {
MessageBox(hwnd, psFilename, L"Missing Shader File", MB_OK);
}
return false;
}
// Create the vertex shader from the buffer.
if (FAILED(device->CreateVertexShader(vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(), NULL, &vertexShader))) {
return false;
}
// Create the pixel shader from the buffer.
if (FAILED(device->CreatePixelShader(pixelShaderBuffer->GetBufferPointer(),
pixelShaderBuffer->GetBufferSize(), NULL, &pixelShader))) {
return false;
}
// needs to match the VertexTexture stucture in the Model and in the shader.
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;
unsigned int numElements = sizeof(polygonLayout) / sizeof(polygonLayout[0]);
if (FAILED(device->CreateInputLayout(polygonLayout, numElements, vertexShaderBuffer->GetBufferPointer(),
vertexShaderBuffer->GetBufferSize(), &layout))) {
return false;
}
vertexShaderBuffer->Release();
pixelShaderBuffer->Release();
// Create the constant buffer pointer so we can access the vertex shader constant buffer from within this class.
if (FAILED(initMatrixBuffer(device))) {
MessageBox(NULL, L"Error creating Constant (Matrix) Buffer", L"ERROR", MB_OK);
return false;
}
if (FAILED(initSamplerState(device))) {
MessageBox(NULL, L"Error creating Sampler Shader", L"ERROR", MB_OK);
return false;
}
return true;
}