Hypercell ein ] Hypercell aus ] Zeige Navigation ] Verstecke Navigation ]
c++.net  
   

Die mobilen Seiten von c++.net:
https://m.c-plusplus.net

  
C++ Forum :: Spiele-/Grafikprogrammierung ::  [GELOEST]OpenGL: Seltsamer Fragment Shader-Kompilierfehler     Zeige alle Beiträge auf einer Seite Auf Beitrag antworten
Autor Nachricht
Unregistrierter





Beitrag Unregistrierter 04:56:05 15.07.2017   Titel:   [GELOEST]OpenGL: Seltsamer Fragment Shader-Kompilierfehler            Zitieren

C++:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
#include <glad/glad.h>
#define GLFW_DLL
#include <GLFW\glfw3.h>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstdarg>
#include <string>
#include <iostream>
 
// TODO: split source code for better readability
 
class FileManager {
public:
    FileManager(const char* fileName) {
        this->fileName = fileName;
    }
    ~FileManager() {
        fclose(this->fileHandle);
    }
protected:
    const char* fileName;
    FILE* fileHandle;
    void rewriteToFile(const char* inputData) {
        this->accessFile("w+");
        fprintf(this->fileHandle, inputData);
        fclose(this->fileHandle);
        return;
    }
    void writeToFile(const char* inputData) {
        this->accessFile("a+");
        fprintf(this->fileHandle, inputData);
        fclose(this->fileHandle);
        return;
    }
private:
    void accessFile(const char* fileAccessMode) {
        this->fileHandle = nullptr;
        fopen_s(&(this->fileHandle), this->fileName, fileAccessMode);
        if (nullptr == this->fileHandle) {
            fprintf(stderr, "ERROR: Failed to access file\n");
            return;
        }
        return;
    }
};
 
class LogFileManager : FileManager {
public:
    LogFileManager(const char* logFileName) : FileManager(logFileName) {
    }
    void generateLogFile(const char* message) {
        time_t currentTime = time(nullptr);
        char currentDate[26];
        ctime_s(currentDate, sizeof(currentDate), &currentTime);
        // TODO: Bad code fix (double file access => slow)
        this->rewriteToFile(currentDate);
        this->writeToFile(message);
        return;
    }
private:
};
 
int main() {
   
    // Initialize GLFW
    if (GLFW_FALSE == glfwInit()) {
        fprintf(stderr, "ERROR: Failed to initialize GLFW3\n");
        return EXIT_FAILURE;
    }
    // Create window
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
    GLFWwindow* window = glfwCreateWindow(640, 480, "OpenGL Game", nullptr, nullptr);
    if (nullptr == window) {
        fprintf(stderr, "ERROR: Failed to create window with GLFW3\n");
        glfwTerminate();
        return EXIT_FAILURE;
    }
    glfwMakeContextCurrent(window);
    // Load all OpenGL function pointers.
    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
        fprintf(stderr, "ERROR: Failed to initialize GLAD\n");
        return EXIT_FAILURE;
    }
    // Get info from renderer
    const GLubyte* renderer = glGetString(GL_RENDERER);
    const GLubyte* version = glGetString(GL_VERSION);
    fprintf(stdout, "Renderer: %s\nOpenGL version supported: %s\n", renderer, version);
    // Enable depth
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    // Put defining code here
    // Define triangle
    GLfloat points[] = {0.0f, 0.5f, 0.0f,
                        0.5f, -0.5f, 0.0f,
                        -0.5f, -0.5f, 0.0f};
    // Create buffer object
    GLuint vbo = 0;
    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, sizeof(points), points, GL_STATIC_DRAW);
    // Create vertex attribute object
    GLuint vao = 0;
    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
    // Shader definitions
    const char* vertexShaderSource =
                                "#version 330\n"
                                "in vec3 coordinates3d\n"
                                "void main() {\n"
                                "    glPosition(coordinates3d.x, coordinates3d.y, coordinates3d.z, 1.0f);\n"
                                "}";
    const char* fragmentShaderSource =
                                "#version 330\n"
                                "out vec4 fragmentColor\n"
                                "void main() {\n"
                                "    fragmentColor = vec4(0.5f, 0.0f, 0.0f, 1.0f);\n"
                                "}";
    // Create and compile shaders
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, nullptr);
    glCompileShader(vertexShader);
    // Check if the vertex shader got compile errors
    LogFileManager logFileManager("log.txt");
    int success = 0;
    char message[512] = {};
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(vertexShader, 512, nullptr, message);
        // TODO: Specify error type in message
        logFileManager.generateLogFile(message);
    }
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, nullptr);
    glCompileShader(fragmentShader);
    // Check if the fragment shader got compile errors
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(fragmentShader, 512, nullptr, message);
        // TODO: Specify error type in message
        logFileManager.generateLogFile(message);
    }
    // Create shader program and link it
    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    // Check for linking errors
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(shaderProgram, 512, nullptr, message);
        // TODO: Specify error type in message
        logFileManager.generateLogFile(message);
    }
    // Render loop
    while (!glfwWindowShouldClose(window)) {
        // Wipe the drawing surface clear
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        // Use shader program and vertex attribute object
        glUseProgram(shaderProgram);
        glBindVertexArray(vao);
        // Draw from the currently bound vertex attribute object
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glfwPollEvents();
        glfwSwapBuffers(window);
    }
    // Exit program
    glfwTerminate();
    return EXIT_SUCCESS;
}


