Fehler beim berechnen der Diffuse lighting



  • Hey Leute ich versuche gerade die Diffuse lightning zu realisieren,aber leider sehen alle Seiten des Würfels gleich aus,wobei sie je nach Winkel zur Lichtquelle heller oder dunkler erscheinen sollten.Ich suche schon seit 2h nach dem Fehler,wahrscheinlich wieder so ein kleiner Schusselfehler der eigentlich ganz offentsichtlich ist 😅
    Vieleicht kann mir ja einer von euch helfen,hier ist mein Code:

    Main.cpp

    
    #include<iostream>
    #include"GLEW/include/GL/glew.h"
    #include"GLFW/include/GLFW/glfw3.h"
    #include"Shader-Klasse/Shader.h"
    #include"glm/glm.hpp"
    #include"glm/gtc/matrix_transform.hpp"
    #include"glm/gtc/type_ptr.hpp"
    #include<Windows.h>
    #include "Camera-Klasse/Camera.h"
    #include<math.h>
    
    
    #define STB_IMAGE_IMPLEMENTATION
    #include"stb_image/stb_image.h"
    
    
    float vertices[] = {
    	-0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    	 0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    	 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    	 0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    	-0.5f,  0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    	-0.5f, -0.5f, -0.5f,  0.0f,  0.0f, -1.0f,
    
    	-0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
    	 0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
    	 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
    	 0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
    	-0.5f,  0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
    	-0.5f, -0.5f,  0.5f,  0.0f,  0.0f, 1.0f,
    
    	-0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
    	-0.5f,  0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
    	-0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
    	-0.5f, -0.5f, -0.5f, -1.0f,  0.0f,  0.0f,
    	-0.5f, -0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
    	-0.5f,  0.5f,  0.5f, -1.0f,  0.0f,  0.0f,
    
    	 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
    	 0.5f,  0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
    	 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
    	 0.5f, -0.5f, -0.5f,  1.0f,  0.0f,  0.0f,
    	 0.5f, -0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
    	 0.5f,  0.5f,  0.5f,  1.0f,  0.0f,  0.0f,
    
    	-0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
    	 0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
    	 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
    	 0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
    	-0.5f, -0.5f,  0.5f,  0.0f, -1.0f,  0.0f,
    	-0.5f, -0.5f, -0.5f,  0.0f, -1.0f,  0.0f,
    
    	-0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
    	 0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f,
    	 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
    	 0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
    	-0.5f,  0.5f,  0.5f,  0.0f,  1.0f,  0.0f,
    	-0.5f,  0.5f, -0.5f,  0.0f,  1.0f,  0.0f
    	};
    
    glm::vec3 LightPosition(5.0f, 4.0f, -10.0f);
    glm::vec3 LightColor(10.0f, 10.0f, 10.0f);
    glm::vec3 CubeColor(1.0f, 0.4f, 0.3f);
    
    void Scroll_Callback(GLFWwindow*, double, double);
    void WindowSize_Callback(GLFWwindow*, int, int);
    void MouseMove_Callback(GLFWwindow*, double, double);
    void KeyInput_Callback(GLFWwindow*, int, int, int, int);
    
    float deltaTime = 0;
    int WindowHeight, WindowWidth;
    Camera cam = Camera();
    
    int main() {
    
    	if (!glfwInit())
    		{
    		std::cerr << "Error::Initialize::GLFW-Library";
    		std::cin.get();
    		return -1;
    		}
    
    	GLFWmonitor* monitor = glfwGetPrimaryMonitor();
    	const GLFWvidmode* mode = glfwGetVideoMode(monitor);
    	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    	glfwWindowHint(GLFW_RED_BITS, mode->redBits);
    	glfwWindowHint(GLFW_GREEN_BITS, mode->greenBits);
    	glfwWindowHint(GLFW_BLUE_BITS, mode->blueBits);
    	glfwWindowHint(GLFW_REFRESH_RATE, mode->refreshRate);
    
    	WindowWidth = mode->width;
    	WindowHeight = mode->height;
    
    	GLFWwindow* window = glfwCreateWindow(mode->width, mode->height, "OpenGl Program", NULL, NULL);
    	if (window == NULL)
    		{
    		std::cerr << "Error::Create::Window";
    		std::cin.get();
    		glfwTerminate();
    		return -1;
    		}
    
    	glfwMakeContextCurrent(window);
    	if (glewInit())
    		{
    		std::cerr << "Error::Initialize::GLEW-Library";
    		std::cin.get();
    		glfwTerminate();
    		return -1;
    		}
    
    	glfwSwapInterval(1);
    	glfwSetScrollCallback(window, Scroll_Callback);
    	glfwSetCursorPosCallback(window, MouseMove_Callback);
    	glfwSetKeyCallback(window, KeyInput_Callback);
    	glfwSetFramebufferSizeCallback(window, WindowSize_Callback);
    	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
    
    	FreeConsole();
    
    	glEnable(GL_DEPTH_TEST);
    
    	Shader CubeShader("F:\\OpenGL\\OpenGL\\Shader\\vertexShader.vert", "F:\\OpenGL\\OpenGL\\Shader\\fragmentShader.frag");
    	Shader LightShader("F:\\OpenGL\\OpenGL\\Shader\\vertexShader2.vs", "F:\\OpenGL\\OpenGL\\Shader\\fragmentShader2.fs");
    	unsigned int VAO, VBO;
    	glGenVertexArrays(1, &VAO);
    	glGenBuffers(1, &VBO);
    
    
    	glBindVertexArray(VAO);
    
    	glBindBuffer(GL_ARRAY_BUFFER, VBO);
    	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    	
    	glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
    	glEnableVertexAttribArray(0);
    	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(sizeof(float) * 3));
    	glEnableVertexAttribArray(1);
    
    
    
    	glm::mat4 model, projection;
    
    	float lastTime = 0, FrameTime = 0;
    
    	Beep(800, 100);
    
    	CubeShader.SetVec3("lightPos", LightPosition);
    
    	while (!glfwWindowShouldClose(window))
    		{
    
    		FrameTime = glfwGetTime();
    		deltaTime = FrameTime - lastTime;
    		lastTime = FrameTime;
    
    		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    
    		model = glm::mat4(1);
    		projection = glm::mat4(1);
    
    
    		if (WindowHeight != 0)
    			projection = glm::perspective(glm::radians(cam.zoom), (float)WindowWidth / WindowHeight, 0.1f, 100.0f);
    
    		CubeShader.Use();
    		CubeShader.SetMat4("view", cam());
    		CubeShader.SetMat4("projection", projection);
    		CubeShader.SetMat4("model", model);
    		CubeShader.SetVec3("lightColor", LightColor);
    		CubeShader.SetVec3("objectColor", CubeColor);
    		glDrawArrays(GL_TRIANGLES, 0, 36);
    
    		model = glm::translate(model, LightPosition);
    		LightShader.Use();
    		LightShader.SetMat4("view", cam());
    		LightShader.SetMat4("projection", projection);
    		LightShader.SetMat4("model", model);
    		LightShader.SetVec3("LightColor", LightColor);
    		glDrawArrays(GL_TRIANGLES, 0, 36);
    
    
    		glfwPollEvents();
    		glfwSwapBuffers(window);
    		}
    
    	glDeleteBuffers(1, &VBO);
    	glDeleteVertexArrays(1, &VAO);
    
    
    	glfwTerminate();
    	return 0;
    	}
    
    
    
    void MouseMove_Callback(GLFWwindow* window, double xPos, double yPos) {
    	cam.ProcessMouseInput(xPos, yPos);
    	return;
    	}
    
    void KeyInput_Callback(GLFWwindow*window, int key, int scancode, int action, int mod) {
    	switch (key)
    		{
    			case GLFW_KEY_W:
    				{
    				cam.ProcessKeyboardInput(FORWARD, deltaTime);
    				break;
    				}
    			case GLFW_KEY_S:
    				{
    				cam.ProcessKeyboardInput(BACKWARD, deltaTime);
    				break;
    				}
    			case GLFW_KEY_D:
    				{
    				cam.ProcessKeyboardInput(RIGHT, deltaTime);
    				break;
    				}
    			case GLFW_KEY_A:
    				{
    				cam.ProcessKeyboardInput(LEFT, deltaTime);
    				break;
    				}
    			case GLFW_KEY_ESCAPE:
    				{
    				glfwSetWindowShouldClose(window, true);
    				break;
    				}
    		}
    	return;
    	}
    
    
    void WindowSize_Callback(GLFWwindow*window, int width, int height) {
    	glViewport(0, 0, width, height);
    	WindowWidth = width;
    	WindowHeight = height;
    	return;
    	}
    
    void Scroll_Callback(GLFWwindow*window, double xOffset, double yOffset) {
    	cam.ProcessScroll(yOffset);
    	return;
    	}
    
    

    VertexShader:

    #version 330 core
    
    layout(location=0) in vec3 Pos;
    layout(location=1)in vec3 aNormal;
    out vec3 Normal;
    out vec3 FragPos;
    
    uniform mat4 model;
    uniform mat4 view;
    uniform mat4 projection;
    
    
    void main(){
    gl_Position=projection*view*model*vec4(Pos,1.0f);
    FragPos=vec3(model*vec4(Pos,1.0f));
    Normal=normalize(aNormal);
    return;
    }
    

    FragmentShader:

    
    #version 330 core
    out vec4 FragColor;
      
      in vec3 Normal;
      in vec3 FragPos;
      uniform vec3 lightColor;
      uniform vec3 objectColor;
      uniform vec3 lightPos;
    
    void main()
    {
    vec3 ambiente=0.1f*lightColor;
    
    vec3 ligthDirection=normalize(lightPos-FragPos);
    float scalar=max(dot(Normal,ligthDirection),0.0f);
    vec3 diffuse=scalar*lightColor;
    
    vec3 result = (ambiente + diffuse) * objectColor;
    FragColor=vec4(result,1.0f);
    return;
    } 
    

    In diesem Bild kann man sehen wie mein Würfel aussieht(ambient)und wie er eigentlich aussehen soll(diffuse)
    Link Text

    Vielen Dank shon mal im Vorraus

    LG Thorsten



  • Deine Normals sind doch auch nur konstante Vektoren. Wieso erwartest du, das sich irgendwas ändert?



  • Falls es aus dem https://learnopengl.com/Lighting/Basic-Lighting Tutorial kommt, hatte da mal auch ein Problem.

    Wahrscheinlich liegt das Problem bei der Normalen im Vertex-Shader.

    #version 330 core
    
    layout(location = 0) in vec3 position;
    layout(location = 1) in vec3 normal;
    
    uniform mat4 model;
    uniform mat4 view;
    uniform mat4 projection;
    
    out vec3 worldnormal;
    out vec3 worldposition;
    
    
    void main()
    {
      gl_Position = projection * view * model * vec4(position, 1.0);
    
      worldposition = vec3(model * vec4(position, 1.0));
      worldnormal = vec3(model * vec4(normal, 0.0));
    }
    


  • @titan99_
    Ja ich arbeite mich gerade durch dieses Tutorial,aber leider entspricht die Ausgabe noch immer der ambient.Es hat sich nicht's verändert.(bis jetzt ist die model-Matrix im Vertex-Shader des CubeShaders auch noch eine Einheits-Matrix)
    Fällt dir sonst noch irgendetwas im Quelltext auf?



  • @Thorsten54 sagte in Fehler beim berechnen der Diffuse lighting:

    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(sizeof(float) * 3));

    Würd ich überprüfen (Bin aber nicht sicher, schreibe von Smartphone). Sollte dort nicht 3 stehen anstatt 2. Sonst funktioniert es ausser das diffuse lighting?



  • @titan99_ Ja das war noch ein Überbleibsel,da wurden vorher die Textur-Koordinaten übergeben,und ja alles außer das diffuse lightning funktioniert.Ich hab den Fragment-Shader jetzt noch einmal etwas angepasst:

    
    #version 330 core
    out vec4 FragColor;
      
      in vec3 Normal;
      in vec3 FragPos;
      uniform vec3 lightColor;
      uniform vec3 objectColor;
      uniform vec3 lightPos;
     
    
    void main()
    {
    vec3 ambiente=0.1f*lightColor;
    vec3 ligthDirection=normalize(FragPos-lightPos);
    vec3 Norm=normalize(Normal);
    float scalar=max(dot(Norm,ligthDirection),0.0f);
    vec3 diffuse=scalar*lightColor;
    vec3 result = (ambiente + diffuse) * objectColor;
    FragColor=vec4(result,1.0f);
    return;
    } 
    

    Ich habe eigentlich nur bei

    vec3 ligthDirection=normalize(FragPos-lightPos);
    

    die Argumente getauscht,sodass dot()nicht immer eine negative Zahl zurückgibt und dadurch diffuse immer 0,0,0 enthält,jetzt ist immerhin ein unterschied zum ambient zu sehen,aber jetzt wird jede Seite des Würfels kreisförmig zur Mitte hin immer heller und alle Seiten des Würfels sehen gleich aus,obwohl jede Seite in sich den gleichen Farbton haben sollte,und sich nur die unterschiedlichen Seiten des Würfels unterscheiden sollen.Ich weiß jetzt wirklich nicht mehr weiter



  • @TGGC Weil sie ja für jede Seite unterschiedlich sind,für die "vordere" Seite des Würfels sind sie zb:0,0,1;während sie für die linke Seite :-1,0,0 sind,ich hoffe du verstehst wie ich das meine.😅


  • Mod

    Gib die Werte als Farben aus und vergleiche zu dem was du erwartest, z.B. die Normalen

    void main()
    {
    FragColor=vec4(Normal*0.5+0.5,1.0f);
    } 
    


  • Ich habe den Fehler jetzt ausfindig gemacht,ich habe vergessen vor dem übergeben der LightPos an den Vertex-Shader den Shader überhaupt erst einmal zu binden.Nun funtioniert alles wie geplant.Vielen dank an alle die geholfen haben.


Log in to reply