OpenGL specular highlights drawing add high angled view - c++

Question

I try to render a big block of individual cubes in OpenGL and i'm now experimenting with lighting.
It works quite good, but when viewing the cube from a certain angle, its shows highlights with shouldn't be there.
I altered the shader so the specular highlights are red.
I just expected them to not be there because the light comes from the direction with the all bright cubes and there should be no reflections from this lightsource on the side of the cube.
Another thing which bothers me is, that there is an edge(Pic 2) where color changes. This is also something i don't quite understand and seek help with.
This is present when I use a directional lightsource and view the big cube from a certain angle.
OpenGl Version ist 3.3, i'm on Windows and using c++ with cmake to build.
Here are some images:
Github Link, because SOT does not allow me to upload code becaues "it is not formatted"(trying like 20 min to format them to SOT likes).
Edit: It works now, who could have thought that it was the formatting of the images and not actually the cpp, glsl code.
Github
Important Files: light_proto.glsl, vertex.glsl, main.cpp
Files
main.cpp
// RENDER LOOP
while (!glfwWindowShouldClose(window))
{
// INPUT
//keysboard input, mouse input
processInput(window);
defaultShader.use();
// CAMERA
// model matrix set further down, dynamically for each object
//view matrix, transform world space to camera space
glm::mat4 view = glm::lookAt(cameraPos, cameraPos + cameraFront, cameraUp);
defaultShader.setMatrix4fv("view", view);
//projection matrix, view space to device cordinates
glm::mat4 projection = glm::perspective(glm::radians(fov), 800.0f / 600.0f, 0.1f, 100.0f);
defaultShader.setMatrix4fv("projection", projection);
// DRAWING
//clear color and depth buffer
glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
////vertex data, shaders
cube->use();
defaultShader.setVec3("viewPos", cameraPos.x, cameraPos.y, cameraPos.z);
defaultShader.setVec3("material.specular", 0.0f, 1.0f, 0.0f);
defaultShader.setFloat("material.shininess", 32.0f);
defaultShader.setVec3("dirLight.direction", -1.0f, -0.0f, 0.0f);
defaultShader.setVec3("dirLight.ambient", 0.2f, 0.2f, 0.2f);
defaultShader.setVec3("dirLight.diffuse", 0.8f, 0.8f, 0.8f); // darken diffuse light a bit
defaultShader.setVec3("dirLight.specular", 1.0f, 1.0f, 1.0f);
defaultShader.setVec3("pointLights[0].position", -1.0f, -1.0f, -1.0f);
defaultShader.setVec3("pointLights[0].ambient", 0.2f, 0.2f, 0.2f);
defaultShader.setVec3("pointLights[0].diffuse", 0.8f, 0.8f, 0.8f); // darken diffuse light a bit
defaultShader.setVec3("pointLights[0].specular", 1.0f, 1.0f, 1.0f);
defaultShader.setFloat("pointLights[0].constant", 1.0f);
defaultShader.setFloat("pointLights[0].linear", 0.045f);
defaultShader.setFloat("pointLights[0].quadratic", 0.0075f);
//defaultShader.setVec3("lightColor", 1.0f, 1.0f, 1.0f);
//defaultShader.setVec3("lightPos", -1.0f, lighty, -1.0f);
//defaultShader.setVec3("viewPos", cameraPos.x, cameraPos.y, cameraPos.z);
//defaultShader.setVec3("material.specular", 0.0f, 1.0f, 0.0f);
//defaultShader.setFloat("material.shininess", 128.0f);
//defaultShader.setVec3("light.direction", -10.0f, lighty, 10.0f);
//defaultShader.setBool("light.isDirectional", false);
//defaultShader.setVec3("light.ambient", 0.2f, 0.2f, 0.2f);
//defaultShader.setVec3("light.diffuse", 0.8f, 0.8f, 0.8f); // darken diffuse light a bit
//defaultShader.setVec3("light.specular", 1.0f, 1.0f, 1.0f);
//defaultShader.setFloat("light.constant", 1.0f);
//defaultShader.setFloat("light.linear", 0.045f);
//defaultShader.setFloat("light.quadratic", 0.0075f);
int cubesize = 30;
//draw cubes
for (float i = 0.0f; i < cubesize; i++) {
for (float j = 0.0f; j < cubesize; j++) {
for (float k = 0.0f; k < cubesize; k++) {
glm::mat4 model = glm::mat4(1.0f);
model = glm::translate(model, glm::vec3(i, j, k));
defaultShader.setMatrix4fv("model", model);
glDrawArrays(GL_TRIANGLES, 0, 36);
}
}
}
//DRAW LIGHT
light->use();
lightshader.use();
lightshader.setMatrix4fv("view", view);
lightshader.setMatrix4fv("projection", projection);
glm::mat4 model = glm::mat4(1.0f);
lighty += 0.1f * deltaTime;
model = glm::translate(model, glm::vec3(-1.0, -1.0, -1.0));
lightshader.setMatrix4fv("model", model);
glDrawArrays(GL_TRIANGLES, 0, 36);
//GLFW updating the window
glfwSwapBuffers(window);
glfwPollEvents();
}
Fragment Shader
#version 330 core
in vec2 TexCoord;
in vec3 Normal;
in vec3 FragPos;
struct DirLight {
vec3 direction;
vec3 ambient;
vec3 diffuse;
vec3 specular;
};
uniform DirLight dirLight;
vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir);
struct PointLight {
vec3 position;
float constant;
float linear;
float quadratic;
vec3 ambient;
vec3 diffuse;
vec3 specular;
};
#define NR_POINT_LIGHTS 1
uniform PointLight pointLights[NR_POINT_LIGHTS];
vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir);
struct Material {
vec3 specular;
float shininess;
};
uniform Material material;
uniform sampler2D texture0;
uniform vec3 viewPos;
out vec4 FragColor;
void main()
{
// properties
vec3 norm = normalize(Normal);
vec3 viewDir = normalize(viewPos - FragPos);
// phase 1: Directional lighting
vec3 result = CalcDirLight(dirLight, norm, viewDir);
// phase 2: Point lights
for(int i = 0; i < NR_POINT_LIGHTS; i++)
//result += CalcPointLight(pointLights[i], norm, FragPos, viewDir);
FragColor = texture2D(texture0, TexCoord) * vec4(result, 1.0);
}
vec3 CalcDirLight(DirLight light, vec3 normal, vec3 viewDir)
{
vec3 lightDir = normalize(-light.direction);
// diffuse shading
float diff = max(dot(normal, lightDir), 0.0);
// specular shading
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
// combine results
vec3 ambient = light.ambient * vec3(texture(texture0, TexCoord));
vec3 diffuse = light.diffuse * diff * vec3(texture(texture0, TexCoord));
vec3 specular = light.specular * spec * vec3(1.0f, 0.0f, 0.0f);
return (ambient + diffuse + specular);
}
vec3 CalcPointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewDir)
{
vec3 lightDir = normalize(light.position - fragPos);
// diffuse shading
float diff = max(dot(normal, lightDir), 0.0);
// specular shading
vec3 reflectDir = reflect(-lightDir, normal);
float spec = pow(max(dot(viewDir, reflectDir), 0.0), material.shininess);
// attenuation
float distance = length(light.position - fragPos);
float attenuation = 1.0 / (light.constant + light.linear * distance +
light.quadratic * (distance * distance));
// combine results
vec3 ambient = light.ambient * vec3(texture(texture0, TexCoord));
vec3 diffuse = light.diffuse * diff * vec3(texture(texture0, TexCoord));
vec3 specular = light.specular * spec * vec3(1.0f, 1.0f, 1.0f);
ambient *= attenuation;
diffuse *= attenuation;
specular *= attenuation;
return (ambient + diffuse + specular);
}
Vertex Shader
#version 330 core
layout (location = 0) in vec3 aPos;
layout (location = 1) in vec2 aTexCoord;
layout (location = 2) in vec3 aNormal;
out vec2 TexCoord;
out vec3 Normal;
out vec3 FragPos;
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;
void main(){
gl_Position = projection * view * model * vec4(aPos, 1.0f);
FragPos = vec3(model * vec4(aPos, 1.0));
TexCoord = vec2(aTexCoord.x, aTexCoord.y);
Normal = aNormal;
};

Answer 1

It looks like you have one issue and a half
First in image 2 (and 3) the reason why there is a line in the diamond texture is due to texture filtering.
I checked your source code in Texture.cpp the Minification filter is set to GL_NEAREST_MIPMAP_NEAREST and you also generate the relative mipsmaps.
If you change
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_NEAREST);
to
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
at line 23 of Texture.cpp and remove
glGenerateMipmap(GL_TEXTURE_2D);
the line should disapper
I do not understand where the problem stands with the red specular light, if you could show the source of the light direction i think might be able to help