GLSL Error: (0) : error C5145: must write to gl_Position - c++

When I go to link my compiled vertex and fragment shaders, I get this error:
(0) : error C5145: must write to gl_Position
Here is the basic section of my code where the error occurs:
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(GL_VERTEX_SHADER, 1, &vertexShaderCode, nullptr);
glCompileShader(GL_VERTEX_SHADER);
GLint okay;
glGetShaderiv(GL_VERTEX_SHADER, GL_COMPILE_STATUS, &okay);
if (okay == GL_FALSE) {
char infoLog[512];
glGetShaderInfoLog(GL_VERTEX_SHADER, 512, nullptr, infoLog);
error("Failed to compile vertex shader.", infoLog);
}
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(GL_FRAGMENT_SHADER, 1, &fragmentShaderCode, nullptr);
glCompileShader(GL_FRAGMENT_SHADER);
glGetShaderiv(GL_FRAGMENT_SHADER, GL_COMPILE_STATUS, &okay);
if (okay == GL_FALSE) {
char infoLog[512];
glGetShaderInfoLog(GL_FRAGMENT_SHADER, 512, nullptr, infoLog);
error("Failed to compile fragment shader.", infoLog);
}
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glAttachShader(shaderProgram, fragmentShader);
glLinkProgram(shaderProgram);
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &okay);
if (okay == GL_FALSE) {
char infoLog[512];
glGetProgramInfoLog(shaderProgram, 512, nullptr, infoLog);
error("Failed to link the shader program.", infoLog);
}
glDeleteShader(vertexShader);
glDeleteShader(fragmentShader);
Here is the vertex shader:
#version 330 core
layout (location = 0) in vec3 vertexData;
layout (location = 1) in vec2 textureCoord;
out vec2 textCoord;
uniform mat4 projectionMat;
uniform mat4 viewMat;
uniform mat4 modelMat;
void main() {
gl_Position = projectionMat * viewMat * modelMat * vec4(vertexData, 1.0f);
vertColor = vertexColor;
textCoord = textureCoord;
}
Here is the fragment shader (in case it matters):
#version 330 core
in vec2 textCoord;
out vec4 color;
uniform sampler2D text;
uniform vec4 textColor;
void main() {
color = texture(text, textCoord) * textColor;
}
I did some investigating and toyed around with it and found that (unlike other people) the source I was sending to OpenGL was not empty and was the full, correct source (I found this by printing vertexShaderCode).
How do I fix it?

GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
This creates a shader object for a vertex shader. And this means that vertexShader now contains that shader object. Given that:
glShaderSource(GL_VERTEX_SHADER, 1, &vertexShaderCode, nullptr);
What does this do? It's supposed to put the given code into a shader object. But none of the parameters are a shader object. The first parameter is an OpenGL enumerator, which is not a shader object.
Shader and program objects are not like most OpenGL objects. You don't bind them just to set data into them (except for uniforms and programs, but we don't even need to bind them for that since GL 4.1). If you want to manipulate a shader, you have to actually pass the shader to the function that manipulates it.
glShaderSource(vertexShader, 1, &vertexShaderCode, nullptr);

Related

OpenGL shader does not compile but gives no error message

