Esempio n. 1
0
void GLProgram::recover()
{
	m_vertexShader = loadAndCompileShader(m_vShader, GL_VERTEX_SHADER);
	m_fragmentShader = loadAndCompileShader(m_fShader, GL_FRAGMENT_SHADER);

	if (m_vertexShader == 0 or m_fragmentShader == 0)
	{
		return;
	}

	m_programObject = glCreateProgram();
	if (m_programObject == 0)
	{
		CHECK_GL_ERROR;
		return;
	}

	glAttachShader(m_programObject, m_vertexShader);
	glAttachShader(m_programObject, m_fragmentShader);

	for (const auto& it : m_attributes)
	{
		glBindAttribLocation(m_programObject, it.second->getPosition(), it.second->getName().c_str());
	}

	linkProgram();
}
Esempio n. 2
0
// ----------------------------------------------------------------------------
//  Create Vertex Fragment program
// ----------------------------------------------------------------------------
GLuint createVertexFragmentProgram(const std::string& vertex_shader_path,
                                   const std::string& fragment_shader_path) {
  GLuint vertShader = loadAndCompileShader(GL_VERTEX_SHADER, vertex_shader_path);
  GLuint fragShader = loadAndCompileShader(GL_FRAGMENT_SHADER, fragment_shader_path);

  GLuint program = glCreateProgram();
  if (!program) {
    throw std::runtime_error("Can't create GLSL program.");
  }

  glAttachShader(program, vertShader);
  glAttachShader(program, fragShader);
  glLinkProgram(program);

  GLint status;
  glGetProgramiv(program, GL_LINK_STATUS, &status);
  if (!status) {
    std::cerr << "Linking error in shader program!" << std::endl;
    GLint logLen;
    glGetProgramiv(program, GL_INFO_LOG_LENGTH, &logLen);
    if (logLen > 0) {
      char *log = new char[logLen];
      GLsizei written;
      glGetProgramInfoLog(program, logLen, &written, log);
      std::cerr << "Shader log: " << std::endl;
      std::cerr << log << std::endl;

      delete[] log;
    }
    throw std::runtime_error("Can't link shader program.");
  }
  return program;
}
Esempio n. 3
0
GLProgram* GLProgram::create(const char* vShader, const char* fShader)
{
	auto vertexShader = loadAndCompileShader(vShader, GL_VERTEX_SHADER);
	auto fragmentShader = loadAndCompileShader(fShader, GL_FRAGMENT_SHADER);

	if (vertexShader == 0 or fragmentShader == 0)
	{
		LOGE("Failed to load and compile shaders");
		return nullptr;
	}

	GLProgram* program = new (std::nothrow) GLProgram();
	
	if (not program)
	{
		LOGE("Failed to create GLProgram");
		return nullptr;
	}

	program->m_programObject = glCreateProgram();
	if (program->m_programObject == 0)
	{
		CHECK_GL_ERROR;

		delete program;
		LOGE("Failed to create program object");
		return nullptr;
	}

	glAttachShader(program->m_programObject, vertexShader);
	glAttachShader(program->m_programObject, fragmentShader);

	program->m_vertexShader = vertexShader;
	program->m_fragmentShader = fragmentShader;

	program->m_vShader = vShader;
	program->m_fShader = fShader;

	return program;
}
Esempio n. 4
0
static void readShader(GLuint shader, const char *filename)
{
    const int max = 100*1000;
    int n;
    char *buffer = (char*) malloc(max);
    FILE *f = fopen(filename, "r");
    if (!f) {
        fprintf(stderr, "Unable to open shader file %s\n", filename);
        exit(1);
    }

    n = fread(buffer, 1, max, f);
    printf("Read %d bytes from shader file %s\n", n, filename);
    if (n > 0) {
        buffer[n] = 0;
        loadAndCompileShader(shader, buffer);
    }

    fclose(f);
    free(buffer);
}
Esempio n. 5
0
bool
API2Test::testShaderAttribs(void)
{
	static const char *vertShaderText =
		"attribute vec4 generic; \n"
		"void main() { \n"
		"   gl_Position = ftransform(); \n"
		"   gl_FrontColor = generic; \n"
		"} \n";
	GLuint vertShader, program;

	vertShader = loadAndCompileShader(GL_VERTEX_SHADER, vertShaderText);
	if (!vertShader) {
		return false;
	}
	program = createProgram(vertShader, 0);
	if (!program) {
		REPORT_FAILURE("glCreateProgram (uniform test) failed");
		return false;
	}
	glUseProgram_func(program);

	static const GLfloat testColors[3][4] = {
		{ 1.0, 0.5, 0.25, 0.0 },
		{ 0.0, 0.1, 0.2,  0.3 },
		{ 0.5, 0.6, 0.7,  0.8 },
	};

	// let compiler allocate the attribute location
	const GLint attr = glGetAttribLocation_func(program, "generic");
	if (attr < 0) {
		REPORT_FAILURE("glGetAttribLocation failed");
		return false;
	}
	for (int i = 0; i < 3; i++) {
		GLfloat pixel[4];
		renderQuadWithArrays(attr, testColors[i], pixel);
		if (!equalColors(pixel, testColors[i])) {
#if 0
                   printf("Expected color %f %f %f\n",
                          testColors[i][0],
                          testColors[i][1],
                          testColors[i][2]);
                   printf("Found color %f %f %f\n",
                          pixel[0], pixel[1], pixel[2]);
#endif
			REPORT_FAILURE("Vertex array test failed");
			return false;
		}
	}

	// Test explicit attribute binding.
	const GLint bindAttr = 6;  // XXX a non-colliding alias
	glBindAttribLocation_func(program, bindAttr, "generic");
	glLinkProgram_func(program);
	GLint loc = glGetAttribLocation_func(program, "generic");
	if (loc != bindAttr) {
		REPORT_FAILURE("glBindAttribLocation failed");
		return false;
	}
	for (int i = 0; i < 3; i++) {
		GLfloat pixel[4];
		renderQuadWithArrays(bindAttr, testColors[i], pixel);
		if (!equalColors(pixel, testColors[i])) {
			REPORT_FAILURE("Vertex array test failed (2)");
			return false;
		}
	}

	return true;
}
Esempio n. 6
0
bool
API2Test::testUniformiFuncs(void)
{
	static const char *fragShaderText =
		"uniform int ui1; \n"
		"uniform ivec2 ui2; \n"
		"uniform ivec3 ui3; \n"
		"uniform ivec4 ui4; \n"
		"void main() { \n"
		"   gl_FragColor = vec4(ui1, ui2.y, ui3.z, ui4.w) * 0.1; \n"
		"} \n";
	GLuint fragShader, program;
	GLint ui1, ui2, ui3, ui4;

	fragShader = loadAndCompileShader(GL_FRAGMENT_SHADER, fragShaderText);
	if (!fragShader) {
		return false;
	}
	program = createProgram(0, fragShader);
	if (!program) {
		REPORT_FAILURE("glCreateProgram (uniform test) failed");
		return false;
	}
	glUseProgram_func(program);

	ui1 = glGetUniformLocation_func(program, "ui1");
	if (ui1 < 0) {
		REPORT_FAILURE("glGetUniform \"ui1\" failed");
		return false;
	}
	ui2 = glGetUniformLocation_func(program, "ui2");
	if (ui2 < 0) {
		REPORT_FAILURE("glGetUniform \"ui2\" failed");
		return false;
	}
	ui3 = glGetUniformLocation_func(program, "ui3");
	if (ui3 < 0) {
		REPORT_FAILURE("glGetUniform \"ui3\" failed");
		return false;
	}
	ui4 = glGetUniformLocation_func(program, "ui4");
	if (ui4 < 0) {
		REPORT_FAILURE("glGetUniform \"ui4\" failed");
		return false;
	}

	GLfloat pixel[4], expected[4];
	GLint expectedInt[4];

	// Test glUniform[1234]i()
	expectedInt[0] = 1;
	expectedInt[1] = 2;
	expectedInt[2] = 3;
	expectedInt[3] = 4;
	expected[0] = 0.1;
	expected[1] = 0.2;
	expected[2] = 0.3;
	expected[3] = 0.4;
	glUniform1i_func(ui1, expectedInt[0]);
	glUniform2i_func(ui2, 0, expectedInt[1]);
	glUniform3i_func(ui3, 0, 0, expectedInt[2]);
	glUniform4i_func(ui4, 0, 0, 0, expectedInt[3]);
	renderQuad(pixel);
	if (!equalColors(pixel, expected)) {
		REPORT_FAILURE("glUniform[1234]i failed");
		//printf("%f %f %f %f\n", pixel[0], pixel[1], pixel[2], pixel[3]);
		return false;
	}

	// Test glUniform[1234]iv()
	GLint u[4];
	expectedInt[0] = 9;
	expectedInt[1] = 8;
	expectedInt[2] = 7;
	expectedInt[3] = 6;
	expected[0] = 0.9;
	expected[1] = 0.8;
	expected[2] = 0.7;
	expected[3] = 0.6;
	u[0] = expectedInt[0];
	glUniform1iv_func(ui1, 1, u);
	u[0] = 0;  u[1] = expectedInt[1];
	glUniform2iv_func(ui2, 1, u);
	u[0] = 0;  u[1] = 0;  u[2] = expectedInt[2];
	glUniform3iv_func(ui3, 1, u);
	u[0] = 0;  u[1] = 0;  u[2] = 0;  u[3] = expectedInt[3];
	glUniform4iv_func(ui4, 1, u);
	renderQuad(pixel);
	if (!equalColors(pixel, expected)) {
		REPORT_FAILURE("glUniform[1234]i failed");
#if 0
		printf("Expected color %f %f %f %f\n",
                       expected[0], expected[1], expected[2], expected[3]);
		printf("Found color %f %f %f %f\n",
                       pixel[0], pixel[1], pixel[2], pixel[3]);
#endif
		return false;
	}

	return true;
}
Esempio n. 7
0
bool
API2Test::testUniformfFuncs(void)
{
	static const char *fragShaderText =
		"uniform float uf1; \n"
		"uniform vec2 uf2; \n"
		"uniform vec3 uf3; \n"
		"uniform vec4 uf4; \n"
		"void main() { \n"
		"   gl_FragColor = vec4(uf1, uf2.y, uf3.z, uf4.w); \n"
		"} \n";
	GLuint fragShader, program;
	GLint uf1, uf2, uf3, uf4;
	GLfloat value[4];

	fragShader = loadAndCompileShader(GL_FRAGMENT_SHADER, fragShaderText);
	if (!fragShader) {
		return false;
	}
	program = createProgram(0, fragShader);
	if (!program) {
		REPORT_FAILURE("glCreateProgram (uniform test) failed");
		return false;
	}
	glUseProgram_func(program);

	uf1 = glGetUniformLocation_func(program, "uf1");
	if (uf1 < 0) {
		REPORT_FAILURE("glGetUniform \"uf1\" failed");
		return false;
	}
	uf2 = glGetUniformLocation_func(program, "uf2");
	if (uf2 < 0) {
		REPORT_FAILURE("glGetUniform \"uf2\" failed");
		return false;
	}
	uf3 = glGetUniformLocation_func(program, "uf3");
	if (uf3 < 0) {
		REPORT_FAILURE("glGetUniform \"uf3\" failed");
		return false;
	}
	uf4 = glGetUniformLocation_func(program, "uf4");
	if (uf4 < 0) {
		REPORT_FAILURE("glGetUniform \"uf4\" failed");
		return false;
	}


	GLfloat pixel[4], expected[4];

	// Test glUniform[1234]f()
	expected[0] = 0.1;
	expected[1] = 0.2;
	expected[2] = 0.3;
	expected[3] = 0.4;
	glUniform1f_func(uf1, expected[0]);
	glUniform2f_func(uf2, 0.0, expected[1]);
	glUniform3f_func(uf3, 0.0, 0.0, expected[2]);
	glUniform4f_func(uf4, 0.0, 0.0, 0.0, expected[3]);
	renderQuad(pixel);
	if (!equalColors(pixel, expected)) {
		REPORT_FAILURE("glUniform[1234]f failed");
		//printf("found:    %f %f %f %f\n", pixel[0], pixel[1], pixel[2], pixel[3]);
		//printf("expected: %f %f %f %f\n", expected[0], expected[1], expected[2], expected[3]);

		return false;
	}

	// Test glUniform[1234]fv()
	GLfloat u[4];
	expected[0] = 0.9;
	expected[1] = 0.8;
	expected[2] = 0.7;
	expected[3] = 0.6;
	u[0] = expected[0];
	glUniform1fv_func(uf1, 1, u);
	u[0] = 0.0;  u[1] = expected[1];
	glUniform2fv_func(uf2, 1, u);
	u[0] = 0.0;  u[1] = 0.0;  u[2] = expected[2];
	glUniform3fv_func(uf3, 1, u);
	u[0] = 0.0;  u[1] = 0.0;  u[2] = 0.0;  u[3] = expected[3];
	glUniform4fv_func(uf4, 1, u);
	renderQuad(pixel);
	if (!equalColors(pixel, expected)) {
		REPORT_FAILURE("glUniform[1234]f failed");
		return false;
	}

	// Test glGetUniformfv
	glUniform4fv_func(uf4, 1, expected);
	glGetUniformfv_func(program, uf4, value);
	if (value[0] != expected[0] ||
	    value[1] != expected[1] ||
	    value[2] != expected[2] ||
	    value[3] != expected[3]) {
		REPORT_FAILURE("glGetUniformfv failed");
		return false;
	}

	return true;
}
Esempio n. 8
0
bool
API2Test::testShaderObjectFuncs(void)
{
	static const char *vertShaderText =
		"void main() { \n"
		"   gl_Position = ftransform(); \n"
		"} \n";
	static const char *fragShaderText =
		"void main() { \n"
		"   gl_FragColor = vec4(1.0, 0.5, 0.25, 0.0); \n"
		"} \n";
	GLuint vertShader, fragShader, program;
	GLint stat, val, err;

	vertShader = loadAndCompileShader(GL_VERTEX_SHADER, vertShaderText);
	if (!vertShader)
		return false;
	fragShader = loadAndCompileShader(GL_FRAGMENT_SHADER, fragShaderText);
	if (!fragShader)
		return false;


	program = createProgram(vertShader, fragShader);
	if (!program) {
		REPORT_FAILURE("glCreateProgram failed");
		return false;
	}
	glGetProgramiv_func(program, GL_LINK_STATUS, &stat);
	if (!stat) {
		REPORT_FAILURE("glLinkProgram failed");
		return false;
	}
	glUseProgram_func(program);

	glGetIntegerv(GL_CURRENT_PROGRAM, &val);
	if (val != (GLint) program) {
		REPORT_FAILURE("glGetInteger(GL_CURRENT_PROGRAM) failed");
		return false;
	}

        err = glGetError();
        if (err) {
		REPORT_FAILURE("OpenGL error detected in testShaderFuncs");
		return false;
	}

        if (!glIsProgram_func(program)) {
		REPORT_FAILURE("glIsProgram failed");
		return false;
	}

	GLuint objects[2];
	GLsizei count;
	glGetProgramiv_func(program, GL_ATTACHED_SHADERS, &val);
	if (val != 2) {
		REPORT_FAILURE("glGetProgramiv(GL_ATTACHED_SHADERS) failed");
		return false;
	}
	glGetAttachedShaders_func(program, 2, &count, objects);
	if (count != 2) {
		REPORT_FAILURE("glGetAttachedShaders failed (wrong count)");
		return false;
	}
	if (objects[0] != vertShader && objects[1] != vertShader) {
		REPORT_FAILURE("glGetAttachedShaders failed (vertex shader missing)");
		return false;
	}
	if (objects[0] != fragShader && objects[1] != fragShader) {
		REPORT_FAILURE("glGetAttachedShaders failed (fragment shader missing)");
		return false;
	}

	glValidateProgram_func(program);
	glGetProgramiv_func(program, GL_VALIDATE_STATUS, &stat);
	if (!stat) {
		REPORT_FAILURE("glValidateProgram failed");
		return false;
	}

	// Delete vertex shader
	glDeleteShader_func(vertShader);
	if (!glIsShader_func(vertShader)) {
		// the shader is still attached so the handle should be valid
		REPORT_FAILURE("glIsShader(deleted shader) failed");
		return false;
	}
	glGetShaderiv_func(vertShader, GL_DELETE_STATUS, &stat);
	if (stat != GL_TRUE) {
		REPORT_FAILURE("Incorrect shader delete status");
		return false;
	}

	// Delete fragment shader
	glDeleteShader_func(fragShader);

	// Delete program object
	glDeleteProgram_func(program);
	if (!glIsProgram_func(program)) {
		// the program is still in use so the handle should be valid
		REPORT_FAILURE("glIsProgram(deleted program) failed");
		return false;
	}
	glGetProgramiv_func(program, GL_DELETE_STATUS, &stat);
	if (stat != GL_TRUE) {
		REPORT_FAILURE("Incorrect program delete status");
		return false;
	}

	// now unbind the program
	glUseProgram_func(0);
	stat = glIsProgram_func(program);
	if (stat) {
		// the program and handle should have really been deleted now
		REPORT_FAILURE("glIsProgram(deleted program) failed");
		return false;
	}

	glGetProgramiv_func(program, GL_DELETE_STATUS, &stat);
	err = glGetError();
	if (!err) {
		// the program and handle should have been deleted now
		// so glGetProgramiv() should have generated an error
		REPORT_FAILURE("glGetProgramiv(deleted program) failed");
		return false;
	}

	return true;
}