bool Shader::LoadAndCompile(const std::string& sVert, const std::string& sFrag)
{
GLhandleARB so[2];
memset(so, 0, sizeof(GLhandleARB)*2);
///Loading the shader
so[0] = loadShader(sVert.c_str());
if(so[0]==0){
std::cerr << "loading shader "+sVert+" failed" << std::endl;
return false;
}
///Compiling the shader, done by the graphic card
if(!compileShader(so[0])){
std::cerr << "compiling shader "+sVert+" failed" << std::endl;
return false;
}
so[1] = loadShader(sFrag.c_str());
if(so[1]==0){
std::cerr << "loading shader "+sFrag+" failed " << std::endl;
return false;
}
if(!compileShader(so[1])){
std::cerr << "compiling shader "+sFrag+" failed " << std::endl;
return false;
}
m_oProgram = linkShaders(so,2);
m_bIsReady = true;
return true;
}
void GLProgram::getShaders(void)
{
Configuration *c = Configuration::getInstance();
std::string str = c->getConfiguration("VERTEX_SHADER");
addShader(str, GL_VERTEX_SHADER);
str = c->getConfiguration("FRAGMENT_SHADER");
addShader(str, GL_FRAGMENT_SHADER);
linkShaders();
}
void OpenGLShader::loadProgram(const std::string vertexPath, const std::string fragmentPath)
{
const GLuint vertexShader = loadShader(vertexPath, GL_VERTEX_SHADER);
const GLuint fragmentShader = loadShader(fragmentPath, GL_FRAGMENT_SHADER);
// Create shader program and link it
GLuint shaderProgram = glCreateProgram();
linkShaders(shaderProgram, { vertexShader, fragmentShader });
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
this->identifier = shaderProgram;
}
GLuint LoadShaderProgram(char *filenameVertex, char *filenameFragment)
{
GLuint program = 0;
char *buffer1;
char *buffer2;
const GLchar *pSource = 0;
long length = 0;
GLuint vertShader = 0;
GLuint fragShader = 0;
FILE* file;
if (filenameVertex != NULL)
{
file = fopen(filenameVertex, "r");
if(!file)
{
fprintf(stderr, "failed to open vert shader file %s\n", filenameVertex);
exit(1);
}
fseek (file , 0 , SEEK_END);
length = ftell (file);
rewind (file);
buffer1= (char*) malloc(sizeof(char)*length);
fread(buffer1,1,length,file);
fclose (file);
pSource = (const GLchar *)(buffer1);
vertShader = CompileShader(GL_VERTEX_SHADER, pSource, length);
}
if (filenameFragment != NULL)
{
file = fopen(filenameFragment, "r");
if(!file)
{
fprintf(stderr, "failed to open frag shader file %s\n", filenameFragment);
exit(1);
}
fseek (file , 0 , SEEK_END);
length = ftell(file);
rewind(file);
buffer2= (char*) malloc(sizeof(char)*length);
fread(buffer2,1,length,file);
fclose (file);
pSource = (const GLchar *)(buffer2);
fragShader = CompileShader(GL_FRAGMENT_SHADER, pSource, length);
}
program = linkShaders(vertShader, fragShader);
return program;
}
Renderer::Renderer(int width, int height)
: m_blockLibrary(new BlockLibrary)
{
setSize(width, height);
// We don't sort blocks ourselves, so we need depth testing
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
// For transparent blocks
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Create a vertex array object
glGenVertexArrays(1, &m_vertexArray);
glBindVertexArray(m_vertexArray);
//// Setup the terrain chunk shader program
GLuint vertexShader = loadShader("chunk-vertex.glsl", GL_VERTEX_SHADER);
GLuint fragmentShader = loadShader("chunk-fragment.glsl", GL_FRAGMENT_SHADER);
m_chunkShader.programId = linkShaders(vertexShader, fragmentShader);
// Input variables
m_chunkShader.position = glGetAttribLocation(m_chunkShader.programId, "position");
m_chunkShader.texCoord = glGetAttribLocation(m_chunkShader.programId, "texCoord");
m_chunkShader.lighting = glGetAttribLocation(m_chunkShader.programId, "lighting");
// Uniform variables
m_chunkShader.vpMatrix = glGetUniformLocation(m_chunkShader.programId, "vpMatrix");
m_chunkShader.textureSampler = glGetUniformLocation(m_chunkShader.programId, "textureSampler");
//m_chunkShader.highlight = glGetUniformLocation(m_chunkShader.programId, "highlight");
m_chunkShader.resolution = glGetUniformLocation(m_chunkShader.programId, "resolution");
m_chunkShader.sunPosition = glGetUniformLocation(m_chunkShader.programId, "sunPosition");
m_chunkShader.brightness = glGetUniformLocation(m_chunkShader.programId, "brightness");
//// Setup the screen tinting shader program
vertexShader = loadShader("tint-vertex.glsl", GL_VERTEX_SHADER);
fragmentShader = loadShader("tint-fragment.glsl", GL_FRAGMENT_SHADER);
m_tintShader.programId = linkShaders(vertexShader, fragmentShader);
m_tintShader.position = glGetAttribLocation(m_tintShader.programId, "position");
m_tintShader.color = glGetUniformLocation(m_tintShader.programId, "color");
GLfloat tintVertices[][2] =
{
{-1.0f, 1.0f}, {1.0f, -1.0f}, {1.0f, 1.0f},
{-1.0f, -1.0f}, {1.0f, -1.0f}, {-1.0f, 1.0f}
};
glGenBuffers(1, &m_tintShader.vbo);
glBindBuffer(GL_ARRAY_BUFFER, m_tintShader.vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 12, &tintVertices[0], GL_STATIC_DRAW);
/// Setup the block selection shader program
vertexShader = loadShader("floating-vertex.glsl", GL_VERTEX_SHADER);
fragmentShader = loadShader("floating-fragment.glsl", GL_FRAGMENT_SHADER);
m_blockShader.programId = linkShaders(vertexShader, fragmentShader);
std::vector<GLfloat> blockVertices;
for (size_t face = 0; face < 6; ++face)
{
for (size_t j = 0; j < 6; ++j)
{
CubeVertex vertex = cubeMesh[face * 6 + j];
glm::vec3 position = vertex.position;
// Center at the origin
position -= glm::vec3(0.5f);
// Rotate into a pleasing orientation
position = glm::rotateY(position, 45.0f);
position = glm::rotateX(position, 15.0f);
// Don't take up the entire screen
position.z -= 10.0f;
for (size_t i = 0; i < 3; ++i)
blockVertices.push_back(position[i]);
for (size_t i = 0; i < 2; ++i)
blockVertices.push_back(vertex.texCoord[i]);
blockVertices.push_back(face);
}
}
m_blockShader.position = glGetAttribLocation(m_blockShader.programId, "position");
m_blockShader.texCoord = glGetAttribLocation(m_blockShader.programId, "texCoord");
m_blockShader.textureSampler = glGetUniformLocation(m_blockShader.programId, "textureSampler");
m_blockShader.projection = glGetUniformLocation(m_blockShader.programId, "projection");
m_blockShader.blockType = glGetUniformLocation(m_blockShader.programId, "blockType");
glGenBuffers(1, &m_blockShader.vbo);
glBindBuffer(GL_ARRAY_BUFFER, m_blockShader.vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * 6 * 36, &blockVertices[0], GL_STATIC_DRAW);
}
bool Shader::Load(const std::string& name, const std::string& extensions)
{
if(!s_bInitialized)
if(!Init())
return false;
if(!extensions.empty()) {
std::stringstream ss( extensions );
std::string it;
while(std::getline(ss, it, ' '))
{
glInfo::GetSingleton().isExtensionSupported(it);
}
}
m_strName = name;
GLhandleARB so[3];
memset(so, 0, sizeof(GLhandleARB)*3);
// Set up path for shaders
char szPath[MAX_PATH+1];
GetCurrentDirectory(MAX_PATH, szPath); // Get Our Working Directory
strcat_s(szPath, "\\Data\\Shaders\\"); // Append "\\Data\\Shaders\\" After The Working Directory
strcat_s(szPath, name.c_str()); // Append The PathName
// convert back to string
std::string tempName;
tempName = szPath;
std::string s1 = tempName+".vert";
so[0] = loadShader(s1);
if(so[0]==0){
std::cerr << "[Error] Coading shader "+s1+" failed (exiting...)" << std::endl;
return false;
}
if(!compileShader(so[0])){
std::cerr << "[Error] Compiling shader "+s1+" failed (exiting...)" << std::endl;
return false;
}
std::string s2 = tempName+".frag";
so[1] = loadShader(s2);
if(so[1]==0){
std::cerr << "[Error] Loading shader "+s2+" failed (exiting...)" << std::endl;
return false;
}
if(!compileShader(so[1])){
std::cerr << "[Error] Compiling shader "+s2+" failed (exiting...)" << std::endl;
return false;
}
m_nProgram = linkShaders(so,2);
glDeleteObjectARB(so[0]);
glDeleteObjectARB(so[1]);
return true;
}
