Program::Program(int files, char** fileNames, char *options) {
program = -1;
vertexShader = -1;
fragmentShader = -1;
const char **contents = (const char**) malloc((files + 2) * sizeof(char*));
int i;
for (i = 0; i < files; ++i) {
contents[i + 2] = readFile(fileNames[i]);
}
if (program == -1) {
program = glCreateProgram();
vertexShader = glCreateShader(GL_VERTEX_SHADER);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
assert(glGetError() == 0);
}
contents[0] = "#define _VERTEXSHADER_\n";
contents[1] = options == NULL ? "" : options;
glShaderSource(vertexShader, files + 2, contents, NULL);
glCompileShader(vertexShader);
checkShader(vertexShader);
assert(glGetError() == 0);
contents[0] = "#define _FRAGMENTSHADER_\n";
glShaderSource(fragmentShader, files + 2, contents, NULL);
glCompileShader(fragmentShader);
checkShader(fragmentShader);
assert(glGetError() == 0);
for (i = 0; i < files; ++i) {
free((void*) contents[i + 2]);
}
glBindAttribLocation(program, 1, "normal");
glBindAttribLocation(program, 2, "color");
glLinkProgram(program);
GLint logLength;
glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLength);
if (logLength > 0) {
char *log = new char[logLength];
glGetProgramInfoLog(program, logLength, &logLength, log);
printf("%s", log);
}
if (checkProgram(program)) {
assert(glGetError() == 0);
} else {
printShaderLog(vertexShader);
printShaderLog(fragmentShader);
// exit(-1);
}
}
bool initShaders(const char* vertShaderPath, const char* fragShaderPath)
{
// create a program before linking shaders
program = glCreateProgram();
glUseProgram(program);
// compile shader sources
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
const char* vertexShaderSource = readShader(vertShaderPath); if (vertexShaderSource == NULL) return false;
GLint vertexShaderLength = strlen(vertexShaderSource);
glShaderSource(vertexShader, 1, &vertexShaderSource, &vertexShaderLength);
glCompileShader(vertexShader);
if (!checkShader(vertexShader, "vertexShader")){ printf("Unable to compile vertex shader\n"); return false; }
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
const char* fragmentShaderSource = readShader(fragShaderPath); if (fragmentShaderSource == NULL) return false;
GLint fragmentShaderLength = strlen(fragmentShaderSource);
glShaderSource(fragmentShader, 1, &fragmentShaderSource, &fragmentShaderLength);
glCompileShader(fragmentShader);
if (!checkShader(fragmentShader, "fragmentShader")){ printf("Unable to compile fragment shader\n"); return false; }
// attach vertex/fragments shaders and link program
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glLinkProgram(program);
if (!checkProgram(program, "program")){ printf("Unable to link program\n"); return false; }
// deallocate string
free((void*)vertexShaderSource);
free((void*)fragmentShaderSource);
return true;
}
static void initShader_phong ()
{
/*if (! glutExtensionSupported("GL_ARB_vertex_program"))
Fail("GL_ARB_vertex_program not available on this machine");
if (! glutExtensionSupported("GL_ARB_fragment_program"))
Fail("GL_ARB_fragment_program not available on this machine");*/
glEnable(GL_VERTEX_PROGRAM_ARB);
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glGenProgramsARB(3, Shader);
glBindProgramARB(GL_VERTEX_PROGRAM_ARB, Shader[0]);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(ShaderSrc[0]), ShaderSrc[0]);
checkShader(0);
glBindProgramARB(GL_FRAGMENT_PROGRAM_ARB, Shader[1]);
glProgramStringARB(GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(ShaderSrc[1]), ShaderSrc[1]);
checkShader(1);
/*glBindProgramARB(GL_VERTEX_PROGRAM_ARB, Shader[2]);
glProgramStringARB(GL_VERTEX_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB,
strlen(ShaderSrc[2]), ShaderSrc[2]);
checkShader(2);*/
glDisable(GL_VERTEX_PROGRAM_ARB);
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
static GLuint loadVertexShader(const char * source) {
GLuint shader = glCreateProgramObjectARB();
if(!shader) {
LogWarning << "failed to create program object";
return 0;
}
GLuint obj = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
if(!obj) {
LogWarning << "failed to create shader object";
glDeleteObjectARB(shader);
return 0;
}
glShaderSourceARB(obj, 1, &source, NULL);
glCompileShaderARB(obj);
if(!checkShader(obj, "compile", GL_OBJECT_COMPILE_STATUS_ARB)) {
glDeleteObjectARB(obj);
glDeleteObjectARB(shader);
return 0;
}
glAttachObjectARB(shader, obj);
glDeleteObjectARB(obj);
glLinkProgramARB(shader);
if(!checkShader(shader, "link", GL_OBJECT_LINK_STATUS_ARB)) {
glDeleteObjectARB(shader);
return 0;
}
return shader;
}
unsigned int ShaderManager::createProgram(const std::string &vertexShaderFilename, const std::string &geometryShaderFilename,
const std::string &fragmentShaderFilename, const std::map<std::string, std::string> &tokens)
{
unsigned int programID = glCreateProgram();
programs.push_back(programID);
//vertex shader
const std::string &vertexShaderFileSource = readEntireFile(shadersParentDirectory + shadersDirectoryName + vertexShaderFilename);
const std::string &vertexShaderSourceStep1 = tokenReplacerShader.replaceTokens(vertexShaderFileSource, tokens);
const std::string &vertexShaderSource = loopUnrollerShader.unrollLoops(vertexShaderSourceStep1);
const char *vertexShaderSourceChar = vertexShaderSource.c_str();
unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSourceChar, nullptr);
glCompileShader(vertexShader);
checkShader(vertexShader, vertexShaderFilename);
glAttachShader(programID, vertexShader);
//geometry shader
if(!geometryShaderFilename.empty())
{
const std::string &geometryShaderFileSource = readEntireFile(shadersParentDirectory + shadersDirectoryName + geometryShaderFilename);
const std::string &geometryShaderSourceStep1 = tokenReplacerShader.replaceTokens(geometryShaderFileSource, tokens);
const std::string &geometryShaderSource = loopUnrollerShader.unrollLoops(geometryShaderSourceStep1);
const char *geometryShaderSourceChar = geometryShaderSource.c_str();
unsigned int geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(geometryShader, 1, &geometryShaderSourceChar, nullptr);
glCompileShader(geometryShader);
checkShader(geometryShader, geometryShaderFilename);
glAttachShader(programID, geometryShader);
}
//fragment shader
const std::string &fragmentShaderFileSource = readEntireFile(shadersParentDirectory + shadersDirectoryName + fragmentShaderFilename);
const std::string &fragmentShaderSourceStep1 = tokenReplacerShader.replaceTokens(fragmentShaderFileSource, tokens);
const std::string &fragmentShaderSource = loopUnrollerShader.unrollLoops(fragmentShaderSourceStep1);
const char *fragmentShaderSourceChar = fragmentShaderSource.c_str();
unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSourceChar, nullptr);
glCompileShader(fragmentShader);
checkShader(fragmentShader, fragmentShaderFilename);
glAttachShader(programID, fragmentShader);
//link
glLinkProgram(programID);
checkProgram(programID, vertexShaderFilename + ", " + geometryShaderFilename + ", " + fragmentShaderFilename);
return programID;
}
int register_graphics::createMesh(lua_State* L)
{
mesh* m = checkMesh(L, 1);
shader* s = checkShader(L, 2);
//m->create(s, vertices, indices);
return 1;
}
int register_graphics::drawFont(lua_State *L)
{
font* f = checkFont(L, 1);
shader* s = checkShader(L, 2);
if(!s->getLinked() && s != NULL)
LOG("WARNING: shader:bind must be called before drawFont!");
const char* message = "";
if(lua_isstring(L, 3))
message = lua_tostring(L, 3);
float x; float y;
if(lua_isnumber(L,4))
x = lua_tonumber(L, 4);
if(lua_isnumber(L,5))
y = lua_tonumber(L, 5);
float sx = 1; float sy = 1;
if(lua_isnumber(L,6))
sx = lua_tonumber(L, 6);
if(lua_isnumber(L,7))
sy = lua_tonumber(L, 7);
float r = 255; float g = 255; float b = 255;
if(lua_isnumber(L, 8))
r = lua_tonumber(L, 8);
if(lua_isnumber(L, 9))
g = lua_tonumber(L, 9);
if(lua_isnumber(L, 10))
b = lua_tonumber(L, 10);
float a = 255;
if(lua_isnumber(L, 11))
a = lua_tonumber(L, 11);
f->draw(message, s, x, y, sx, sy, r, g, b, a);
return 1;
}
bool createShader(std::string file, GLenum shaderType, GLuint & shader)
{
struct stat st;
if(stat(file.c_str(),&st) != 0)
{
std::cerr << "Error stating shader file: " << file << std::endl;
return false;
}
char * fileBuffer;
int filefd;
filefd = open(file.c_str(),O_RDONLY);
if(!filefd)
{
std::cerr << "Error opening shader file: " << file << std::endl;
return false;
}
fileBuffer = new char[st.st_size+1];
fileBuffer[st.st_size] = '\0';
read(filefd,fileBuffer,st.st_size);
close(filefd);
shader = glCreateShader(shaderType);
glShaderSource(shader, 1, (const GLchar **) &fileBuffer, NULL);
glCompileShader(shader);
delete[] fileBuffer;
return checkShader(shader);
}
GLuint createShader(GLenum shaderType, const GLchar* shaderSrcString) {
GLuint shader = glCreateShader(shaderType);
glShaderSource(shader, 1, &shaderSrcString, NULL);
glCompileShader(shader);
checkShader(shader);
return shader;
}
//TODO
int register_graphics::sendShaderUniformLocation(lua_State *L)
{
shader* s = checkShader(L, 1);
const char* location = lua_tostring(L, 2);
float data = lua_tonumber(L, 3);
s->sendUniformLocation(location, data);
return 1;
}
int register_graphics::createBatch(lua_State *L)
{
batch2d* batch = checkBatch(L, 1);
shader* s = checkShader(L, 2);
int limit = 9000;
if(lua_isinteger(L, 3))
limit = lua_tointeger(L, 3);
batch->create(s, limit);
return 1;
}
//Delete
int register_graphics::deleteShader(lua_State *L)
{
shader* f = checkShader(L, 1);
if (f != NULL){
SAFE_DELETE(f);
}else{
LOG("can not delete shader because it is null!");
return 0;
}
return 1;
}
GLuint GenericHolder::setupFragmentShader(){
const GLchar* fragmentSource =
"#version 330 core\n"
"out vec4 outColor;"
"void main() {"
" outColor = vec4(1.0, 0.0, 0.0, 1.0);"//RGBA
"}";
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
glCompileShader(fragmentShader);
checkShader(fragmentShader);
return fragmentShader;
}
/*Nacita textureShader*/
void Shader::createShaders(std::string vertexSource,std::string fragmentSource) {
const char* vsource = vertexSource.c_str();
const char* fsource = fragmentSource.c_str();
vertexShader = glCreateShader(GL_VERTEX_SHADER); //vytvori identifikator pre shader
glShaderSource(vertexShader, 1, &vsource, NULL);
glCompileShader(vertexShader);
Shader::checkShader(shaderProgram, GL_COMPILE_STATUS, false);
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fsource, NULL);
glCompileShader(fragmentShader);
checkShader(shaderProgram, GL_COMPILE_STATUS, false);
// Link the vertex and fragment shader into a shader program
shaderProgram = glCreateProgram(); //vytvori identifikator pre shader
glAttachShader(shaderProgram, vertexShader); //prideli k shaderu vertex shader
glAttachShader(shaderProgram, fragmentShader);
glBindFragDataLocation(shaderProgram, 0, "pixel"); //ktory atribut je vysledna farba
glLinkProgram(shaderProgram); //zlinkuje shader
checkShader(shaderProgram, GL_LINK_STATUS, true);
glUseProgram(shaderProgram); //prikaze pouzivat shader
}
GLuint GenericHolder::setupVertexShader(){
const GLchar* vertexSource =
"#version 330 core\n"
"in vec2 position;"
"uniform mat4 trans;"
"uniform mat4 view;"
"void main() {"
" gl_Position = view*trans*vec4(position, 0.0, 1.0);"//xyzw
"}";
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexSource, NULL);
glCompileShader(vertexShader);
checkShader(vertexShader);
return vertexShader;
}
InstanceSpotShader::InstanceSpotShader()
{
// load the shaders
std::string vertexShaderSource = loadShader("res/Shaders/instanceVertexShader.glsl");
std::string fragmentShaderSource = loadShader("res/Shaders/spotFragmentShader.glsl");
// create and compile the shaders
const GLchar* p[1];
GLint lengths[1];
p[0] = vertexShaderSource.c_str();
lengths[0] = vertexShaderSource.length();
m_shaders[VERTEX_SHADER] = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(m_shaders[VERTEX_SHADER], 1, p, lengths);
glCompileShader(m_shaders[VERTEX_SHADER]);
p[0] = fragmentShaderSource.c_str();
lengths[0] = fragmentShaderSource.length();
m_shaders[FRAGMENT_SHADER] = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(m_shaders[FRAGMENT_SHADER], 1, p, lengths);
glCompileShader(m_shaders[FRAGMENT_SHADER]);
// create, link and validate the program
m_program = glCreateProgram();
glAttachShader(m_program, m_shaders[VERTEX_SHADER]);
glAttachShader(m_program, m_shaders[FRAGMENT_SHADER]);
glLinkProgram(m_program);
glValidateProgram(m_program);
// check the shader for errors
checkShader(m_shaders, NUM_SHADERS, "Spot");
bind();
VPMatrixID = glGetUniformLocation(m_program, "VPMatrix");
modelMatrixID = glGetAttribLocation(m_program, "ModelMatrix");
m_uniforms[LIGHT_COLOR] = glGetUniformLocation(m_program, "lightColor");
m_uniforms[LIGHT_DIRECTION] = glGetUniformLocation(m_program, "lightDir");
m_uniforms[LIGHT_POSITION] = glGetUniformLocation(m_program, "lightPosition");
m_uniforms[LIGHT_CUTOFF] = glGetUniformLocation(m_program, "cutOff");
m_uniforms[LIGHT_CONSTANT] = glGetUniformLocation(m_program, "lightConstant");
m_uniforms[LIGHT_LINEAR] = glGetUniformLocation(m_program, "lightLinear");
m_uniforms[LIGHT_EXPONENT] = glGetUniformLocation(m_program, "lightExponent");
m_uniforms[EYE_POSITION] = glGetUniformLocation(m_program, "eyePosition");
m_uniforms[SPECULAR_INTENSITY] = glGetUniformLocation(m_program, "specularIntensity");
m_uniforms[SPECULAR_POWER] = glGetUniformLocation(m_program, "specularPower");
}
bool Shader::makeShader(const char *txt, GLuint type)
{
GLuint object = glCreateShaderObjectARB(type);
glShaderSource(object, 1, (const GLchar**)(&txt), NULL);
glCompileShader(object);
if( checkShader(object) )
{
glAttachObjectARB(m_program, object);
glDeleteObjectARB(object);
}
else
{
return false;
}
return true;
}
int register_graphics::createDefaultShader(lua_State* L)
{
shader* s = checkShader(L, 1);
default_shaders df;
std::string type = luaL_checkstring(L, 2);
#ifndef EMSCRIPTEN
if (type == "default")
s->create(df.gl_default_vertex.c_str(), df.gl_default_fragment.c_str());
#endif
#ifdef EMSCRIPTEN
if(type == "default")
s->create(df.gl_es_texture_vertex.c_str(), df.gl_es_texture_fragment.c_str());
#endif
return 1;
}
int register_graphics::createShader(lua_State *L)
{
shader* s = checkShader(L, 1);
string type;
if(lua_isstring(L, 2))
type = lua_tostring(L, 2);
if(lua_isstring(L, 2) && (type == "default"))
createDefaultShader(L);
else if(lua_isstring(L,2) && lua_isstring(L,3)){
//custom shader
luaL_checkstring(L, 2);
luaL_checkstring(L, 3);
const char* vertex = lua_tostring(L, 2);
const char* fragment = lua_tostring(L, 3);
s->create(vertex, fragment);
}
return 1;
}
int register_graphics::createFont(lua_State *L)
{
font* f = checkFont(L, 1);
shader* s = checkShader(L, 2);
luaL_checkstring(L, 3);
const char* path = lua_tostring(L, 3);
FT_Library freetype;
if(FT_Init_FreeType(&freetype)){
LOG("Error: Could not init freetype lib!");
return 0;
}
float size = 16;
if(lua_isnumber(L, 4))
size = lua_tonumber(L, 4);
f->load(freetype, s, path, size);
return 1;
}
GLuint Shader::loadShader(GLenum i, std::string name)
{
std::string shaderFileName;
try
{
shaderFileName = (Config::app/"shader"%name/getShaderName(i)).valueSTRING();
} catch_err(Error::ConfigAtSearchPropNotFound, Error::ShaderNoFile)
File::Text file(shaderFileName);
std::string shaderString;
file >> shaderString;
const char* shaderCString = shaderString.c_str();
GLuint shader = glCreateShader(i);
glShaderSource(shader, 1, &shaderCString, NULL);
glCompileShader(shader);
if(!checkShader(shader, GL_COMPILE_STATUS, i))
{
throw Error::ShaderCompileError;
exit(-1);
}
glAttachShader(program, shader);
return shader;
}
/*
* A combination of loadShaderSource(), checkShader() and shader compilation.
*
* @param vertexShaderName
* The path and filename to a vertex shader file.
* \n Recommendation: Define compiler flag @c -D"SHADERS_PATH" and call
* @a SHADERS_PATH"[filename]"
*
* @param fragmentShaderName
* The path and filename to a fragment shader file.
*
* @return
* The id of a created the shader program
*/
GLuint Shader::makeShaderProgram(bool usingVertexShader, bool usingGeometryShader, bool usingTesselationShader, bool usingFragmentShader, bool usingComputeShader) {
GLuint vertexShaderID, geometryShaderID, tesselationControlShaderID, tesselationEvaluationShaderID, fragmentShaderID, computeShaderID;
if (usingVertexShader){
//compile vertex shader
const char* vertexShaderName = &m_vertexShaderPath[0];
vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
loadShaderSource(vertexShaderID, vertexShaderName);
glCompileShader(vertexShaderID);
checkShader(vertexShaderID);
}
if (usingGeometryShader){
//compile geometry shader
const char* geometryShaderName = &m_geometryShaderPath[0];
geometryShaderID = glCreateShader(GL_GEOMETRY_SHADER);
loadShaderSource(geometryShaderID, geometryShaderName);
glCompileShader(geometryShaderID);
checkShader(geometryShaderID);
}
if (usingTesselationShader){
//compile tesselation shader
const char* tesselationControlShaderName = &m_tesselationControlShaderPath[0];
tesselationControlShaderID = glCreateShader(GL_TESS_CONTROL_SHADER);
loadShaderSource(tesselationControlShaderID, tesselationControlShaderName);
glCompileShader(tesselationControlShaderID);
checkShader(tesselationControlShaderID);
const char* tesselationEvaluationShaderName = &m_tesselationEvaluationShaderPath[0];
tesselationEvaluationShaderID = glCreateShader(GL_TESS_EVALUATION_SHADER);
loadShaderSource(tesselationEvaluationShaderID, tesselationEvaluationShaderName);
glCompileShader(tesselationEvaluationShaderID);
checkShader(tesselationEvaluationShaderID);
}
if (usingFragmentShader){
//compile fragment shader
const char* fragmentShaderName = &m_fragmentShaderPath[0];
fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
loadShaderSource(fragmentShaderID, fragmentShaderName);
glCompileShader(fragmentShaderID);
checkShader(fragmentShaderID);
}
if (usingComputeShader){
//compile compute shader
const char* computeShaderName = &m_computeShaderPath[0];
computeShaderID = glCreateShader(GL_FRAGMENT_SHADER);
loadShaderSource(computeShaderID, computeShaderName);
glCompileShader(computeShaderID);
checkShader(computeShaderID);
}
//link shader programs
GLuint programHandle = glCreateProgram();
if (m_usingVertexShader)
glAttachShader(programHandle, vertexShaderID);
if (m_usingGeometryShader)
glAttachShader(programHandle, geometryShaderID);
if (m_usingTesselationShader)
glAttachShader(programHandle, tesselationControlShaderID);
if (m_usingTesselationShader)
glAttachShader(programHandle, tesselationEvaluationShaderID);
if (m_usingFragmentShader)
glAttachShader(programHandle, fragmentShaderID);
if (m_usingComputeShader)
glAttachShader(programHandle, computeShaderID);
glLinkProgram(programHandle);
glUseProgram(programHandle);
//return programHandle;
return programHandle;
}
int register_graphics::unBindShader(lua_State *L)
{
shader* s = checkShader(L, 1);
s->unbind();
return 1;
}
