ID3DBlob* D3DApp::GenerateShader(const std::string& filename, const std::string& function,
const std::string& model, const D3D_SHADER_MACRO* pDefines)
{
HRESULT hr = S_OK;
ID3DBlob* pCompiledShader = nullptr;
ID3DBlob* pErrorMessages = nullptr;
UINT flags = D3DCOMPILE_PACK_MATRIX_ROW_MAJOR;
#ifdef _DEBUG
flags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION; // | D3DCOMPILE_WARNINGS_ARE_ERRORS;
#endif
std::ifstream shaderFile(filename);
std::string hlslCode((std::istreambuf_iterator<char>(shaderFile)),
std::istreambuf_iterator<char>());
HR(D3DCompile(
hlslCode.c_str(),
hlslCode.size(),
nullptr,
pDefines,
nullptr,
function.c_str(),
model.c_str(),
flags,
0,
&pCompiledShader,
&pErrorMessages));
ReleaseCOM(pErrorMessages);
return(pCompiledShader);
}
/*
================================================================================================
idRenderProgManager::LoadGLSLShader
================================================================================================
*/
GLuint idRenderProgManager::LoadGLSLShader( GLenum target, const char * name, idList<int> & uniforms ) {
idStr inFile;
idStr outFileHLSL;
idStr outFileGLSL;
idStr outFileUniforms;
inFile.Format( "renderprogs\\%s", name );
inFile.StripFileExtension();
outFileHLSL.Format( "renderprogs\\glsl\\%s", name );
outFileHLSL.StripFileExtension();
outFileGLSL.Format( "renderprogs\\glsl\\%s", name );
outFileGLSL.StripFileExtension();
outFileUniforms.Format( "renderprogs\\glsl\\%s", name );
outFileUniforms.StripFileExtension();
if ( target == GL_FRAGMENT_SHADER ) {
inFile += ".pixel";
outFileHLSL += "_fragment.hlsl";
outFileGLSL += "_fragment.glsl";
outFileUniforms += "_fragment.uniforms";
} else {
inFile += ".vertex";
outFileHLSL += "_vertex.hlsl";
outFileGLSL += "_vertex.glsl";
outFileUniforms += "_vertex.uniforms";
}
// first check whether we already have a valid GLSL file and compare it to the hlsl timestamp;
ID_TIME_T hlslTimeStamp;
int hlslFileLength = fileSystem->ReadFile( inFile.c_str(), NULL, &hlslTimeStamp );
ID_TIME_T glslTimeStamp;
int glslFileLength = fileSystem->ReadFile( outFileGLSL.c_str(), NULL, &glslTimeStamp );
// if the glsl file doesn't exist or we have a newer HLSL file we need to recreate the glsl file.
idStr programGLSL;
idStr programUniforms;
if ( ( glslFileLength <= 0 ) || ( hlslTimeStamp > glslTimeStamp ) ) {
if ( hlslFileLength <= 0 ) {
// hlsl file doesn't even exist bail out
return false;
}
void * hlslFileBuffer = NULL;
int len = fileSystem->ReadFile( inFile.c_str(), &hlslFileBuffer );
if ( len <= 0 ) {
return false;
}
idStr hlslCode( ( const char* ) hlslFileBuffer );
idStr programHLSL = StripDeadCode( hlslCode, inFile );
programGLSL = ConvertCG2GLSL( programHLSL, inFile, target == GL_VERTEX_SHADER, programUniforms );
fileSystem->WriteFile( outFileHLSL, programHLSL.c_str(), programHLSL.Length(), "fs_basepath" );
fileSystem->WriteFile( outFileGLSL, programGLSL.c_str(), programGLSL.Length(), "fs_basepath" );
if ( r_useUniformArrays.GetBool() ) {
fileSystem->WriteFile( outFileUniforms, programUniforms.c_str(), programUniforms.Length(), "fs_basepath" );
}
} else {
// read in the glsl file
void * fileBufferGLSL = NULL;
int lengthGLSL = fileSystem->ReadFile( outFileGLSL.c_str(), &fileBufferGLSL );
if ( lengthGLSL <= 0 ) {
idLib::Error( "GLSL file %s could not be loaded and may be corrupt", outFileGLSL.c_str() );
}
programGLSL = ( const char * ) fileBufferGLSL;
Mem_Free( fileBufferGLSL );
if ( r_useUniformArrays.GetBool() ) {
// read in the uniform file
void * fileBufferUniforms = NULL;
int lengthUniforms = fileSystem->ReadFile( outFileUniforms.c_str(), &fileBufferUniforms );
if ( lengthUniforms <= 0 ) {
idLib::Error( "uniform file %s could not be loaded and may be corrupt", outFileUniforms.c_str() );
}
programUniforms = ( const char* ) fileBufferUniforms;
Mem_Free( fileBufferUniforms );
}
}
// find the uniforms locations in either the vertex or fragment uniform array
if ( r_useUniformArrays.GetBool() ) {
uniforms.Clear();
idLexer src( programUniforms, programUniforms.Length(), "uniforms" );
idToken token;
while ( src.ReadToken( &token ) ) {
int index = -1;
for ( int i = 0; i < RENDERPARM_TOTAL && index == -1; i++ ) {
const char * parmName = GetGLSLParmName( i );
if ( token == parmName ) {
index = i;
}
}
for ( int i = 0; i < MAX_GLSL_USER_PARMS && index == -1; i++ ) {
const char * parmName = GetGLSLParmName( RENDERPARM_USER + i );
if ( token == parmName ) {
index = RENDERPARM_USER + i;
}
}
if ( index == -1 ) {
idLib::Error( "couldn't find uniform %s for %s", token.c_str(), outFileGLSL.c_str() );
}
uniforms.Append( index );
}
}
// create and compile the shader
const GLuint shader = qglCreateShader( target );
if ( shader ) {
const char * source[1] = { programGLSL.c_str() };
qglShaderSource( shader, 1, source, NULL );
qglCompileShader( shader );
int infologLength = 0;
qglGetShaderiv( shader, GL_INFO_LOG_LENGTH, &infologLength );
if ( infologLength > 1 ) {
idTempArray<char> infoLog( infologLength );
int charsWritten = 0;
qglGetShaderInfoLog( shader, infologLength, &charsWritten, infoLog.Ptr() );
// catch the strings the ATI and Intel drivers output on success
if ( strstr( infoLog.Ptr(), "successfully compiled to run on hardware" ) != NULL ||
strstr( infoLog.Ptr(), "No errors." ) != NULL ) {
//idLib::Printf( "%s program %s from %s compiled to run on hardware\n", typeName, GetName(), GetFileName() );
} else if ( r_displayGLSLCompilerMessages.GetBool() ) {
idLib::Printf( "While compiling %s program %s\n", ( target == GL_FRAGMENT_SHADER ) ? "fragment" : "vertex" , inFile.c_str() );
const char separator = '\n';
idList<idStr> lines;
lines.Clear();
idStr source( programGLSL );
lines.Append( source );
for ( int index = 0, ofs = lines[index].Find( separator ); ofs != -1; index++, ofs = lines[index].Find( separator ) ) {
lines.Append( lines[index].c_str() + ofs + 1 );
lines[index].CapLength( ofs );
}
idLib::Printf( "-----------------\n" );
for ( int i = 0; i < lines.Num(); i++ ) {
idLib::Printf( "%3d: %s\n", i+1, lines[i].c_str() );
}
idLib::Printf( "-----------------\n" );
idLib::Printf( "%s\n", infoLog.Ptr() );
}
}
GLint compiled = GL_FALSE;
qglGetShaderiv( shader, GL_COMPILE_STATUS, &compiled );
if ( compiled == GL_FALSE ) {
qglDeleteShader( shader );
return INVALID_PROGID;
}
}
return shader;
}