question

FyMa2618-9573 avatar image
0 Votes"
FyMa2618-9573 asked BarrySchwarz-8780 commented

C++ OpengL Error Need help!

Good day,
i try to learn OpenGl whit C++, i tried to write my first Shader but i had some Porblems and i am dont know to to fix them z.b whittype ShaderType usw.(I put my Code down bellow).
thanks in advance.


 #include <GL/glew.h>
 #include <GLFW/glfw3.h>
 #include <iostream>
 #include <fstream>
 #include <string>
 #include <sstream>
    
 struct ShaderPogramSource
 {
     std::string VertexSource;
     std::string FragmentSource;
 };
 static ShaderPogramSource ParseShader(const std::string& filepath)
 {
    
     //(Warscheinlich) (file öffnen)wen stream .. ist, filepath string in function oben erstellt siehe oben.
     std::ifstream stream(filepath);
    
     //?
     enum class SahderTyp
     {
         NONE = -1, VERTEX = 0, FRAGMENT = 1
     };
    
     //erstellt einen stringsteream namens ss mit 2 arrays in sich, wie viele Arrays es besitzten soll
     std::stringstream ss[2];
    
     //erstellt einen String Namens Line
     std::string line;
     //(Warscheinlcih) Setzt den Standert shader typ fest bzw. keinen, NONE ist string siehe oben
     ShaderType type = ShaderType::NONE;
     //??, stream, oben erstellter string bzw. line
     while (getline(stream, line))
     {
         //(Warscheinlich) wenn string leine gefunden wird und shader enthält wenn npos gefunden ist heißt das das er es nicht gefunden hat, std bzuw. line
         if (line.find("#shader") != std::string::npos)
         {
             //(Warscheinlich) wenn in line bzw std vertex gefu´nedn wird ... wenn npos nichts gefunden, line bzw. string
             if (line.find("vertex") != std::string::npos)
                 //Setzte ShaderType zu Vertex
                 type = ShaderType::VERTEX;
                
                 //(Warscheinlich) wenn in line bzw std f´ragment gefu´nedn wird ... wenn npos nichts gefunden, line bzw. string
             else if (line.find("fragment") != std::string::npos)
                 //Setzte ShaderType zu fragment
                 type = ShaderType::FRAGMENT;
         }
         else 
         {
             //stringsream, line string
             ss[(int)type] << line << "\n";
         }
     }
    
     return { ss[0].str(), ss[1].str() };
 }
 static unsigned int CompileShader(unsigned int type, const std::string& source)
 {
     //(Warscheinlich) VertexShader erstellen, Shader Typ
     unsigned int id = glCreateShader(type);
     //(Warscheinlich)const char namens src erstellen, oben erstellter string mit Source, ?
     const char* scr = source.c_str();
     //??, Deer Shader, (Warscheinlich) Wie viel Sourcode es gibt bzw scr, der erstllte unsigned char bzw src, ??
     glShaderSource(id, 1, &scr, nullptr);
     //Shader Compielen / lesen, Der Shader selbst bzw id
     glCompileShader(id);
    
     //Create int result
     int result;
     //Error handling, Der shader selbst bzw. id, ??, Ein int name.
     glGetShaderiv(id, GL_COMPILE_STATUS, &result);
     //Prüfen ob Ergebnis falsch ist bzw. int result
     if (result == GL_FALSE)
     {
         //Ersellt einen int namens Length
         int length;
         //??, Shader bzw. Id, ?, Int length sehe oben
         glGetShaderiv(id, GL_INFO_LOG_LENGTH, &length);
         //Erstellt ein Char namens Message mit dem Int Length in sich, int Length
         char* message = (char*)alloca(length * sizeof(char));
         //(Warscheinlich) Informationen krigen, SShader bzw. id, BufferCores bzw. length, char message siehe oben
         glGetShaderInfoLog(id, length, &length, message);
         //Einen Text in die Konsole schreiben, Typ
         std::cout << "Fehler beim compilen " << (type == GL_VERTEX_SHADER ?  "vertex" : "fragment") << " shader!" << std::endl;
         //Message in die Konsole schreiben.
         std::cout << message << std::endl;
         //??, Shader bzw. id
         glDeleteShader(id);
         //return 0
         return 0;
     }
    
     //Shader returnen
     return id;
 }
 static unsigned int CreateShader(const std::string& vertexShader, const std::string& fragmentShader)
 {
     //(Warscheinlich) Pogramm erstellen
     unsigned int pogramm = glCreateProgram();
     //(Warscheinlich)((Vertex))Shader Compliemieren,  Shader Typ, Shader aus in funktion erstellten string
     unsigned int vs = CompileShader(GL_VERTEX_SHADER, vertexShader);
     //(Warscheinlich)((Fragment))Shader Compliemieren,  Shader Typ, Shader aus in funktion erstellten string
     unsigned int fs = CompileShader(GL_FRAGMENT_SHADER, fragmentShader);
    
     //(Warscheinlich) Shader anwenden, auf was es angewendet werden soll bzw. pogramm, der Shader
     glAttachShader(pogramm, vs);
     //(Warscheinlich) Shader anwenden, auf was es angewendet werden soll bzw. pogramm, der Shader
     glAttachShader(pogramm, fs);
     //(Warscheinlich) Pogramm linken, pogramm
     glLinkProgram(pogramm);
     //??, Das pogramm bzw. pogramm
     glValidateProgram(pogramm);
    
     //(warscheinlich)Shader löschen da die richtigen Shader schon auf das programm bzw. Object gelinkt sind, Der Shader
     glDeleteShader(vs);
     //(warscheinlich)Shader löschen da die richtigen Shader schon auf das programm bzw. Object gelinkt sind, Der Shader
     glDeleteShader(fs);
    
     //Pogramm ((Warscheinlich)bzw. Zeichnung) returnen
     return pogramm;
 }
 int main(void)
 {
     GLFWwindow* window;
    
    
    
     /* Initialize the library */
     if (!glfwInit())
         return -1;
    
    
     /* Create a windowed mode window and its OpenGL context */
     window = glfwCreateWindow(640, 480, "GotGames-Engine", NULL, NULL);
     if (!window)
     {
         glfwTerminate();
         return -1;
     }
    
    
     /* Make the window's context current */
     glfwMakeContextCurrent(window);
    
     //Auf fehler überprüfen
     if (glewInit() != GLEW_OK)
         //wen ja schreibe in Konsole ...
         std::cout << "error Noobs!" << std::endl;
    
     //Print Version in Console
     std::cout << glGetString(GL_VERSION) << std::endl;
    
     //Position für ein Buffer, Wie viele in []
     float position[6] =  {
         //X    //Y
         -0.5f, -0.5f, //2Floats per Vertex x/y position //2D system
          0.0f, 0.5f,
          0.5f, -0.5f
     };
    
     //Buffer erstellen (ID)
     unsigned int buffer;
     //Buffer generienren, Wie viele Buffer generiert werden sollen, Buffer(unsigned int festlegen)
     glGenBuffers(1, &buffer);
     //Buffer festlgeen, (Vermutlich)Typ, Buffer auswählen
     glBindBuffer(GL_ARRAY_BUFFER, buffer);
     //Daten festlgen, (Vermutlich)Typ, Nummer die in den Float Position festgelegt habe., Formation (Position)
     glBufferData(GL_ARRAY_BUFFER, 6 * sizeof(float), position, GL_STATIC_DRAW);
        
    
     //Vertex activieren, Index
     glEnableVertexAttribArray(0);
     //??,Index, Vertexes, Type, ??, stride, pointers
     glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);
    
     ShaderPogramSource source = ParseShader("res/shaders/basic.shader");
     std::cout << "VERTEX" << std::endl;
     std::cout << source.VertexSource << std::endl;
     std::cout << "FRAGMENT" << std::endl;
     std::cout << source.FragmentSource << std::endl;
    
     //Shader namens Schadesr erstellen, vertexShader string siehe oben, fragment shader string siehe oben
    //// unsigned int shader = CreateShader(vertexShader, fragmentShader);
     //??, Ahder siehe oben
    //// glUseProgram(shader);
    
    
     /* Loop until the user closes the window */
     while (!glfwWindowShouldClose(window))
     {
         /* Render here */
         glClear(GL_COLOR_BUFFER_BIT);
    
         //Male, (Warscheinlcih) mit was/ was man will, Ab welchem Argument Zahl Index bzw man mit dem Malen starten will, wie viele reien bzw längen in dem float bzw buffer enthalten sind
         glDrawArrays(GL_TRIANGLES, 0, 3);
    
          /* Swap front and back buffers */
         glfwSwapBuffers(window);
    
         /* Poll for and process events */
         glfwPollEvents();
     }
     //??, shader
     //glDeleteProgram(shader);
    
     glfwTerminate();
     return 0;
 }
    
    
 //basic.shader
    
 //??
 //Shader section vertex
 #shader vertex
 #version 330 core
    
 layout (location = 0) in vec4 position;
    
 void main()
 {
    gl_Position = position;
 };
    
 //Shader section fragment
 #shader fragment
 #version 330 core
    
 layout (location = 0) out vec4 color;
    
 void main()
 {
     //color
    color = vec4(1.0, 0.0, 0.0, 1.0);
 };
 //end



c++
· 1
5 |1600 characters needed characters left characters exceeded

Up to 10 attachments (including images) can be used with a maximum of 3.0 MiB each and 30.0 MiB total.

It might help if you told us what the problems are. Provide the exact text of any error messages or a complete description of how the result differs from what you expect.

0 Votes 0 ·

0 Answers