While some parts of the code can be moved more central other parts need to be further duplicated and in doing so the need to fix the same issues in multiple places make things harder and harder to maintain.
For my goals however I don't need the preprocessor to do much so we can keep everything very simple and we'll limit the functionality to the following:
- support for a #include to insert the text from a file into our shader
- supplying a number of "defines" which we can trigger logic
- very basic #ifdef, #ifndef and #else logic that use these defines to include or exclude parts of the shader code
Changes to our system library
I was thinking about putting most of this code in our system.h file but decided against that for now. I may yet change this in the future. For now one support function has been added here:
// gets the portion of the line up to the specified delimiter(s)
// return NULL on failure or if there is no text
// returns string on success, calling function is responsible for freeing the text
char * delimitText(const char *pText, const char *pDelimiters) {
int len = 0;
char * result = NULL;
bool found = false;
int delimiterCount;
delimiterCount = strlen(pDelimiters) + 1; // always include our trailing 0 as a delimiter ;)
while (!found) {
int pos = 0;
while ((!found) && (pos < delimiterCount)) {
if (pText[len] == pDelimiters[pos]) {
found = true;
};
pos++;
};
if (!found) {
len++;
};
};
if (len != 0) {
result = malloc(len + 1);
if (result != NULL) {
memcpy(result, pText, len);
result[len] = 0;
};
};
return result;
};
This function splits off the first part of the text pointed to by pText from the start until it detects one of the delimiters or the end of the string.This is fairly similar to the code we wrote before to read out material and object files line by line but without using our varchar implementation.
Changes to our varchar library
We are going to use varchar.h but in combination with a linked list to store our defines in. For this I've added 3 new functions:
// list container for varchars
// llist * strings = newVarcharList()
llist * newVarcharList() {
llist * varcharList = newLlist((dataRetainFunc) varcharRetain, (dataFreeFunc) varcharRelease);
return varcharList;
};
This first function simply returns a linked list setup to accept varchar objects.
// list container for varchars created by processing a string
// empty strings will not be added but duplicate strings will be
// llist * strings = newVarcharList()
llist * newVCListFromString(const char * pText, const char * pDelimiters) {
llist * varcharList = newVarcharList();
if (varcharList != NULL) {
int pos = 0;
while (pText[pos] != 0) {
// find our next line
char * line = delimitText(pText + pos, pDelimiters);
if (line != NULL) {
int len = strlen(line);
varchar * addChar = newVarchar();
if (addChar != NULL) {
varcharAppend(addChar, line, len);
llistAddTo(varcharList, addChar);
};
if (pText[pos + len] != 0) {
// skip our newline character
pos += len + 1;
} else {
// we found our ending
pos += len;
};
free(line);
} else {
// skip any empty line...
pos++;
};
};
};
return varcharList;
};
This method uses our new delimitText function to pull a given string appart and add each word in the string as an entry into a new linked list.
// check if our list contains a string
bool vclistContains(llist * pVCList, const char * pText) {
if ((pVCList != NULL) && (pText != NULL)) {
llistNode * node = pVCList->first;
while (node != NULL) {
varchar * text = (varchar *) node->data;
if (varcharCmp(text, pText) == 0) {
return true;
};
node = node->next;
};
};
// not found
return false;
};
And finally a function that checks if a given word is present in our linked list.Changes to our shader library
The real implementation can be found in our shader library. We've added a new parameter to our newShader function so we can pass it the defines we want to use for that shader:
shaderInfo * newShader(const char *pName, const char * pVertexShader, const char * pTessControlShader, const char * pTessEvalShader, const char * pGeoShader, const char * pFragmentShader, const char *pDefines) {
shaderInfo * newshader = (shaderInfo *)malloc(sizeof(shaderInfo));
if (newshader != NULL) {
llist * defines;
...
// convert our defines
defines = newVCListFromString(pDefines, " \r\n");
// attempt to load our shader by name
if (pVertexShader != NULL) {
shaders[count] = shaderLoad(GL_VERTEX_SHADER, pVertexShader, defines);
if (shaders[count] != NO_SHADER) count++;
};
...
// no longer need our defines
if (defines != NULL) {
llistFree(defines);
};
...
return newshader;
};
We first convert our new parameter pDefines into a linked list of varchars by calling our new newVCListFromString function.We then pass our new linked list to each shaderLoad call so it can be used by our preprocessor.
Finally we deallocate our linked list and all the varchars held within.
The only change in shaderLoad is that it no longer called loadFile directly but instead calls shaderLoadAndPreprocess:
varchar * shaderLoadAndPreprocess(const char *pName, llist * pDefines) {
varchar * shaderText = NULL;
// create a new varchar object for our shader text
shaderText = newVarchar();
if (shaderText != NULL) {
// load the contents of our file
char * fileText = loadFile(shaderPath, pName);
if (fileText != NULL) {
// now loop through our text line by line (we do this with a copy of our pointer)
int pos = 0;
bool addLines = true;
int ifMode = 0; // 0 is not in if, 1 = true condition not found, 2 = true condition found
while (fileText[pos] != 0) {
// find our next line
char * line = delimitText(fileText + pos, "\n\r");
// found a non-empty line?
if (line != NULL) {
int len = strlen(line);
// check for any of our preprocessor checks
if (memcmp(line, "#include \"", 10) == 0) {
if (addLines) {
// include this file
char * includeName = delimitText(line + 10, "\"");
if (includeName != NULL) {
varchar * includeText = shaderLoadAndPreprocess(includeName, pDefines);
if (includeText != NULL) {
// and append it....
varcharAppend(shaderText, includeText->text, includeText->len);
varcharRelease(includeText);
};
free(includeName);
};
};
} else if (memcmp(line, "#ifdef ", 7) == 0) {
if (ifMode == 0) {
char * ifdefined;
ifMode = 1; // assume not defined....
ifdefined = delimitText(line + 7, " ");
if (ifdefined != NULL) {
// check if our define is in our list of defines
if (vclistContains(pDefines, ifdefined)) {
ifMode = 2;
};
free(ifdefined);
};
addLines = (ifMode == 2);
} else {
errorlog(SHADER_ERR_NESTED, "Can't nest defines in shaders");
};
} else if (memcmp(line, "#ifndef ", 8) == 0) {
if (ifMode == 0) {
char * ifnotdefined;
ifMode = 1; // assume not defined....
ifnotdefined = delimitText(line + 7, " ");
if (ifnotdefined != NULL) {
// check if our define is not in our list of defines
if (vclistContains(pDefines, ifnotdefined) == false) {
ifMode = 2;
};
free(ifnotdefined);
};
addLines = (ifMode == 2);
} else {
errorlog(SHADER_ERR_NESTED, "Can't nest defines in shaders");
};
} else if (memcmp(line, "#else", 5) == 0) {
if (ifMode == 1) {
ifMode = 2;
addLines = true;
} else {
addLines = false;
};
} else if (memcmp(line, "#endif", 6) == 0) {
addLines = true;
ifMode = 0;
} else if (addLines) {
// add our line
varcharAppend(shaderText, line, len);
// add our line delimiter
varcharAppend(shaderText, "\r\n", 1);
};
if (fileText[pos + len] != 0) {
// skip our newline character
pos += len + 1;
} else {
// we found our ending
pos += len;
};
// don't forget to free our line!!!
free (line);
} else {
// skip empty lines...
pos++;
};
};
// free the text we've loaded, what we need has now been copied into shaderText
free(fileText);
};
if (shaderText->text == NULL) {
varcharRelease(shaderText);
shaderText = NULL;
};
};
return shaderText;
};
I'm not going to detail each and every section, I hope the comments do a good enough job for that. In a nutshell however, we start by creating a new varchar variable called shaderText which is what we'll end up returning. This means that our shaderLoad function also has a small change to work with a varchar instead of a char pointer as a result.After this we load the contents of our shader file into a variable called fileText but instead of using this directly we use delimitText to loop through our shader text one line at a time.
For each line we check if it starts with one of our preprocessor commands and if so handle the special logic associated with it. If not we simply add our line to our shaderText variable.
#include is the first preprocessor command we handle, it simply checks the filename presented and attempts to load that file by calling shaderLoadAndPreprocess recursively.
This is followed by the code that interprets our #ifdef, #ifndef, #else and #endif preprocessor commands. These basically check if the given define is present in our linked list. They toggle the values of ifMode and addLines that control whether we ignore text in our shader file or add the lines to our shaderText.
Changes to our shaders
I've made two changes to our shaders, the first is that I've created a new shader files called "shadowmap.fs" that contains our samplePCF, shadow and shadowTest functions and we use #include in the various fragment shaders where we need these functions.
The second change is that I've combined our flatshader.fs, textured.fs and reflect.fs fragment shaders into a single standard.fs file that looks as follows:
#version 330
// info about our light
uniform vec3 lightPos; // position of our light after view matrix was applied
uniform float ambient = 0.3; // ambient factor
uniform vec3 lightcol = vec3(1.0, 1.0, 1.0); // color of the light of our sun
// info about our material
uniform float alpha = 1.0; // alpha for our material
#ifdef textured
uniform sampler2D textureMap; // our texture map
#else
uniform vec3 matColor = vec3(0.8, 0.8, 0.8); // color of our material
#endif
uniform vec3 matSpecColor = vec3(1.0, 1.0, 1.0); // specular color of our material
uniform float shininess = 100.0; // shininess
#ifdef reflect
uniform sampler2D reflectMap; // our reflection map
#endif
// these are in world coordinates
in vec3 E; // normalized vector pointing from eye to V
in vec3 N; // normal vector for our fragment
// these in view
in vec4 V; // position of fragment after modelView matrix was applied
in vec3 Nv; // normal vector for our fragment (inc view matrix)
in vec2 T; // coordinates for this fragment within our texture map
in vec4 Vs[3]; // our shadow map coordinates
out vec4 fragcolor; // our output color
#include "shadowmap.fs"
void main() {
#ifdef textured
// start by getting our color from our texture
fragcolor = texture(textureMap, T);
fragcolor.a = fragcolor.a * alpha;
if (fragcolor.a < 0.2) {
discard;
};
#else
// Just set our color
fragcolor = vec4(matColor, alpha);
#endif
// Get the normalized directional vector between our surface position and our light position
vec3 L = normalize(lightPos - V.xyz);
// We calculate our ambient color
vec3 ambientColor = fragcolor.rgb * lightcol * ambient;
// Check our shadow map
float shadowFactor = shadow(Vs[0], Vs[1], Vs[2]);
// We calculate our diffuse color, we calculate our dot product between our normal and light
// direction, note that both were adjusted by our view matrix so they should nicely line up
float NdotL = max(0.0, dot(Nv, L));
// and calculate our color after lighting is applied
vec3 diffuseColor = fragcolor.rgb * lightcol * (1.0 - ambient) * NdotL * shadowFactor;
// now for our specular lighting
vec3 specColor = vec3(0.0);
if ((NdotL != 0.0) && (shininess != 0.0)) {
// slightly different way to calculate our specular highlight
vec3 halfVector = normalize(L - normalize(V.xyz));
float nxHalf = max(0.0, dot(Nv, halfVector));
float specPower = pow(nxHalf, shininess);
specColor = lightcol * matSpecColor * specPower * shadowFactor;
};
#ifdef reflect
// add in our reflection, this is one of the few places where world coordinates are paramount.
vec3 r = reflect(E, N);
vec2 rc = vec2((r.x + 1.0) / 4.0, (r.y + 1.0) / 2.0);
if (r.z < 0.0) {
r.x = 1.0 - r.x;
};
vec3 reflColor = texture(reflectMap, rc).rgb;
// and add them all together
fragcolor = vec4(clamp(ambientColor+diffuseColor+specColor+reflColor, 0.0, 1.0), fragcolor.a);
#else
// and add them all together
fragcolor = vec4(clamp(ambientColor+diffuseColor+specColor, 0.0, 1.0), fragcolor.a);
#endif
}
Note the inclusion of our #ifdef blocks to change between our various bits of logic while reusing code that is the same in all three shaders.We can now change our shader loading code in engine.h to the following:
colorShader = newShader("flatcolor", "standard.vs", NULL, NULL, NULL, "standard.fs", "");
texturedShader = newShader("textured", "standard.vs", NULL, NULL, NULL, "standard.fs", "textured");
reflectShader = newShader("reflect", "standard.vs", NULL, NULL, NULL, "standard.fs", "reflect");
If we need it we could very quickly add a fourth shader that combines texture mapping and reflection mapping by simply passing "textured reflect" as our defines.In the same way I've combined our shadow shaders into a single shader file.
Obviously there is a lot of room for improvement here, but it is a start and enough to keep us going for a little bit longer.
Download the source here
What's next?
Now we're ready to start working on our deferred shader.
