Example #1
0
bool GLSLProgram::compileAndLinkShaders(const char* vertexShaderFile, const char* fragmentShaderFile) {
    const char* vertexSrc = readShaderFromFile(vertexShaderFile);
    const char* fragSrc = readShaderFromFile(fragmentShaderFile);
    int isCompiledVS, isCompiledFS, maxLength, isLinked;
    GLint shader = glCreateProgram();

    int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, (const GLchar**) &vertexSrc, 0);
    glCompileShader(vertexShader);
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &isCompiledVS);
    if (!isCompiledVS) {
        glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &maxLength);
        char* vertexInfoLog = new char[maxLength];

        glGetShaderInfoLog(vertexShader, maxLength, &maxLength, vertexInfoLog);
        printf("vertex shader: compile error: ");
        printf("%s", vertexInfoLog);
        delete[] vertexInfoLog;
        return false;
    }

    // compile the fragment shader
    int fragShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragShader, 1, (const GLchar**) &fragSrc, 0);
    glCompileShader(fragShader);
    glGetShaderiv(fragShader, GL_COMPILE_STATUS, &isCompiledFS);
    if (!isCompiledFS) {
        glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &maxLength);
        char* fragInfoLog = new char[maxLength];

        glGetShaderInfoLog(fragShader, maxLength, &maxLength, fragInfoLog);
        printf("fragment shader: compile error: ");
        printf("%s", fragInfoLog);
        delete[] fragInfoLog;
        return false;
    }

    // attach and link the shaders to the program
    glAttachShader(shader, vertexShader);
    glAttachShader(shader, fragShader);

    glLinkProgram(shader);
    glGetProgramiv(shader, GL_LINK_STATUS, (int*) &isLinked);
    if (!isLinked) {
        glGetProgramiv(shader, GL_INFO_LOG_LENGTH, &maxLength);

        char* infoLog = new char[maxLength];

        glGetProgramInfoLog(shader, maxLength, &maxLength,
                            infoLog);
        fprintf(stdout, "shader: link error: ");
        printf("%s", infoLog);
        delete[] infoLog;
        return false;
    }

    mHandle = shader;

    return true;
}
void Shader::loadShaders(std::string vertexFile, std::string fragmentFile)
{
	// Create full relative pathes
	std::string vertexPath = SHADER_PATH + vertexFile;
	std::string fragmentPath = SHADER_PATH + fragmentFile;

	// If already initialized, delete old program
	if(programInitialized)
	{
		glDeleteShader(vertexHandle);
		glDeleteShader(fragmentHandle);
		glDeleteProgram(programHandle);
	}

	// Load data for vertex shader
	vertexHandle = glCreateShader(GL_VERTEX_SHADER);
	readShaderFromFile(vertexPath, vertexHandle);

	// Load data for fragment shader
	fragmentHandle = glCreateShader(GL_FRAGMENT_SHADER);
	readShaderFromFile(fragmentPath, fragmentHandle);

	// Bind shaders
	programHandle = glCreateProgram();
	glAttachShader(programHandle, vertexHandle);
	glAttachShader(programHandle, fragmentHandle);
	glLinkProgram(programHandle);

	// Set program as initialized
	programInitialized = GL_TRUE;

	// Reset counter
	textureSlotCounter = 0;
}
Example #3
0
void initGL() {
	// The image is displayed in the window by using two simple primitives(triangles)
	// that we map to a texture. The texture will contain the colors we get from our raytracing.

	glewInit();

	// Create an array for holding the vertex positions of our two triangles
	float positions[] = {
		1.0f,    -1.0f, 0.0f,
		1.0f,	  1.0f, 0.0f,
		-1.0f,	 -1.0f, 0.0f,
		-1.0f,	  1.0f, 0.0f
	};

	//Create a buffer for holding our triangle vertex positions
	GLuint positionBuffer;
	glGenBuffers(1, &positionBuffer);
	glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
	glBufferData(GL_ARRAY_BUFFER, sizeof(positions), positions, GL_STATIC_DRAW);

	//Create a vertex array object
	glGenVertexArrays(1, &vertexArrayObject);
	glBindVertexArray(vertexArrayObject);
	glBindBuffer(GL_ARRAY_BUFFER, positionBuffer);
	glVertexAttribPointer(0, 3, GL_FLOAT, false, 0, 0);
	glEnableVertexAttribArray(0);

	//TODO: Init vertex/fragment shaders
	GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
	GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);

	std::string vertShaderString = readShaderFromFile("simple.vert");
	std::string fragShaderString = readShaderFromFile("simple.frag");
	const char *vertShaderChars = vertShaderString.c_str();
	const char *fragShaderChars = fragShaderString.c_str();

	glShaderSource(vertexShader, 1, &vertShaderChars, NULL);
	glShaderSource(fragmentShader, 1, &fragShaderChars, NULL);

	compileShader(vertexShader);
	compileShader(fragmentShader);

	defShaderProgram = glCreateProgram();
	glAttachShader(defShaderProgram, vertexShader);
	glAttachShader(defShaderProgram, fragmentShader);

	// Might be counterintuitive to delete the shaders here but they live on in our shaderprogram
	// so basically we just free up some unused memory.
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);

	glBindAttribLocation(defShaderProgram, 0, "position");

	glLinkProgram(defShaderProgram);

	GLint programIsLinked;
	glGetProgramiv(defShaderProgram, GL_LINK_STATUS, &programIsLinked);
	if (!programIsLinked) {
		std::cout << "Error when linking default shader program\n";
	}

	//TODO: Init texture to hold tracing results(image)
	//TODO: 
}