I am trying to write a function for loading and compiling a shader using OpenGl, but the shader refuses to compile while giving me an empty (or random) error log.
The following is my minimal example:
vertexShader = glCreateShader( GL_VERTEX_SHADER );
std::string vertexSource = ShaderLoader::load("vertexShader.vert");
const char * vertexAdress = vertexSource.c_str();
glShaderSource( vertexShader, 1, &vertexAdress, NULL );
int shaderCompiled = GL_FALSE;
char errorLog[512];
glCompileShader(vertexShader);
glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &shaderCompiled );
glGetShaderInfoLog(vertexShader, 512, nullptr, &errorLog[0]);
glDeleteShader(vertexShader);
Outputting shaderCompiled gives 0 and errorLog gives either an empty string or a few random characters.
The function ShaderLoader::load contains the following code:
std::string ShaderLoader::load(std::string source) {
std::string shader;
std::fstream readFile(source, std::ios::in);
if (readFile.is_open()){
std::stringstream buffer;
buffer << readFile.rdbuf();
shader = buffer.str() + "\0";
} else {
throw std::runtime_error( "Couldn't load shader file: " + source);
}
return shader;
}
It seems to be working as expected. The shader source code is
#version 330 core
layout (location = 0) in vec3 inVertex;
layout (location = 1) in vec3 inNormal;
out vec3 FragmentPosition;
out vec3 Normal;
uniform mat4 transform;
void main()
{
FragmentPosition = vec3(inVertex);
Normal = mat3(transpose(inverse(transform))) * inNormal;
gl_Position = transform * vec4( inVertex, 1 );
}
How can I populate errorLog with an actual error message, or even better, get the shader to compile.
First only use error logging if shaderCompiled is false so you don't get random strings,
glGetShaderiv(VS, GL_COMPILE_STATUS, &shaderCompiled);
if (!shaderCompiled)
{
//error
GLchar InfoLog[256];
glGetShaderInfoLog(vertexShader, sizeof(InfoLog), NULL, InfoLog);
Second, are you actually linking and using the shaders, the problem might not be with the compilation:
// after compilation
GLuint shaderProgram = glCreateProgram();
glAttachShader(shaderProgram, vertexShader);
glLinkProgram(shaderProgram);
glDetachShader(shaderProgram, vertexShader);
glDeleteShader(vertexShader);
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);

GLEW Vertex Shader compile error

