]> git.localhorst.tv Git - blank.git/blob - src/graphics/viewport.cpp
give unique IDs to entities
[blank.git] / src / graphics / viewport.cpp
1 #include "Camera.hpp"
2 #include "Canvas.hpp"
3 #include "Viewport.hpp"
4
5 #include "../app/init.hpp"
6 #include "../model/geometry.hpp"
7
8 #include <GL/glew.h>
9 #include <glm/gtc/matrix_transform.hpp>
10 #include <glm/gtx/transform.hpp>
11 #include <SDL.h>
12
13
14 namespace blank {
15
16 Camera::Camera() noexcept
17 : fov(PI_0p25)
18 , aspect(1.0f)
19 , near(0.1f)
20 , far(256.0f)
21 , projection(glm::perspective(fov, aspect, near, far))
22 , view(1.0f) {
23
24 }
25
26
27 void Camera::FOV(float f) noexcept {
28         fov = f;
29         UpdateProjection();
30 }
31
32 void Camera::Aspect(float r) noexcept {
33         aspect = r;
34         UpdateProjection();
35 }
36
37 void Camera::Aspect(float w, float h) noexcept {
38         Aspect(w / h);
39 }
40
41 void Camera::Clip(float n, float f) noexcept {
42         near = n;
43         far = f;
44         UpdateProjection();
45 }
46
47
48 void Camera::UpdateProjection() noexcept {
49         projection = glm::perspective(fov, aspect, near, far);
50 }
51
52
53 Canvas::Canvas() noexcept
54 : offset(0.0f, 0.0f)
55 , size(1.0f, 1.0f)
56 , near(100.0f)
57 , far(-100.0f)
58 , projection(glm::ortho(offset.x, size.x, size.y, offset.y, near, far))
59 , view(1.0f) {
60
61 }
62
63
64 void Canvas::Resize(float w, float h) noexcept {
65         size.x = w;
66         size.y = h;
67         UpdateProjection();
68 }
69
70
71 void Canvas::UpdateProjection() noexcept {
72         projection = glm::ortho(offset.x, size.x, size.y, offset.y, near, far);
73 }
74
75
76 Viewport::Viewport()
77 : cam()
78 , canv()
79 , cursor(1.0f)
80 , chunk_prog()
81 , entity_prog()
82 , sprite_prog()
83 , active_prog(NONE) {
84         glClearColor(0.0, 0.0, 0.0, 1.0);
85 }
86
87 void Viewport::VSync(bool b) noexcept {
88         if (SDL_GL_SetSwapInterval(b) != 0) {
89                 throw SDLError("SDL_GL_SetSwapInterval");
90         }
91 }
92
93 void Viewport::EnableDepthTest() noexcept {
94         glEnable(GL_DEPTH_TEST);
95         glDepthFunc(GL_LESS);
96 }
97
98 void Viewport::DisableDepthTest() noexcept {
99         glDisable(GL_DEPTH_TEST);
100 }
101
102 void Viewport::EnableBackfaceCulling() noexcept {
103         glEnable(GL_CULL_FACE);
104 }
105
106 void Viewport::DisableBackfaceCulling() noexcept {
107         glDisable(GL_CULL_FACE);
108 }
109
110 void Viewport::EnableAlphaBlending() noexcept {
111         glEnable(GL_BLEND);
112         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
113 }
114
115 void Viewport::EnableInvertBlending() noexcept {
116         glEnable(GL_BLEND);
117         glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
118 }
119
120 void Viewport::DisableBlending() noexcept {
121         glDisable(GL_BLEND);
122 }
123
124 void Viewport::Resize(int w, int h) noexcept {
125         glViewport(0, 0, w, h);
126         float fw = w;
127         float fh = h;
128         cam.Aspect(fw, fh);
129         canv.Resize(fw, fh);
130
131         chunk_prog.SetProjection(Perspective());
132         if (active_prog == HUD) {
133                 entity_prog.SetProjection(Ortho());
134         } else {
135                 entity_prog.SetProjection(Perspective());
136         }
137         sprite_prog.SetProjection(Ortho());
138 }
139
140 void Viewport::Clear() noexcept {
141         glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
142 }
143
144 void Viewport::ClearDepth() noexcept {
145         glClear(GL_DEPTH_BUFFER_BIT);
146 }
147
148
149 void Viewport::SetCursor(const glm::vec3 &pos) {
150         cursor[3].x = pos.x;
151         cursor[3].y = pos.y;
152         cursor[3].z = pos.z;
153 }
154
155 void Viewport::SetCursor(const glm::vec3 &pos, Gravity grav) {
156         glm::vec2 p(align(grav, canv.Size(), glm::vec2(pos) + canv.Offset()));
157         cursor[3].x = p.x;
158         cursor[3].y = p.y;
159         cursor[3].z = pos.z;
160 }
161
162 void Viewport::MoveCursor(const glm::vec3 &d) {
163         cursor[3].x += d.x;
164         cursor[3].y += d.y;
165         cursor[3].z += d.z;
166 }
167
168
169 BlockLighting &Viewport::ChunkProgram() noexcept {
170         if (active_prog != CHUNK) {
171                 chunk_prog.Activate();
172                 EnableDepthTest();
173                 EnableBackfaceCulling();
174                 DisableBlending();
175                 active_prog = CHUNK;
176         }
177         return chunk_prog;
178 }
179
180 DirectionalLighting &Viewport::EntityProgram() noexcept {
181         if (active_prog != ENTITY) {
182                 entity_prog.Activate();
183                 EnableDepthTest();
184                 EnableBackfaceCulling();
185                 DisableBlending();
186                 entity_prog.SetVP(cam.View(), cam.Projection());
187                 active_prog = ENTITY;
188         }
189         return entity_prog;
190 }
191
192 DirectionalLighting &Viewport::HUDProgram() noexcept {
193         if (active_prog != HUD) {
194                 entity_prog.Activate();
195                 EnableDepthTest();
196                 EnableBackfaceCulling();
197                 entity_prog.SetVP(canv.View(), canv.Projection());
198                 active_prog = HUD;
199         }
200         return entity_prog;
201 }
202
203 PlainColor &Viewport::WorldOutlineProgram() noexcept {
204         if (active_prog != OUTLINE_WORLD) {
205                 outline_prog.Activate();
206                 outline_prog.SetVP(cam.View(), cam.Projection());
207                 active_prog = OUTLINE_WORLD;
208         }
209         return outline_prog;
210 }
211
212 PlainColor &Viewport::HUDOutlineProgram() noexcept {
213         if (active_prog != OUTLINE_HUD) {
214                 outline_prog.Activate();
215                 outline_prog.SetVP(canv.View(), canv.Projection());
216                 active_prog = OUTLINE_HUD;
217         }
218         return outline_prog;
219 }
220
221 BlendedSprite &Viewport::SpriteProgram() noexcept {
222         if (active_prog != SPRITE) {
223                 sprite_prog.Activate();
224                 EnableAlphaBlending();
225                 active_prog = SPRITE;
226         }
227         return sprite_prog;
228 }
229
230
231 void Viewport::WorldPosition(const glm::mat4 &t) noexcept {
232         cam.View(glm::inverse(t));
233         chunk_prog.SetView(cam.View());
234 }
235
236 }