// GL utilities, bare essentials
// By Ingemar Ragnemalm
// August 2012:
// FBO creation/usage routines.
// Geometry shader support synched with preliminary version.
// September 2012: Improved infolog printouts with file names.
// 120910: Clarified error messages from shader loader.
// 120913: Re-activated automatic framebuffer checks for UseFBO().
// Fixed FUBAR in InitFBO().
// 130228: Changed most printf's to stderr.
// 131014: Added tesselation shader support
// 150812: Added a NULL check on file names in readFile, makes Visual Studio happier.
// 160302: Uses fopen_s on Windows, as suggested by Jesper Post. Should reduce warnings a bit.
// 200405: Added a few typecasts that were missing.
// 210219: Shader errors are now visible on new VS19.
// 210324: Compiling without fragment shader is now allowed
// 220113: Removed the last remains of VS support. Use a system that
// can handle printf! From now on, I will use CodeBlocks on Windows.
//#define GL3_PROTOTYPES
#ifdef WIN32
#include <Windows.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <stddef.h>
#include <string.h>
#include "GL_utilities.h"
// Shader loader
char* readFile(char *file)
{
FILE *fptr;
long length;
char *buf;
if (file == NULL)
return NULL;
// It seems Windows/VS doesn't like fopen any more, but fopen_s is not on the others.
#if defined(_WIN32)
fopen_s(&fptr, file, "r");
#else
fptr = fopen(file, "rb"); // rw works everywhere except Windows?
#endif
// fptr = fopen(file, "rb"); /* Open file for reading */
if (!fptr) /* Return NULL on failure */
return NULL;
fseek(fptr, 0, SEEK_END); /* Seek to the end of the file */
length = ftell(fptr); /* Find out how many bytes into the file we are */
buf = (char*)malloc(length+1); /* Allocate a buffer for the entire length of the file and a null terminator */
memset(buf, 0, sizeof(char)*(length + 1)); /* Clean the buffer - suggested for safety by Mateusz 2016 */
fseek(fptr, 0, SEEK_SET); /* Go back to the beginning of the file */
fread(buf, length, 1, fptr); /* Read the contents of the file in to the buffer */
fclose(fptr); /* Close the file */
buf[length] = 0; /* Null terminator */
return buf; /* Return the buffer */
}
// Infolog: Show result of shader compilation
void printShaderInfoLog(GLuint obj, const char *fn)
{
GLint infologLength = 0;
GLint charsWritten = 0;
char *infoLog;
glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &infologLength);
if (infologLength > 2)
{
fprintf(stderr, "[From %s:]\n", fn);
infoLog = (char *)malloc(infologLength);
glGetShaderInfoLog(obj, infologLength, &charsWritten, infoLog);
fprintf(stderr, "[From %s:]\n", infoLog);
free(infoLog);
}
}
void printProgramInfoLog(GLuint obj, const char *vfn, const char *ffn,
const char *gfn, const char *tcfn, const char *tefn)
{
GLint infologLength = 0;
GLint charsWritten = 0;
char *infoLog;
glGetProgramiv(obj, GL_INFO_LOG_LENGTH,&infologLength);
if (infologLength > 2)
{
if (ffn == NULL)
fprintf(stderr, "[From %s:]\n", vfn);
else
if (gfn == NULL)
fprintf(stderr, "[From %s+%s:]\n", vfn, ffn);
else
if (tcfn == NULL || tefn == NULL)
fprintf(stderr, "[From %s+%s+%s:]\n", vfn, ffn, gfn);
else
fprintf(stderr, "[From %s+%s+%s+%s+%s:]\n", vfn, ffn, gfn, tcfn, tefn);
infoLog = (char *)malloc(infologLength);
glGetProgramInfoLog(obj, infologLength, &charsWritten, infoLog);
fprintf(stderr, "%s\n",infoLog);
free(infoLog);
}
}
// Compile a shader, return reference to it
GLuint compileShaders(const char *vs, const char *fs, const char *gs, const char *tcs, const char *tes,
const char *vfn, const char *ffn, const char *gfn, const char *tcfn, const char *tefn)
{
GLuint v,f,g,tc,te,p;
v = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(v, 1, &vs, NULL);
glCompileShader(v);
if (fs != NULL)
{
f = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(f, 1, &fs, NULL);
glCompileShader(f);
}
if (gs != NULL)
{
g = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(g, 1, &gs, NULL);
glCompileShader(g);
}
#ifdef GL_TESS_CONTROL_SHADER
if (tcs != NULL)
{
tc = glCreateShader(GL_TESS_CONTROL_SHADER);
glShaderSource(tc, 1, &tcs, NULL);
glCompileShader(tc);
}
if (tes != NULL)
{
te = glCreateShader(GL_TESS_EVALUATION_SHADER);
glShaderSource(te, 1, &tes, NULL);
glCompileShader(te);
}
#endif
p = glCreateProgram();
if (vs != NULL)
glAttachShader(p,v);
if (fs != NULL)
glAttachShader(p,f);
if (gs != NULL)
glAttachShader(p,g);
if (tcs != NULL)
glAttachShader(p,tc);
if (tes != NULL)
glAttachShader(p,te);
glLinkProgram(p);
glUseProgram(p);
if (vs != NULL) printShaderInfoLog(v, vfn);
if (fs != NULL) printShaderInfoLog(f, ffn);
if (gs != NULL) printShaderInfoLog(g, gfn);
if (tcs != NULL) printShaderInfoLog(tc, tcfn);
if (tes != NULL) printShaderInfoLog(te, tefn);
printProgramInfoLog(p, vfn, ffn, gfn, tcfn, tefn);
return p;
}
GLuint loadShaders(const char *vertFileName, const char *fragFileName)
{
return loadShadersGT(vertFileName, fragFileName, NULL, NULL, NULL);
}
GLuint loadShadersG(const char *vertFileName, const char *fragFileName, const char *geomFileName)
// With geometry shader support
{
return loadShadersGT(vertFileName, fragFileName, geomFileName, NULL, NULL);
}
GLuint loadShadersGT(const char *vertFileName, const char *fragFileName, const char *geomFileName,
const char *tcFileName, const char *teFileName)
// With tesselation shader support
{
char *vs, *fs, *gs, *tcs, *tes;
GLuint p = 0;
vs = readFile((char *)vertFileName);
fs = readFile((char *)fragFileName);
gs = readFile((char *)geomFileName);
tcs = readFile((char *)tcFileName);
tes = readFile((char *)teFileName);
if (vs==NULL)
fprintf(stderr, "Failed to read %s from disk.\n", vertFileName);
if (fs==NULL && (fragFileName != NULL))
fprintf(stderr, "Failed to read %s from disk.\n", fragFileName);
if ((gs==NULL) && (geomFileName != NULL))
fprintf(stderr, "Failed to read %s from disk.\n", geomFileName);
if ((tcs==NULL) && (tcFileName != NULL))
fprintf(stderr, "Failed to read %s from disk.\n", tcFileName);
if ((tes==NULL) && (teFileName != NULL))
fprintf(stderr, "Failed to read %s from disk.\n", teFileName);
if ((vs!=NULL)&&(fs!=NULL))
p = compileShaders(vs, fs, gs, tcs, tes, vertFileName, fragFileName, geomFileName, tcFileName, teFileName);
if (vs != NULL) free(vs);
if (fs != NULL) free(fs);
if (gs != NULL) free(gs);
if (tcs != NULL) free(tcs);
if (tes != NULL) free(tes);
return p;
}
// End of Shader loader
void dumpInfo(void)
{
printf ("Vendor: %s\n", glGetString (GL_VENDOR));
printf ("Renderer: %s\n", glGetString (GL_RENDERER));
printf ("Version: %s\n", glGetString (GL_VERSION));
printf ("GLSL: %s\n", glGetString (GL_SHADING_LANGUAGE_VERSION));
printError ("dumpInfo");
}
static GLenum lastError = 0;
static char lastErrorFunction[1024] = "";
/* report GL errors, if any, to stderr */
void printError(const char *functionName)
{
GLenum error;
while (( error = glGetError() ) != GL_NO_ERROR)
{
if ((lastError != error) || (strcmp(functionName, lastErrorFunction)))
{
fprintf (stderr, "GL error 0x%X detected in %s\n", error, functionName);
strcpy(lastErrorFunction, functionName);
lastError = error;
}
}
}
// FBO
//----------------------------------FBO functions-----------------------------------
void CHECK_FRAMEBUFFER_STATUS()
{
GLenum status;
status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
fprintf(stderr, "Framebuffer not complete\n");
}
// create FBO
// FP buffer, suitable for HDR
FBOstruct *initFBO(int width, int height, int int_method)
{
FBOstruct *fbo = (FBOstruct *) malloc(sizeof(FBOstruct));
fbo->width = width;
fbo->height = height;
// create objects
glGenFramebuffers(1, &fbo->fb); // frame buffer id
glBindFramebuffer(GL_FRAMEBUFFER, fbo->fb);
glGenTextures(1, &fbo->texid);
fprintf(stderr, "%i \n",fbo->texid);
glBindTexture(GL_TEXTURE_2D, fbo->texid);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
if (int_method == 0)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbo->texid, 0);
// Renderbuffer
// initialize depth renderbuffer
glGenRenderbuffers(1, &fbo->rb);
glBindRenderbuffer(GL_RENDERBUFFER, fbo->rb);
glRenderbufferStorage( GL_RENDERBUFFER, GL_DEPTH_COMPONENT24, fbo->width, fbo->height );
glFramebufferRenderbuffer( GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, fbo->rb );
CHECK_FRAMEBUFFER_STATUS();
fprintf(stderr, "Framebuffer object %d\n", fbo->fb);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return fbo;
}
// create FBO, optionally with depth
// Integer buffer, not suitable for HDR!
FBOstruct *initFBO2(int width, int height, int int_method, int create_depthimage)
{
FBOstruct *fbo = (FBOstruct *)malloc(sizeof(FBOstruct));
fbo->width = width;
fbo->height = height;
// create objects
glGenRenderbuffers(1, &fbo->rb);
glGenFramebuffers(1, &fbo->fb); // frame buffer id
glBindFramebuffer(GL_FRAMEBUFFER, fbo->fb);
glGenTextures(1, &fbo->texid);
fprintf(stderr, "%i \n",fbo->texid);
glBindTexture(GL_TEXTURE_2D, fbo->texid);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
if (int_method == 0)
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbo->texid, 0);
if (create_depthimage!=0)
{
glGenTextures(1, &fbo->depth);
glBindTexture(GL_TEXTURE_2D, fbo->depth);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT16, width, height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0L);
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_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_2D, 0);
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, fbo->depth, 0);
fprintf(stderr, "depthtexture: %i\n",fbo->depth);
}
// Renderbuffer
// initialize depth renderbuffer
glBindRenderbuffer(GL_RENDERBUFFER, fbo->rb);
CHECK_FRAMEBUFFER_STATUS();
fprintf(stderr, "Framebuffer object %d\n", fbo->fb);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
return fbo;
}
static int lastw = 0;
static int lasth = 0;
// Obsolete
void updateScreenSizeForFBOHandler(int w, int h)
{
lastw = w;
lasth = h;
}
// choose input (textures) and output (FBO)
void useFBO(FBOstruct *out, FBOstruct *in1, FBOstruct *in2)
{
GLint curfbo;
// This was supposed to catch changes in viewport size and update lastw/lasth.
// It worked for me in the past, but now it causes problems to I have to
// fall back to manual updating.
glGetIntegerv(GL_FRAMEBUFFER_BINDING, &curfbo);
if (curfbo == 0)
{
GLint viewport[4] = {0,0,0,0};
GLint w, h;
glGetIntegerv(GL_VIEWPORT, viewport);
w = viewport[2] - viewport[0];
h = viewport[3] - viewport[1];
if ((w > 0) && (h > 0) && (w < 65536) && (h < 65536)) // I don't believe in 64k pixel wide frame buffers for quite some time
{
lastw = viewport[2] - viewport[0];
lasth = viewport[3] - viewport[1];
}
}
if (out != 0L)
glViewport(0, 0, out->width, out->height);
else
glViewport(0, 0, lastw, lasth);
if (out != 0L)
{
glBindFramebuffer(GL_FRAMEBUFFER, out->fb);
glViewport(0, 0, out->width, out->height);
}
else
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glActiveTexture(GL_TEXTURE1);
if (in2 != 0L)
glBindTexture(GL_TEXTURE_2D, in2->texid);
else
glBindTexture(GL_TEXTURE_2D, 0);
glActiveTexture(GL_TEXTURE0);
if (in1 != 0L)
glBindTexture(GL_TEXTURE_2D, in1->texid);
else
glBindTexture(GL_TEXTURE_2D, 0);
}
git.rcrnstn.net