ShaderProgram::ShaderProgram(const char *vertexShaderFile, const char *fragmentShaderFile) {
// create the vertex shader
vertexShader = LoadShaderFromFile(vertexShaderFile, GL_VERTEX_SHADER);
// create the fragment shader
fragmentShader = LoadShaderFromFile(fragmentShaderFile, GL_FRAGMENT_SHADER);
// Create the final shader program from our vertex and fragment shaders
programID = glCreateProgram();
glAttachShader(programID, vertexShader);
glAttachShader(programID, fragmentShader);
glLinkProgram(programID);
GLint linkSuccess;
glGetProgramiv(programID, GL_LINK_STATUS, &linkSuccess);
if(linkSuccess == GL_FALSE) {
printf("Error linking shader program!\n");
}
modelviewMatrixUniform = glGetUniformLocation(programID, "modelviewMatrix");
projectionMatrixUniform = glGetUniformLocation(programID, "projectionMatrix");
positionAttribute = glGetAttribLocation(programID, "position");
texCoordAttribute = glGetAttribLocation(programID, "texCoord");
}
bool ShaderSet::LoadFromFile(const Resources::Shaders::ShadersInfo & shadersInfo, ID3D11Device * dev)
{
assert(dev);
bool shaderLoadResult = true;
if (shadersInfo.vertexShaderInfo)
{
ID3DBlob * shaderCode = LoadShaderFromFile(*shadersInfo.vertexShaderInfo, dev);
if (!shaderCode)
{
return false;
}
VSBlob = shaderCode;
HRESULT res = dev->CreateVertexShader(shaderCode->GetBufferPointer(), shaderCode->GetBufferSize(), NULL, &vertexShader);
if (FAILED(res))
{
WinUtils::PrintErrorMessage(res, "Error creating VS : ", "Error");
VSBlob->Release();
return false;
}
}
if (shadersInfo.pixelShaderInfo)
{
ID3DBlob * shaderCode = LoadShaderFromFile(*shadersInfo.pixelShaderInfo, dev);
if (!shaderCode)
{
vertexShader->Release();
return false;
}
PSBlob = shaderCode;
HRESULT res = dev->CreatePixelShader(shaderCode->GetBufferPointer(), shaderCode->GetBufferSize(), NULL, &pixelShader);
if (FAILED(res))
{
WinUtils::PrintErrorMessage(res, "Error creating PS : ", "Error");
//clean up previously loaded shaders
VSBlob->Release();
vertexShader->Release();
shaderCode->Release();
return false;
}
}
return true;
}
bool Shader::InitializeFromFile(const char* vertFilename, const char* fragFilename)
{
//std::cout << "Compiling shaders: " << vertFilename << " | " << fragFilename << std::endl;
m_vertex = LoadShaderFromFile(vertFilename, GL_VERTEX_SHADER);
m_fragment = LoadShaderFromFile(fragFilename, GL_FRAGMENT_SHADER);
if(m_vertex == -1 || m_fragment == -1)
return false;
return CreateShader();
}
static __forceinline bool LOAD_PS(char* DefineString, const char* name, FRAGMENTSHADER& fragment, int shaderver, ZZshProfile context, const char* depth)
{
bool flag;
char temp[200];
GlslHeaderString(temp, name, depth);
sprintf(DefineString, "%s#define FRAGMENT_SHADER 1\n#define CTX %d\n", temp, context * NOCONTEXT);
//ZZLog::WriteLn("Define for PS == '%s'", DefineString);
flag = LoadShaderFromFile(fragment.Shader, DefineString, name, GL_FRAGMENT_SHADER);
SetupFragmentProgramParameters(&fragment, context, 0);
return flag;
}
static __forceinline bool LOAD_VS(char* DefineString, const char* name, VERTEXSHADER& vertex, int shaderver, ZZshProfile context, const char* depth)
{
bool flag;
char temp[200];
GlslHeaderString(temp, name, depth);
sprintf(DefineString, "%s#define VERTEX_SHADER 1\n#define CTX %d\n", temp, context * NOCONTEXT);
//ZZLog::WriteLn("Define for VS == '%s'", DefineString);
flag = LoadShaderFromFile(vertex.Shader, DefineString, name, GL_VERTEX_SHADER);
SetupVertexProgramParameters(&vertex, context);
return flag;
}
AsShader::AsShader(std::string* pShaderPaths, GLuint pNumFiles, GLenum pType)
{
mShaderType = pType;
LoadShaderFromFile(pShaderPaths, pNumFiles, pType);
}
int main( int argc, char** argv)
#endif
{
char* HLSLShaderSource = 0;
char* GLSLShaderSource = 0;
char* ErrorLog = 0;
SCmdOptions Options;
{
int Result = ParseCommandLine( argc-1, argv+1, Options);
if (Result != 0)
{
return Result;
}
}
HLSLShaderSource = LoadShaderFromFile(Options.ShaderFilename);
if (!HLSLShaderSource)
{
dprintf( "Failed to open input shader %s\n", Options.ShaderFilename);
return -2;
}
int Flags = HLSLCC_PackUniforms; // | HLSLCC_NoValidation | HLSLCC_PackUniforms;
Flags |= Options.bNoPreprocess ? HLSLCC_NoPreprocess : 0;
Flags |= Options.bDumpAST ? HLSLCC_PrintAST : 0;
Flags |= Options.bFlattenUB ? HLSLCC_FlattenUniformBuffers : 0;
Flags |= Options.bFlattenUBStructures ? HLSLCC_FlattenUniformBufferStructures : 0;
Flags |= Options.bGroupFlattenedUB ? HLSLCC_GroupFlattenedUniformBuffers : 0;
Flags |= Options.bCSE ? HLSLCC_ApplyCommonSubexpressionElimination : 0;
Flags |= Options.bExpandExpressions ? HLSLCC_ExpandSubexpressions : 0;
Flags |= Options.bSeparateShaderObjects ? HLSLCC_SeparateShaderObjects : 0;
FGlslCodeBackend GlslCodeBackend(Flags, Options.Target);
FGlslLanguageSpec GlslLanguageSpec;//(Options.Target == HCT_FeatureLevelES2);
FCodeBackend* CodeBackend = &GlslCodeBackend;
ILanguageSpec* LanguageSpec = &GlslLanguageSpec;
switch (Options.Backend)
{
case HB_Glsl:
default:
CodeBackend = &GlslCodeBackend;
LanguageSpec = &GlslLanguageSpec;
Flags |= HLSLCC_DX11ClipSpace;
break;
}
int Result = 0;
{
//FCRTMemLeakScope::BreakOnBlock(33758);
FCRTMemLeakScope MemLeakScopeContext;
FHlslCrossCompilerContext Context(Flags, Options.Frequency, Options.Target);
if (Context.Init(Options.ShaderFilename, LanguageSpec))
{
FCRTMemLeakScope MemLeakScopeRun;
Result = Context.Run(
HLSLShaderSource,
Options.Entry,
CodeBackend,
&GLSLShaderSource,
&ErrorLog) ? 1 : 0;
}
if (GLSLShaderSource)
{
dprintf("GLSL Shader Source --------------------------------------------------------------\n");
dprintf("%s",GLSLShaderSource);
dprintf("\n-------------------------------------------------------------------------------\n\n");
}
if (ErrorLog)
{
dprintf("Error Log ----------------------------------------------------------------------\n");
dprintf("%s",ErrorLog);
dprintf("\n-------------------------------------------------------------------------------\n\n");
}
if (Options.OutFile && GLSLShaderSource)
{
FILE *fp = fopen( Options.OutFile, "w");
if (fp)
{
fprintf( fp, "%s", GLSLShaderSource);
fclose(fp);
}
}
free(HLSLShaderSource);
free(GLSLShaderSource);
free(ErrorLog);
if (DebugBuffer)
{
free(DebugBuffer);
DebugBuffer = nullptr;
}
}
return 0;
}
int Init ( void )
{
GLuint vertexShader;
GLuint fragmentShader;
GLuint programObject;
GLint linked;
// Load Textures
glGenTextures(TEXTURE_COUNT, GtextureID);
loadTexture("../media/rocks.bmp", GtextureID[0]);
loadTexture("../media/rainbow-blocks.bmp", GtextureID[1]);
loadTexture("../media/rgb.bmp", GtextureID[2]);
loadTexture("../media/barack-obama.bmp", GtextureID[3]);
loadTexture("../media/rainbow-stripes.bmp", GtextureID[4]);
loadTexture("../media/gtx-promo.bmp", GtextureID[5]);
loadTexture("../media/Mettle_Skybox_Cubic_Cross.bmp", GtextureID[6]);
loadTexture("../media/sky.bmp", GtextureID[7]);
// Initialize FMOD
//initFmod();
// Create a new FBO (Frame Bufffer Object)
glGenFramebuffers(1, &Gframebuffer);
// Create a new empty texture for rendering original scene
glGenTextures(1, &GfullscreenTexture);
glBindTexture(GL_TEXTURE_2D, GfullscreenTexture);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, WINDOW_WIDTH, WINDOW_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// Create 3 new empty textures for processing textures
glGenTextures(1, &GpTexture_0);
glBindTexture(GL_TEXTURE_2D, GpTexture_0);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, WINDOW_WIDTH, WINDOW_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glGenTextures(1, &GpTexture_1);
glBindTexture(GL_TEXTURE_2D, GpTexture_1);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, WINDOW_WIDTH, WINDOW_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glGenTextures(1, &GpTexture_2);
glBindTexture(GL_TEXTURE_2D, GpTexture_2);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, WINDOW_WIDTH, WINDOW_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
// Create and bind render buffer, and create a 16-bit depth buffer
glGenRenderbuffers(1, &GdepthRenderbuffer);
glBindRenderbuffer(GL_RENDERBUFFER, GdepthRenderbuffer);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, WINDOW_WIDTH, WINDOW_HEIGHT);
// Load Shaders
vertexShader = LoadShaderFromFile(GL_VERTEX_SHADER, "../vertexShader1.vert" );
fragmentShader = LoadShaderFromFile(GL_FRAGMENT_SHADER, "../fragmentShader1.frag" );
// Create the program object
programObject = glCreateProgram ( );
if ( programObject == 0 )
return 0;
glAttachShader ( programObject, fragmentShader );
glAttachShader ( programObject, vertexShader );
// (Send from CPU to GPU)
// Bind vPosition to attribute 0
glBindAttribLocation(programObject, 0, "vPosition");
// Bind vColor to attribute 1
glBindAttribLocation(programObject, 1, "vColor");
// Bind vPosition to attribute 2
glBindAttribLocation(programObject, 2, "vTexCoord");
// Link the program
glLinkProgram ( programObject );
// Check the link status
glGetProgramiv ( programObject, GL_LINK_STATUS, &linked );
if ( !linked )
{
GLint infoLen = 0;
glGetProgramiv ( programObject, GL_INFO_LOG_LENGTH, &infoLen );
if ( infoLen > 1 )
{
//char* infoLog = malloc (sizeof(char) * infoLen );
char infoLog[512];
glGetProgramInfoLog ( programObject, infoLen, NULL, infoLog );
printf ( "Error linking program:\n%s\n", infoLog );
//free ( infoLog );
}
glDeleteProgram ( programObject );
return 0;
}
// Store the program object
GprogramID = programObject;
glClearColor ( 0.0f, 0.0f, 0.0f, 0.0f );
// Enable depth test
glEnable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
//Initialize Matrices
gPerspectiveMatrix = Matrix4::perspective
(
60.0f,
(float)WINDOW_WIDTH / (float)WINDOW_HEIGHT,
0.1f, 30.0f
);
gViewMatrix = Matrix4::translate(Vector3(0.0f, 0.0f, -2.0f));
return 1;
}
