glBegin/glEnd - были объявлены deprecated ("нерекомендуемые к использованию") в 2004 году, когда вышел OpenGL 2.0. А в 2009, когда вышел OpenGL 3.1 были полностью удалены вместе с glOrtho, glMatrixMode, glPushMatrix и т.д.
Пример, как выставить ортогональную проекцию на актуальном OpenGL 3+ с помощью функции glm::ortho математической библитеки GLM.
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
| GLfloat g_windowWidth = 200.0f;
GLfloat g_windowHeigth = 150.0f;
void initMatrices(GLuint program)
{
g_projMatrix = glm::ortho(
0.0f, g_windowWidth,
0.0f, g_windowHeigth,
-1.0f, 1.0f);
// ...
} |
|
Проект на GLUT в VS2015, можно скачать и сразу запустить, всё подлючено: DrawingLine.zip
Функция DrawLine рисует линию по двум точкам с возможностью указать цвет:
| C++ | 1
2
3
4
5
6
7
8
9
10
| void Display()
{
glClear(GL_COLOR_BUFFER_BIT);
DrawLine(Point(0.0f, 0.0f), Point(100.0f, 100.0f), Color(1.0f, 1.0f, 0.0f));
DrawLine(Point(50.0f, 10.0f), Point(190.0f, 70.0f), Color(0.0f, 1.0f, 0.0f));
DrawLine(Point(30.0f, 20.0f), Point(120.0f, 100.0f), Color(0.0f, 1.0f, 1.0f));
glutSwapBuffers();
} |
|
main.cpp
| 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
| #include <glad/glad.h>
#include <GL/freeglut.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <string>
#include <iostream>
#include "Errors.h"
#include "GLSLProgram.h"
struct Point
{
float x, y;
Point(float x, float y) :
x(x), y(y)
{
}
};
struct Color
{
float r, g, b;
Color(float r, float g, float b) :
r(r), g(g), b(b)
{
}
};
glm::mat4 g_modelMatrix;
glm::mat4 g_projMatrix;
glm::mat4 g_mpMatrix;
GLint g_uMpMatrix;
GLint g_uColor;
GLfloat g_windowWidth = 200.0f;
GLfloat g_windowHeigth = 150.0f;
void init(GLuint program);
void initMatrices(GLuint program);
void initVertexBuffers();
void DrawLine(Point p1, Point p2, Color c);
void Display();
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitContextFlags(GLUT_CORE_PROFILE | GLUT_DEBUG);
glutInitWindowSize(g_windowWidth, g_windowHeigth);
glutCreateWindow("Drawing a line");
if (!gladLoadGL())
{
fatalError("Failed to initialize GLAD");
}
GLuint program = GLSLProgram::CreateProgram();
init(program);
glutDisplayFunc(Display);
glutMainLoop();
return 0;
}
void init(GLuint program)
{
glViewport(0.0f, 0.0f, g_windowWidth, g_windowHeigth);
initVertexBuffers();
initMatrices(program);
g_uColor = glGetUniformLocation(program, "uColor");
if (g_uColor < 0)
{
fatalError("Failed to get uColor");
}
}
void initMatrices(GLuint program)
{
g_projMatrix = glm::ortho(
0.0f, g_windowWidth,
0.0f, g_windowHeigth,
-1.0f, 1.0f);
g_uMpMatrix = glGetUniformLocation(program, "uMpMatrix");
if (g_uMpMatrix < 0)
{
fatalError("Failed to get uMpMatrix");
}
}
void initVertexBuffers()
{
GLfloat vertices[] = { -0.5f, 0.0f, 0.5f, 0.0f };
GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, 4 * sizeof(GLfloat), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, NULL);
glEnableVertexAttribArray(0);
}
void DrawLine(Point p1, Point p2, Color c)
{
GLfloat x = p1.x + (p2.x - p1.x) / 2.0f;
GLfloat y = p1.y + (p2.y - p1.y) / 2.0f;
GLfloat length = glm::sqrt(
(p2.x - p1.x) * (p2.x - p1.x) +
(p2.y - p1.y) * (p2.y - p1.y));
GLfloat tan = (p2.y - p1.y) / (p2.x - p1.x);
GLfloat radians = glm::atan(tan);
g_modelMatrix =
glm::translate(glm::vec3(x, y, 0.0f)) *
glm::rotate(radians, glm::vec3(0.0f, 0.0f, 1.0f)) *
glm::scale(glm::vec3(length, 1.0f, 1.0f));
g_mpMatrix = g_projMatrix * g_modelMatrix;
glUniformMatrix4fv(g_uMpMatrix, 1, GL_FALSE, &(g_mpMatrix[0][0]));
glUniform3f(g_uColor, c.r, c.g, c.b);
glDrawArrays(GL_LINES, 0, 2);
}
void Display()
{
glClear(GL_COLOR_BUFFER_BIT);
DrawLine(Point(0.0f, 0.0f), Point(100.0f, 100.0f), Color(1.0f, 1.0f, 0.0f));
DrawLine(Point(50.0f, 10.0f), Point(190.0f, 70.0f), Color(0.0f, 1.0f, 0.0f));
DrawLine(Point(30.0f, 20.0f), Point(120.0f, 100.0f), Color(0.0f, 1.0f, 1.0f));
glutSwapBuffers();
} |
|
GLSLProgram.h
| C++ | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| #pragma once
#include <glad/glad.h>
class GLSLProgram
{
public:
GLSLProgram();
~GLSLProgram();
static GLuint CreateProgram();
private:
static GLuint CreateShader(const char *shaderSource, GLenum shaderType);
}; |
|
GLSLProgram.cpp
| 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
| #include "GLSLProgram.h"
#include "Errors.h"
#include <iostream>
#include <vector>
const char *vertexShaderSource =
"#version 330 core\n"
"layout(location = 0) in vec2 aPosition;"
"uniform mat4 uMpMatrix;"
"void main()"
"{"
" gl_Position = uMpMatrix * vec4(aPosition, 0.0, 1.0);"
"}";
const char *fragmentShaderSource =
"#version 330 core\n"
"precision mediump float;"
"uniform vec3 uColor;"
"out vec4 fragColor;"
"void main()"
"{"
" fragColor = vec4(uColor, 1.0);"
"}";
GLSLProgram::GLSLProgram()
{
}
GLSLProgram::~GLSLProgram()
{
}
GLuint GLSLProgram::CreateProgram()
{
GLuint program = glCreateProgram();
GLuint vShader = CreateShader(vertexShaderSource, GL_VERTEX_SHADER);
GLuint fShader = CreateShader(fragmentShaderSource, GL_FRAGMENT_SHADER);
glAttachShader(program, vShader);
glAttachShader(program, fShader);
glLinkProgram(program);
glUseProgram(program);
return program;
}
GLuint GLSLProgram::CreateShader(const char *shaderSource, GLenum shaderType)
{
GLuint shader = glCreateShader(shaderType);
glShaderSource(shader, 1, &shaderSource, nullptr);
glCompileShader(shader);
GLint status;
glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
if (status == GL_FALSE)
{
GLint infoLogLength = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLogLength);
std::vector<GLchar> errorLog(infoLogLength);
glGetShaderInfoLog(shader, infoLogLength, &infoLogLength, &errorLog[0]);
glDeleteShader(shader); // Don't leak the shader.
std::printf("%s\n", &(errorLog[0]));
fatalError("Shader failed to compile");
}
return shader;
} |
|
Errors.h
| C++ | 1
2
3
4
5
| #pragma once
#include <string>
extern void fatalError(std::string errorString); |
|
Errors.cpp
| C++ | 1
2
3
4
5
6
7
8
9
10
11
| #include "Errors.h"
#include <iostream>
void fatalError(std::string errorString)
{
std::cout << errorString << std::endl;
std::cout << "Press any key for quit..." << std::endl;
std::getchar();
exit(-1);
} |
|
0
|
(
Сообщение от Disaczar