Ich erwarte ein rotes Dreieck als Bildschirmausgabe, da laut Zeile 122, die Fragmente rot gefaerbt sein muessen.
Aber ich bekomme ein weisses Dreieck, da es offenbar laut erzeugter Logdatei einen Syntax-Fehler bei der Kompilerung des Fragment-Shaders gibt:

Zitat:
...
ERROR: 0:3: 'void' : syntax error syntax error


Der Fragment-Shader (ab Zeile 119) ist eigentlich in Ordnung, trotzdem bekomme ich einen Kompilierfehler. :confused:


Zuletzt bearbeitet von Unregistrierter am 15:01:01 15.07.2017, insgesamt 1-mal bearbeitet
Biolunar
Moderator

Benutzerprofil
Anmeldungsdatum: 16.02.2010
Beiträge: 517
Beitrag Biolunar Moderator 08:28:36 15.07.2017   Titel:              Zitieren

Es fehlen die Semikolons nach den Deklarationen in beiden Shadern:
"in vec3 coordinates3d;\n" und "out vec4 fragmentColor;\n".

Du prüfst auch fast keine GL Funktion auf Erfolg. Die Fehler würden sonst sofort in Zeilen 125 und 138 sofort auffallen.
C++ Forum :: Spiele-/Grafikprogrammierung ::  [GELOEST]OpenGL: Seltsamer Fragment Shader-Kompilierfehler   Auf Beitrag antworten

Zeige alle Beiträge auf einer Seite




Nächstes Thema anzeigen
Vorheriges Thema anzeigen
Sie können Beiträge in dieses Forum schreiben.
Sie können auf Beiträge in diesem Forum antworten.
Sie können Ihre Beiträge in diesem Forum nicht bearbeiten.
Sie können Ihre Beiträge in diesem Forum nicht löschen.
Sie können an Umfragen in diesem Forum nicht mitmachen.

Powered by phpBB © 2001, 2002 phpBB Group :: FI Theme

c++.net ist Teilnehmer des Partnerprogramms von Amazon Europe S.à.r.l. und Partner des Werbeprogramms, das zur Bereitstellung eines Mediums für Websites konzipiert wurde, mittels dessen durch die Platzierung von Werbeanzeigen und Links zu amazon.de Werbekostenerstattung verdient werden kann.

Die Vervielfältigung der auf den Seiten www.c-plusplus.de, www.c-plusplus.info und www.c-plusplus.net enthaltenen Informationen ohne eine schriftliche Genehmigung des Seitenbetreibers ist untersagt (vgl. §4 Urheberrechtsgesetz). Die Nutzung und Änderung der vorgestellten Strukturen und Verfahren in privaten und kommerziellen Softwareanwendungen ist ausdrücklich erlaubt, soweit keine Rechte Dritter verletzt werden. Der Seitenbetreiber übernimmt keine Gewähr für die Funktion einzelner Beiträge oder Programmfragmente, insbesondere übernimmt er keine Haftung für eventuelle aus dem Gebrauch entstehenden Folgeschäden.