I recently started working on Vertex and Fragment shaders in GLEW. For some reason I am getting a failed to compile shader error.
The error I am getting is as follow:
Failed to compile vertex shader: Vertex shader failed to compile with the following errors:
ERROR: 0:3 error (#12) Unexpected qualifier.
ERROR: 0:3 error(#132) Syntax error: "position" parse error
ERROR: error(#273) 2 compilation errors. No code generated.
The text document that contain the code for the shader is:
#version 330 core
layout (location = 0) in Vector4 position;
uniform Matrix pr_matrix;
uniform Matrix vw_matrix = Matrix(1, 0);
uniform Matrix ml_matrix = Matrix(1, 0);
void main()
{
gl_Position = /*pr_matrix **/ position;
}
And the code that compile the shader is:
GLuint Shader::load() {
GLuint program = glCreateProgram();
GLuint vertex = glCreateShader(GL_VERTEX_SHADER);
GLuint fragment = glCreateShader(GL_FRAGMENT_SHADER);
std::string vertexSourceString = File::read_file(mVertex);
std::string fragmentSourceString = File::read_file(mFragment);
const char* vertexSource = vertexSourceString.c_str();
const char* fragmentSource = fragmentSourceString.c_str();
glShaderSource(vertex, 1, &vertexSource, NULL);
glCompileShader(vertex);
GLint result;
glGetShaderiv(vertex, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE) {
GLint length;
glGetShaderiv(vertex, GL_INFO_LOG_LENGTH, &length);
std::vector<char> error(length);
glGetShaderInfoLog(vertex, length, &length, &error[0]);
std::cout << "Failed to compile vertex shader: " << &error[0] << std::endl;
glDeleteShader(vertex);
return 0;
}
glShaderSource(fragment, 1, &fragmentSource, NULL);
glCompileShader(fragment);
glGetShaderiv(fragment, GL_COMPILE_STATUS, &result);
if (result == GL_FALSE) {
GLint length;
glGetShaderiv(fragment, GL_INFO_LOG_LENGTH, &length);
std::vector<char> error(length);
glGetShaderInfoLog(fragment, length, &length, &error[0]);
std::cout << "Failed to compile fragment shader: " << &error[0] << std::endl;
glDeleteShader(fragment);
return 0;
}
glAttachShader(program, vertex);
glAttachShader(program, fragment);
glLinkProgram(program);
glValidateProgram(program);
glDeleteShader(vertex);
glDeleteShader(fragment);
return program;
}
I think something is wrong with the vertex, if anyone can help I will appreciate it. Thanks.
The strings Vertex4 and Matrix have no meaning for GLSL. Types in GLSL are things like vec4 and mat4

OpenGL shader linking

After following a set of OpenGL tutorials which were great but didn't let me understand the basics, I'm trying some very basic OpenGL coding with C++.
My program is supposed to read a vertex and fragment shader and draw a triangle.
I get an error when linking the shaders (I suspect the error can be tracked down to the compiling of the shader though). I know my shaders are read by my program, but any changes to them doesn't affect my error. By running:
glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &Success);
I receive the error: "Link called without any attached shader object". The programs builds, and my triangle shows, but is not affected by the shaders.
UPDATE
I no longer get the above error after fixing a mistake. I now get a complain after glCompileShader():
"Error: 0:3 'location' : syntax error parse error"
So I imagine it has to do with my shader files (will add them below). The shader files are taken from a tutorial, so I assumed they would work.
Shader files:
Vertex shader:
#version 330
layout (location = 0) in vec3 Position;
void main()
{
gl_Position = vec4(0.5*Position.x, 0.5*Position.y, Position.z, 1.0);
}
Fragment shader:
#version 330
out vec4 FragColor;
void main()
{
FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}
In my main function i run:
compileShader();
Attach shaders:
static void AddShader(GLuint ShaderProgram, GLenum ShaderType, std::string filePath){
//create shader object
GLuint ShaderObj = glCreateShader(ShaderType);
//error if no shader
if (ShaderObj == 0){
fprintf(stderr, "Error creating shader type %d\n", ShaderType);
exit(0);
}
//"specify source code"
//readShaderFile returns the shader file as a string
std::string shaderFile = readShaderFile(filePath);
const char* shaderFilePointer = shaderFile.c_str();
GLint ShaderFileLength[1];
ShaderFileLength[0] = strlen(shaderFilePointer);
glShaderSource(ShaderObj, 1, &shaderFilePointer, ShaderFileLength);
//compile the shader
glCompileShader(ShaderObj);
//check if compile successful
GLint success;
glGetShaderiv(ShaderObj, GL_COMPILE_STATUS, &success);
if (!success){
GLchar InfoLog[1024];
glGetShaderInfoLog(ShaderObj, sizeof(InfoLog), NULL, InfoLog);
fprintf(stderr, "Error compiling shader type %d: '%s'\n", ShaderType, InfoLog);
exit(1);
}
glAttachShader(ShaderProgram, ShaderObj);
}
And here are the functions used:
static void compileShaders(){
//create program
GLuint ShaderProgram = glCreateProgram();
//check error
if (ShaderProgram == 0){
fprintf(stderr, "Error creating shader program!\n");
exit(1);
}
//attach compiled shaders
std::string vertexShaderFilePath = "Shaders/colShading.vert";
std::string fragShaderFilePath = "Shaders/colShading.frag";
AddShader(ShaderProgram, GL_VERTEX_SHADER, vertexShaderFilePath);
AddShader(ShaderProgram, GL_FRAGMENT_SHADER, fragShaderFilePath);
GLint Success = 0;
GLchar ErrorLog[1024] = { 0 };
//link shader to program
glLinkProgram(ShaderProgram);
//check link error
glGetProgramiv(ShaderProgram, GL_LINK_STATUS, &Success);
if (Success == 0) {
glGetProgramInfoLog(ShaderProgram, sizeof(ErrorLog), NULL, ErrorLog);
fprintf(stderr, "Error linking shader program: '%s'\n", ErrorLog);
}
//use the linked shader program
glUseProgram(ShaderProgram);
}
I doubt more of the code is needed to find the problem here, but just let me know. Thanks a lot in advance!
SOLUTION
The first answer below did the trick. I removed:
layout (location = 0)
from the vertex shader and then added:
glBindAttribLocation(ShaderProgram, 0, "Position");
before the linking.
It seems that either your hardware or your driver doesn't support the explicit shader location syntax, which require OpenGL/GLSL > 3.3.
To solve this, if samgak's answer doesn't help, you still have two options:
Explicitly set the locations before linking the shader:
This is done with the glBindAttribLocation function, and means basically the same as what you have in your shader. Example:
AddShader(ShaderProgram, GL_VERTEX_SHADER, vertexShaderFilePath);
AddShader(ShaderProgram, GL_FRAGMENT_SHADER, fragShaderFilePath);
//...
//Define the location of the attributes
glBindAttribute(ShaderProgram, 0, "Position") //Bind "in Position" to location 0
//link shader to program
glLinkProgram(ShaderProgram);
After linking, and while building your VAOs (or drawing the geometry), query the location of the attributes, and set the buffers accordingly:
You do this with the glGetAttribLocation function.
GLuint positionLoc = glGetAttribLocation(ShaderProgram, "Position");// Ask for the location of the attribute "Position
//Create buffers and transfer data...
glBindBuffer(gl.ARRAY_BUFFER, ...);
glBufferData(...);
//Turns on the vertex attribute for "Position"
glEnableVertexAttribArray(positionLoc);
//Set the pointer between buffer and attribute
glVertexAttribPointer(positionLoc,...);
For performance reasons, the first option is recommended, as it doesn't force a flush.

C++ GLSL Linking error

I'm developing a 3d Engine and I got some trouble with the GLSL shader in C++.
Vertex shader:
layout(location = 0) in vec3 vertexUP;
layout(location = 1) in vec3 vertexUV;
out vec3 UP;
out vec3 UV;
void main(){
UP = vertexUP;//Without this line, everything works fine
UV = vertexUV;
gl_Position = ftransform();
}
Fragment shader:
in vec3 UP;
in vec3 UV;
out vec3 color;
uniform sampler2D rs0;
uniform sampler2D rs1;
uniform sampler2D rs2;
void main(){
if(UV[2]==0){//Selects between different textures
color = texture( rs0, vec2(UV[0], UV[1]) ).rgb;
}else if(UV[2]==1){
color = texture( rs1, vec2(UV[0], UV[1]) ).rgb;
}else{
color = texture( rs2, vec2(UV[0], UV[1]) ).rgb;
}
if(UP[0]<2){//Test thing
color[0] = 1.0;
}
}
I want to parse the position array (Location 0) to the fragement shader so I can use it for lighting. It Compiles but linking the vertex shader gives a error:
Vertex shader(s) failed to link, Fragment shader(s) linked.
What am I doing wrong?
EDIT:
The code to load the shaders:
GLuint LoadShaders(const char * vertex_file_path,const char * fragment_file_path){
// Create the shaders
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
// Read the Vertex Shader code from the file
std::string VertexShaderCode;
std::ifstream VertexShaderStream(vertex_file_path, std::ios::in);
if(VertexShaderStream.is_open())
{
std::string Line = "";
while(getline(VertexShaderStream, Line))
VertexShaderCode += "\n" + Line;
VertexShaderStream.close();
}
// Read the Fragment Shader code from the file
std::string FragmentShaderCode;
std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
if(FragmentShaderStream.is_open()){
std::string Line = "";
while(getline(FragmentShaderStream, Line))
FragmentShaderCode += "\n" + Line;
FragmentShaderStream.close();
}
GLint Result = GL_FALSE;
int InfoLogLength;
// Compile Vertex Shader
printf("Compiling shader : %s\n", vertex_file_path);
char const * VertexSourcePointer = VertexShaderCode.c_str();
glShaderSource(VertexShaderID, 1, &VertexSourcePointer , NULL);
glCompileShader(VertexShaderID);
// Check Vertex Shader
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
std::vector<char> VertexShaderErrorMessage(InfoLogLength);
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
fprintf(stdout, "%s\n", &VertexShaderErrorMessage[0]);
// Compile Fragment Shader
printf("Compiling shader : %s\n", fragment_file_path);
char const * FragmentSourcePointer = FragmentShaderCode.c_str();
glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer , NULL);
glCompileShader(FragmentShaderID);
// Check Fragment Shader
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
std::vector<char> FragmentShaderErrorMessage(InfoLogLength);
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
fprintf(stdout, "%s\n", &FragmentShaderErrorMessage[0]);
// Link the program
fprintf(stdout, "Linking program\n");
GLuint ProgramID = glCreateProgram();
glAttachShader(ProgramID, VertexShaderID);
glAttachShader(ProgramID, FragmentShaderID);
glLinkProgram(ProgramID);
// Check the program
glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
std::vector<char> ProgramErrorMessage(InfoLogLength);
glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
fprintf(stdout, "%s\n", &ProgramErrorMessage[0]);
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
return ProgramID;
}
You can't do that:
layout(location = 0) in vec3 vertexUP;
layout(location = 1) in vec3 vertexUV;
...
gl_Position = ftransform();
ftransform() uses the builtin gl_Vertex, and the GL spec requires that to alias attribute index 0, so the GL cannot assign the attribute indices without collision.
You really shouldn't mix the old, deprecated builtins with generic attributes. And if you do, you should led the GL assign the attribute locations.

OpenGL Mac OSX vertex shader not linking to fragment shader

I'm having problems to compile and execute a simple OpenGL application in Mac OSX 10.9. It works just fine in windows. But in Mac I keep getting some errors while linking the vertex shader to the fragment shader in the shaderProgram.
Here is my console Output.
4.1 INTEL-8.26.34
ERROR! could not link the shader program
WARNING: Output of vertex shader 'outColor' not read by fragment shader
ERROR: Input of fragment shader 'inColor' not written by vertex shader
Program ended with exit code: 0
Here is the Method that I'm using to link both together.
GLuint createShaderProgram(GLuint vertexShader, GLuint fragmentShader)
{
// Create and link the shader program
GLuint shaderProgram = glCreateProgram(); // create handle
if (!shaderProgram) {
ERROR("could not create the shader program", false);
return NULL_HANDLE;
}
glAttachShader(shaderProgram, vertexShader); // attach vertex shader
glAttachShader(shaderProgram, fragmentShader); // attach fragment shader
glLinkProgram(shaderProgram);
// check to see if the linking was successful
int linked;
glGetProgramiv(shaderProgram, GL_LINK_STATUS, &linked); // get link status
if (!linked) {
ERROR("could not link the shader program", false);
int maxLength;
int length;
glGetProgramiv(shaderProgram, GL_INFO_LOG_LENGTH, &maxLength);
char* log = new char[maxLength];
glGetProgramInfoLog(shaderProgram, maxLength,&length,log);
printf(log);
return NULL_HANDLE;
}
return shaderProgram;
}
Here is my vertexshader.
#version 410 core
layout (location = 0) in vec3 inPosition;
layout (location = 3) in vec3 inColor;
layout (location = 3) smooth out vec4 outColor;
void main()
{
gl_Position = vec4(inPosition, 1.0);
outColor = vec4(inColor, 1.0);
}
Here is the fragShader
#version 410 core
layout (location = 3) smooth in vec4 inColor;
layout (location = 0) out vec4 outColor;
void main()
{
outColor = inColor;
}
Thanks!!
the names need to match:
have the name of the output of the vertex shader match the name of the input of the fragment shader:
#version 410 core
layout (location = 0) in vec3 inPosition;
layout (location = 3) in vec3 inColor;
smooth out vec4 vertOutColor;
void main()
{
gl_Position = vec4(inPosition, 1.0);
vertOutColor = vec4(inColor, 1.0);
}
fragment shader:
#version 410 core
smooth in vec4 vertOutColor;
layout (location = 0) out vec4 outColor;
void main()
{
outColor = vertOutColor;
}