목표
- OpenGL 내에서 디버깅하기
공부 내용
- OpenGL 내에서 에러가 발생하거나 코드를 잘못 작성한 경우, 친절한 에러 메시지보다는 그저 검은 화면을 볼 가능성이 높다.
- 그래서 디버깅을 하려면, OpenGL에서 제공하는 몇몇 메소드와 매크로를 활용해야 한다.
-
glGetError
- 에러가 발생한 경우 에러 플래그를 리턴한다.
return GLenum |
에러 플래그 - GL_NO_ERROR - GL_INVALID_ENUM - GL_INVALID_VALUE - GL_INVALID_OPERATION - GL_INVALID_FRAMEBUFFER_OPERATION - GL_OUT_OF_MEMORY - GL_STACK_UNDERFLOW - GL_STACK_OVERFLOW |
에러 핸들링을 위한 메소드 작성
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
/// <summary>
/// 해당 지점까지 발생한 에러 메시지를 모두 비워준다.
/// </summary>
static void GLClearError()
{
while (glGetError() != GL_NO_ERROR);
}
/// <summary>
/// 해당 지점까지 발생한 에러 메시지를 출력한다.
/// </summary>
static void GLCheckError()
{
while (GLenum error = glGetError())
{
string errStr = "";
switch (error)
{
case GL_NO_ERROR: errStr = "No Errors"; break;
case GL_INVALID_ENUM: errStr = "Invalid Enum"; break;
case GL_INVALID_VALUE: errStr = "Invalid Value"; break;
case GL_INVALID_OPERATION: errStr = "Invalid Operation"; break;
case GL_INVALID_FRAMEBUFFER_OPERATION: errStr = "Invalid Framebuffer Operation"; break;
case GL_OUT_OF_MEMORY: errStr = "Out of Memory"; break;
case GL_STACK_UNDERFLOW: errStr = "Stack Underflow"; break;
case GL_STACK_OVERFLOW: errStr = "Stack Overflow"; break;
default: errStr = "Unknown"; break;
}
cout << "[OpenGL Error] - " << errStr << endl;
}
}
- 디버깅을 할 부분의 상단에 GLClearError();, 하단에 GLCheckError()를 호출하여 에러를 확인할 수 있다.
1
2
3
GLClearError();
glDrawElements(GL_TRIANGLES, 6, GL_INT, nullptr); // error
GLCheckError();
-
대신 루프 내내 에러 메시지가 출력되며, 에러를 확인할 부분마다 위아래에 Clear, Check로 감싸줘야 된다는 단점이 있다.
-
따라서 아래처럼 수정한다.
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
// x가 false인 경우 브레이크 포인트를 걸고 중단한다.
#define ASSERT(x) if(!(x)) __debugbreak();
// 해당 부분의 에러를 검사하여, 에러 발생 시 정보를 출력한다.
#define GLCheck(x) GLClearError();\
x;\
ASSERT(GLCheckError(#x, __FILE__, __LINE__))
/// <summary>
/// 해당 지점까지 발생한 에러 메시지를 모두 비워준다.
/// </summary>
static void GLClearError()
{
while (glGetError() != GL_NO_ERROR);
}
/// <summary>
/// 해당 지점에서 발생한 에러 메시지와 메타 정보를 출력한다.
/// </summary>
static bool GLCheckError(const char* function, const char* file, int line)
{
while (GLenum error = glGetError())
{
string errStr = "";
switch (error)
{
case GL_NO_ERROR: errStr = "No Errors"; break;
case GL_INVALID_ENUM: errStr = "Invalid Enum"; break;
case GL_INVALID_VALUE: errStr = "Invalid Value"; break;
case GL_INVALID_OPERATION: errStr = "Invalid Operation"; break;
case GL_INVALID_FRAMEBUFFER_OPERATION: errStr = "Invalid Framebuffer Operation"; break;
case GL_OUT_OF_MEMORY: errStr = "Out of Memory"; break;
case GL_STACK_UNDERFLOW: errStr = "Stack Underflow"; break;
case GL_STACK_OVERFLOW: errStr = "Stack Overflow"; break;
default: errStr = "Unknown"; break;
}
cout << "[OpenGL Error] - " << errStr << endl
<< "Code : " << function << endl
<< "Line : " << file << " : " << line << endl;
return false;
}
return true;
}
- 이제 에러를 확인하고 싶은 부분에
1
GLCheck(glDrawElements(GL_TRIANGLES, 6, GL_INT, nullptr));
- 이렇게 GLCheck( )으로 감싸기만 하면 에러가 있을 경우 자동으로 중단점을 걸고 에러 내용, 에러가 발생한 위치 정보, 소스 코드 내용까지 출력하게 된다.
- 응용하여 아래처럼 소스 코드 여러 부분을 묶어 체크할 수도 있고,
- 모든 라인을 각각 체크할 수도 있다.
Source Code
Basic.shader
#shader vertex
#version 330 core
layout(location = 0) in vec4 position;
void main()
{
gl_Position = position;
};
#shader fragment
#version 330 core
layout(location = 0) out vec4 color;
void main()
{
color = vec4(0.2, 0.3, 0.8, 1.0);
};
ErrorHandler.hpp
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
#pragma once
// x가 false인 경우 브레이크 포인트를 걸고 중단한다.
#define ASSERT(x) if(!(x)) __debugbreak();
// 해당 부분의 에러를 검사하여, 에러 발생 시 정보를 출력한다.
#define GLCheck(x) GLClearError();\
x;\
ASSERT(GLCheckError(#x, __FILE__, __LINE__))
/// <summary>
/// 해당 지점까지 발생한 에러 메시지를 모두 비워준다.
/// </summary>
static void GLClearError()
{
while (glGetError() != GL_NO_ERROR);
}
/// <summary>
/// 해당 지점에서 발생한 에러 메시지와 메타 정보를 출력한다.
/// </summary>
static bool GLCheckError(const char* function, const char* file, int line)
{
while (GLenum error = glGetError())
{
string errStr = "";
switch (error)
{
case GL_NO_ERROR: errStr = "No Errors"; break;
case GL_INVALID_ENUM: errStr = "Invalid Enum"; break;
case GL_INVALID_VALUE: errStr = "Invalid Value"; break;
case GL_INVALID_OPERATION: errStr = "Invalid Operation"; break;
case GL_INVALID_FRAMEBUFFER_OPERATION: errStr = "Invalid Framebuffer Operation"; break;
case GL_OUT_OF_MEMORY: errStr = "Out of Memory"; break;
case GL_STACK_UNDERFLOW: errStr = "Stack Underflow"; break;
case GL_STACK_OVERFLOW: errStr = "Stack Overflow"; break;
default: errStr = "Unknown"; break;
}
cout << "[OpenGL Error] - " << errStr << endl
<< "Code : " << function << endl
<< "Line : " << file << " : " << line << endl << endl;
return false;
}
return true;
}
CustomFunctions.hpp
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
#pragma once
struct ShaderProgramSource
{
string VertexSource;
string FragmentSource;
};
/// <summary>
/// 쉐이더 파일을 읽어서 버텍스, 프래그먼트 쉐이더 스트링 가져오기
/// </summary>
/// <param name="filePath">쉐이더 파일 경로</param>
/// <returns>ShaderProgramSource { Vertex, Fragment }</returns>
static ShaderProgramSource ParseShader(const string& filePath)
{
enum class ShaderType
{
NONE = -1, VERTEX = 0, FRAGMENT = 1
};
ifstream stream(filePath);
string line;
stringstream ss[2];
ShaderType type = ShaderType::NONE;
// 스트림에서 한 줄씩 읽어오기
while (getline(stream, line))
{
// #shader 라인을 통해 버텍스, 프래그먼트 쉐이더 시작점 인식
if (line.find("#shader") != string::npos)
{
if (line.find("vertex") != string::npos)
{
type = ShaderType::VERTEX;
}
else if (line.find("fragment") != string::npos)
{
type = ShaderType::FRAGMENT;
}
}
// #shader가 없는 부분에서는 스트링 스트림에 라인 추가
else
{
ss[(int)type] << line << '\n';
}
}
return { ss[0].str(), ss[1].str() };
}
/// <summary>
/// 쉐이더 소스 코드를 입력받아 쉐이더 객체 생성하고 컴파일
/// </summary>
/// <param name="source">쉐이더 소스 코드</param>
/// <param name="type">GL_VERTEX_SHADER 또는 GL_FRAGMENT_SHADER</param>
/// <returns>컴파일된 쉐이더 객체의 ID 또는 0(에러)</returns>
static GLuint CompileShader(GLenum type, const string& source)
{
// 빈 쉐이더 객체 생성
GLuint shaderID = glCreateShader(type);
const char* src = source.c_str();
// 쉐이더 코드를 쉐이더 객체로 변환하여 위의 쉐이더 객체 id에 바인딩
glShaderSource(shaderID, 1, &src, nullptr);
// 쉐이더 컴파일
glCompileShader(shaderID);
// 쉐이더 컴파일 결과 검증
GLint result;
glGetShaderiv(shaderID, GL_COMPILE_STATUS, &result);
// 컴파일이 실패한 경우
if (result == GL_FALSE)
{
int length;
// 로그의 길이값을 length에 받아오기
glGetShaderiv(shaderID, GL_INFO_LOG_LENGTH, &length);
// 스택에 배열 동적 할당
char* message = (char*)_malloca(length * sizeof(char));
// 로그 메시지 받아오기
glGetShaderInfoLog(shaderID, length, &length, message);
// 에러 메시지 출력
cout << "Failed to Compile "
<< ((type == GL_VERTEX_SHADER) ? "Vertex" : "Fragment")
<< " Shader"
<< endl;
cout << "\nError Message :" << endl;
cout << message << endl;
// 쉐이더 메모리 해제
glDeleteShader(shaderID);
_freea(message);
return 0;
}
return shaderID;
}
/// <summary>
/// 프로그램, 쉐이더 객체 생성
/// </summary>
/// <param name="vertexShader">버텍스 쉐이더 소스 코드</param>
/// <param name="fragmentShader">프래그먼트 쉐이더 소스 코드</param>
/// <returns>생성된 프로그램 객체의 ID</returns>
static GLuint CreateShader(const string& vertexShader, const string& fragmentShader)
{
// 빈 프로그램 객체 생성
GLuint programID = glCreateProgram();
// 쉐이더 컴파일
GLuint vs = CompileShader(GL_VERTEX_SHADER, vertexShader);
GLuint fs = CompileShader(GL_FRAGMENT_SHADER, fragmentShader);
// 프로그램에 쉐이더 장착, 프로그램 링킹, 검증
glAttachShader(programID, vs);
glAttachShader(programID, fs);
glLinkProgram(programID);
glValidateProgram(programID);
// 쉐이더 메모리 해제
glDeleteShader(vs);
glDeleteShader(fs);
return programID;
}
Application.cpp
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
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
using namespace std;
#include "ErrorHandler.hpp"
#include "CustomFunctions.hpp"
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, "Hello World", NULL, NULL);
if (!window)
{
glfwTerminate();
return -1;
}
/* Make the window's context current */
glfwMakeContextCurrent(window);
// glewInit은 rendering context를 만들고 난 이후에 해야 함
if (glewInit() != GLEW_OK)
{
cout << "GLEW INIT ERROR" << endl;
}
// 간단히 GLEW 버전 확인
cout << glGetString(GL_VERSION) << endl;
/******************************************************************
* VBO - Vertex Position *
******************************************************************/
// Vertex Attribute : 위치 데이터
float positions[] =
{
-0.5f, -0.5f, // 0
0.5f, -0.5f, // 1
0.5f, 0.5f, // 2
-0.5f, 0.5f, // 3
};
// VBO(Vertex Buffer Object) ID 생성
GLuint vbo;
// VBO 객체 생성
glGenBuffers(1, &vbo);
// VBO 타입 바인딩
glBindBuffer(GL_ARRAY_BUFFER, vbo);
// VBO에 위치 데이터 연결
glBufferData(GL_ARRAY_BUFFER, sizeof(positions), positions, GL_STATIC_DRAW);
// 정점 속성 정의
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 2, 0);
// 정점 속성 활성화
glEnableVertexAttribArray(0);
/******************************************************************
* IBO - Vertex Indices *
******************************************************************/
// Index Data
GLuint indices[] =
{
0, 1, 2,
0, 2, 3
};
// Index Buffer Object 생성, 바인딩, 데이터 연결
GLuint ibo;
glGenBuffers(1, &ibo);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
/******************************************************************
* Shader *
******************************************************************/
// 쉐이더 파일 읽어오기
ShaderProgramSource source = ParseShader("Resources/Shaders/Basic.shader");
string vertexShader = source.VertexSource;
string fragmentShader = source.FragmentSource;
cout << "\nVERTEX\n" + vertexShader +
"\nFRAGMENT\n" + fragmentShader << endl;
// 쉐이더 객체 생성 및 컴파일, 프로그램 객체 생성
GLuint shaderProgram = CreateShader(vertexShader, fragmentShader);
// 쉐이더 프로그램 객체 사용
glUseProgram(shaderProgram);
/******************************************************************
* Loop *
******************************************************************/
while (!glfwWindowShouldClose(window))
{
/* Render here */
GLCheck(glClear(GL_COLOR_BUFFER_BIT);)
// 폴리곤 그리기
//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, nullptr);
GLCheck(glDrawElements(GL_TRIANGLES, 6, GL_INT, nullptr);)
/* Swap front and back buffers */
GLCheck(glfwSwapBuffers(window);)
/* Poll for and process events */
GLCheck(glfwPollEvents();)
}
// 프로그램 객체 메모리 해제
glDeleteProgram(shaderProgram);
glfwTerminate();
return 0;
}