1 | #include "logger.h"
|
---|
2 |
|
---|
3 | #include "stb_image.h"
|
---|
4 |
|
---|
5 | #define _USE_MATH_DEFINES
|
---|
6 | #define GLM_SWIZZLE
|
---|
7 |
|
---|
8 | // This is to fix a non-alignment issue when passing vec4 params.
|
---|
9 | // Check if it got fixed in a later version of GLM
|
---|
10 | #define GLM_FORCE_PURE
|
---|
11 |
|
---|
12 | #include <glm/mat4x4.hpp>
|
---|
13 | #include <glm/gtc/matrix_transform.hpp>
|
---|
14 | #include <glm/gtc/type_ptr.hpp>
|
---|
15 |
|
---|
16 | #include <GL/glew.h>
|
---|
17 | #include <GLFW/glfw3.h>
|
---|
18 |
|
---|
19 | #include <cstdio>
|
---|
20 | #include <iostream>
|
---|
21 | #include <fstream>
|
---|
22 | #include <cmath>
|
---|
23 | #include <string>
|
---|
24 | #include <array>
|
---|
25 | #include <vector>
|
---|
26 |
|
---|
27 | using namespace std;
|
---|
28 | using namespace glm;
|
---|
29 |
|
---|
30 | #define ONE_DEG_IN_RAD (2.0 * M_PI) / 360.0 // 0.017444444
|
---|
31 |
|
---|
32 | struct SceneObject {
|
---|
33 | unsigned int id;
|
---|
34 | mat4 model_mat;
|
---|
35 | GLuint shader_program;
|
---|
36 | unsigned int num_points;
|
---|
37 | GLvoid* vertex_vbo_offset;
|
---|
38 | GLvoid* texture_vbo_offset;
|
---|
39 | vector<GLfloat> points;
|
---|
40 | vector<GLfloat> colors;
|
---|
41 | vector<GLfloat> texcoords;
|
---|
42 | vector<GLfloat> selected_colors;
|
---|
43 | };
|
---|
44 |
|
---|
45 | const bool FULLSCREEN = false;
|
---|
46 | int width = 640;
|
---|
47 | int height = 480;
|
---|
48 |
|
---|
49 | vec3 cam_pos;
|
---|
50 |
|
---|
51 | mat4 view_mat;
|
---|
52 | mat4 proj_mat;
|
---|
53 |
|
---|
54 | vector<SceneObject> objects;
|
---|
55 |
|
---|
56 | SceneObject* clickedObject = NULL;
|
---|
57 | SceneObject* selectedObject;
|
---|
58 |
|
---|
59 | double fps;
|
---|
60 |
|
---|
61 | bool faceClicked(array<vec3, 3> points, SceneObject* obj, vec4 world_ray, vec4 cam, vec4& click_point);
|
---|
62 | bool insideTriangle(vec3 p, array<vec3, 3> triangle_points);
|
---|
63 |
|
---|
64 | GLuint loadShader(GLenum type, string file);
|
---|
65 | GLuint loadShaderProgram(string vertexShaderPath, string fragmentShaderPath);
|
---|
66 | unsigned char* loadImage(string file_name, int* x, int* y);
|
---|
67 |
|
---|
68 | void printVector(string label, vec3 v);
|
---|
69 | void print4DVector(string label, vec4 v);
|
---|
70 |
|
---|
71 | float NEAR_CLIP = 0.1f;
|
---|
72 | float FAR_CLIP = 100.0f;
|
---|
73 |
|
---|
74 | void glfw_error_callback(int error, const char* description) {
|
---|
75 | gl_log_err("GLFW ERROR: code %i msg: %s\n", error, description);
|
---|
76 | }
|
---|
77 |
|
---|
78 | void mouse_button_callback(GLFWwindow* window, int button, int action, int mods) {
|
---|
79 | double mouse_x, mouse_y;
|
---|
80 | glfwGetCursorPos(window, &mouse_x, &mouse_y);
|
---|
81 |
|
---|
82 | if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS) {
|
---|
83 | cout << "Mouse clicked (" << mouse_x << "," << mouse_y << ")" << endl;
|
---|
84 | selectedObject = NULL;
|
---|
85 |
|
---|
86 | float x = (2.0f*mouse_x) / width - 1.0f;
|
---|
87 | float y = 1.0f - (2.0f*mouse_y) / height;
|
---|
88 |
|
---|
89 | cout << "x: " << x << ", y: " << y << endl;
|
---|
90 |
|
---|
91 | vec4 ray_clip = vec4(x, y, -1.0f, 1.0f);
|
---|
92 | vec4 ray_eye = inverse(proj_mat) * ray_clip;
|
---|
93 | ray_eye = vec4(ray_eye.xy(), -1.0f, 1.0f);
|
---|
94 | vec4 ray_world = inverse(view_mat) * ray_eye;
|
---|
95 |
|
---|
96 | vec4 cam_pos_temp = vec4(cam_pos, 1.0f);
|
---|
97 |
|
---|
98 | vec4 click_point;
|
---|
99 | vec3 closest_point = vec3(0.0f, 0.0f, -FAR_CLIP); // Any valid point will be closer than the far clipping plane, so initial value to that
|
---|
100 | SceneObject* closest_object = NULL;
|
---|
101 |
|
---|
102 | SceneObject* obj;
|
---|
103 | for (vector<SceneObject>::iterator it = objects.begin(); it != objects.end(); it++) {
|
---|
104 | obj = &*it;
|
---|
105 |
|
---|
106 | for (int p_idx = 0; p_idx < it->points.size(); p_idx += 9) {
|
---|
107 | if (faceClicked({
|
---|
108 | vec3(it->points[p_idx], it->points[p_idx + 1], it->points[p_idx + 2]),
|
---|
109 | vec3(it->points[p_idx + 3], it->points[p_idx + 4], it->points[p_idx + 5]),
|
---|
110 | vec3(it->points[p_idx + 6], it->points[p_idx + 7], it->points[p_idx + 8]),
|
---|
111 | },
|
---|
112 | obj, ray_world, cam_pos_temp, click_point)) {
|
---|
113 | click_point = view_mat * click_point;
|
---|
114 |
|
---|
115 | if (-NEAR_CLIP >= click_point.z && click_point.z > -FAR_CLIP && click_point.z > closest_point.z) {
|
---|
116 | closest_point = click_point.xyz();
|
---|
117 | closest_object = obj;
|
---|
118 | }
|
---|
119 | }
|
---|
120 | }
|
---|
121 | }
|
---|
122 |
|
---|
123 | if (closest_object == NULL) {
|
---|
124 | cout << "No object was clicked" << endl;
|
---|
125 | } else {
|
---|
126 | clickedObject = closest_object;
|
---|
127 | cout << "Clicked object: " << clickedObject->id << endl;
|
---|
128 | }
|
---|
129 | }
|
---|
130 | }
|
---|
131 |
|
---|
132 | int main(int argc, char* argv[]) {
|
---|
133 | cout << "New OpenGL Game" << endl;
|
---|
134 |
|
---|
135 | if (!restart_gl_log()) {}
|
---|
136 | gl_log("starting GLFW\n%s\n", glfwGetVersionString());
|
---|
137 |
|
---|
138 | glfwSetErrorCallback(glfw_error_callback);
|
---|
139 | if (!glfwInit()) {
|
---|
140 | fprintf(stderr, "ERROR: could not start GLFW3\n");
|
---|
141 | return 1;
|
---|
142 | }
|
---|
143 |
|
---|
144 | #ifdef __APPLE__
|
---|
145 | glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
---|
146 | glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
|
---|
147 | glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
|
---|
148 | glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
---|
149 | #endif
|
---|
150 |
|
---|
151 | glfwWindowHint(GLFW_SAMPLES, 4);
|
---|
152 |
|
---|
153 | GLFWwindow* window = NULL;
|
---|
154 | GLFWmonitor* mon = NULL;
|
---|
155 |
|
---|
156 | if (FULLSCREEN) {
|
---|
157 | mon = glfwGetPrimaryMonitor();
|
---|
158 | const GLFWvidmode* vmode = glfwGetVideoMode(mon);
|
---|
159 |
|
---|
160 | width = vmode->width;
|
---|
161 | height = vmode->height;
|
---|
162 | cout << "Fullscreen resolution " << vmode->width << "x" << vmode->height << endl;
|
---|
163 | }
|
---|
164 | window = glfwCreateWindow(width, height, "New OpenGL Game", mon, NULL);
|
---|
165 |
|
---|
166 | if (!window) {
|
---|
167 | fprintf(stderr, "ERROR: could not open window with GLFW3\n");
|
---|
168 | glfwTerminate();
|
---|
169 | return 1;
|
---|
170 | }
|
---|
171 |
|
---|
172 | glfwSetMouseButtonCallback(window, mouse_button_callback);
|
---|
173 |
|
---|
174 | glfwMakeContextCurrent(window);
|
---|
175 | glewExperimental = GL_TRUE;
|
---|
176 | glewInit();
|
---|
177 |
|
---|
178 | const GLubyte* renderer = glGetString(GL_RENDERER);
|
---|
179 | const GLubyte* version = glGetString(GL_VERSION);
|
---|
180 | printf("Renderer: %s\n", renderer);
|
---|
181 | printf("OpenGL version supported %s\n", version);
|
---|
182 |
|
---|
183 | glEnable(GL_DEPTH_TEST);
|
---|
184 | glDepthFunc(GL_LESS);
|
---|
185 |
|
---|
186 | glEnable(GL_CULL_FACE);
|
---|
187 | // glCullFace(GL_BACK);
|
---|
188 | // glFrontFace(GL_CW);
|
---|
189 |
|
---|
190 | int x, y;
|
---|
191 | unsigned char* texImage = loadImage("test.png", &x, &y);
|
---|
192 | if (texImage) {
|
---|
193 | cout << "Yay, I loaded an image!" << endl;
|
---|
194 | cout << x << endl;
|
---|
195 | cout << y << endl;
|
---|
196 | printf("first 4 bytes are: %i %i %i %i\n", texImage[0], texImage[1], texImage[2], texImage[3]);
|
---|
197 | }
|
---|
198 |
|
---|
199 | GLuint tex = 0;
|
---|
200 | glGenTextures(1, &tex);
|
---|
201 | glActiveTexture(GL_TEXTURE0);
|
---|
202 | glBindTexture(GL_TEXTURE_2D, tex);
|
---|
203 | glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, x, y, 0, GL_RGBA, GL_UNSIGNED_BYTE, texImage);
|
---|
204 |
|
---|
205 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
|
---|
206 | glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
|
---|
207 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
---|
208 | glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
---|
209 |
|
---|
210 | mat4 T_model, R_model;
|
---|
211 |
|
---|
212 | // triangle
|
---|
213 | objects.push_back(SceneObject());
|
---|
214 | objects[0].id = 0;
|
---|
215 | objects[0].shader_program = 0;
|
---|
216 | objects[0].vertex_vbo_offset = (GLvoid*) (0 * sizeof(float) * 3);
|
---|
217 | objects[0].texture_vbo_offset = (GLvoid*)(0 * sizeof(float) * 2);
|
---|
218 | objects[0].points = {
|
---|
219 | 0.0f, 0.5f, 0.0f,
|
---|
220 | -0.5f, -0.5f, 0.0f,
|
---|
221 | 0.5f, -0.5f, 0.0f,
|
---|
222 | 0.5f, -0.5f, 0.0f,
|
---|
223 | -0.5f, -0.5f, 0.0f,
|
---|
224 | 0.0f, 0.5f, 0.0f,
|
---|
225 | };
|
---|
226 | objects[0].colors = {
|
---|
227 | 1.0f, 0.0f, 0.0f,
|
---|
228 | 0.0f, 0.0f, 1.0f,
|
---|
229 | 0.0f, 1.0f, 0.0f,
|
---|
230 | 0.0f, 1.0f, 0.0f,
|
---|
231 | 0.0f, 0.0f, 1.0f,
|
---|
232 | 1.0f, 0.0f, 0.0f,
|
---|
233 | };
|
---|
234 | objects[0].texcoords = {
|
---|
235 | 1.0f, 1.0f,
|
---|
236 | 0.0f, 1.0f,
|
---|
237 | 0.0f, 0.0f,
|
---|
238 | 1.0f, 1.0f,
|
---|
239 | 0.0f, 0.0f,
|
---|
240 | 1.0f, 0.0f
|
---|
241 | };
|
---|
242 | objects[0].selected_colors = {
|
---|
243 | 0.0f, 1.0f, 0.0f,
|
---|
244 | 0.0f, 1.0f, 0.0f,
|
---|
245 | 0.0f, 1.0f, 0.0f,
|
---|
246 | 0.0f, 1.0f, 0.0f,
|
---|
247 | 0.0f, 1.0f, 0.0f,
|
---|
248 | 0.0f, 1.0f, 0.0f,
|
---|
249 | };
|
---|
250 | objects[0].num_points = objects[0].points.size() / 3;
|
---|
251 |
|
---|
252 | T_model = translate(mat4(), vec3(0.45f, 0.0f, 0.0f));
|
---|
253 | R_model = rotate(mat4(), 0.0f, vec3(0.0f, 1.0f, 0.0f));
|
---|
254 | objects[0].model_mat = T_model*R_model;
|
---|
255 |
|
---|
256 | // square
|
---|
257 | objects.push_back(SceneObject());
|
---|
258 | objects[1].id = 1;
|
---|
259 | objects[1].shader_program = 0;
|
---|
260 | objects[1].vertex_vbo_offset = (GLvoid*) (6 * sizeof(float) * 3);
|
---|
261 | objects[1].texture_vbo_offset = (GLvoid*)(6 * sizeof(float) * 2);
|
---|
262 | objects[1].points = {
|
---|
263 | 0.5f, 0.5f, 0.0f,
|
---|
264 | -0.5f, 0.5f, 0.0f,
|
---|
265 | -0.5f, -0.5f, 0.0f,
|
---|
266 | 0.5f, 0.5f, 0.0f,
|
---|
267 | -0.5f, -0.5f, 0.0f,
|
---|
268 | 0.5f, -0.5f, 0.0f,
|
---|
269 | };
|
---|
270 | objects[1].colors = {
|
---|
271 | 1.0f, 0.0f, 0.0f,
|
---|
272 | 0.0f, 0.0f, 1.0f,
|
---|
273 | 0.0f, 1.0f, 0.0f,
|
---|
274 | 0.0f, 1.0f, 0.0f,
|
---|
275 | 0.0f, 0.0f, 1.0f,
|
---|
276 | 1.0f, 0.0f, 0.0f,
|
---|
277 | };
|
---|
278 | objects[1].texcoords = {
|
---|
279 | 1.0f, 1.0f,
|
---|
280 | 0.0f, 1.0f,
|
---|
281 | 0.0f, 0.0f,
|
---|
282 | 1.0f, 1.0f,
|
---|
283 | 0.0f, 0.0f,
|
---|
284 | 1.0f, 0.0f
|
---|
285 | };
|
---|
286 | objects[1].selected_colors = {
|
---|
287 | 0.0f, 0.9f, 0.9f,
|
---|
288 | 0.0f, 0.9f, 0.9f,
|
---|
289 | 0.0f, 0.9f, 0.9f,
|
---|
290 | 0.0f, 0.9f, 0.9f,
|
---|
291 | 0.0f, 0.9f, 0.9f,
|
---|
292 | 0.0f, 0.9f, 0.9f,
|
---|
293 | };
|
---|
294 | objects[1].num_points = objects[1].points.size() / 3;
|
---|
295 |
|
---|
296 | T_model = translate(mat4(), vec3(-0.5f, 0.0f, -1.00f));
|
---|
297 | R_model = rotate(mat4(), 0.5f, vec3(0.0f, 1.0f, 0.0f));
|
---|
298 | objects[1].model_mat = T_model*R_model;
|
---|
299 |
|
---|
300 | vector<SceneObject>::iterator obj_it;
|
---|
301 | GLsizeiptr offset;
|
---|
302 |
|
---|
303 | GLsizeiptr points_buffer_size = 0;
|
---|
304 | GLsizeiptr textures_buffer_size = 0;
|
---|
305 |
|
---|
306 | for (obj_it = objects.begin(); obj_it != objects.end(); obj_it++) {
|
---|
307 | points_buffer_size += obj_it->points.size() * sizeof(GLfloat);
|
---|
308 | textures_buffer_size += obj_it->texcoords.size() * sizeof(GLfloat);
|
---|
309 | }
|
---|
310 |
|
---|
311 | GLuint points_vbo = 0;
|
---|
312 | glGenBuffers(1, &points_vbo);
|
---|
313 | glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
|
---|
314 | glBufferData(GL_ARRAY_BUFFER, points_buffer_size, NULL, GL_DYNAMIC_DRAW);
|
---|
315 |
|
---|
316 | offset = 0;
|
---|
317 | for (obj_it = objects.begin(); obj_it != objects.end(); obj_it++) {
|
---|
318 | glBufferSubData(GL_ARRAY_BUFFER, offset, obj_it->points.size() * sizeof(GLfloat), &obj_it->points[0]);
|
---|
319 | offset += obj_it->points.size() * sizeof(GLfloat);
|
---|
320 | }
|
---|
321 |
|
---|
322 | GLuint colors_vbo = 0;
|
---|
323 | glGenBuffers(1, &colors_vbo);
|
---|
324 | glBindBuffer(GL_ARRAY_BUFFER, colors_vbo);
|
---|
325 | glBufferData(GL_ARRAY_BUFFER, points_buffer_size, NULL, GL_DYNAMIC_DRAW);
|
---|
326 |
|
---|
327 | offset = 0;
|
---|
328 | for (obj_it = objects.begin(); obj_it != objects.end(); obj_it++) {
|
---|
329 | glBufferSubData(GL_ARRAY_BUFFER, offset, obj_it->colors.size() * sizeof(GLfloat), &obj_it->colors[0]);
|
---|
330 | offset += obj_it->colors.size() * sizeof(GLfloat);
|
---|
331 | }
|
---|
332 |
|
---|
333 | GLuint selected_colors_vbo = 0;
|
---|
334 | glGenBuffers(1, &selected_colors_vbo);
|
---|
335 | glBindBuffer(GL_ARRAY_BUFFER, selected_colors_vbo);
|
---|
336 | glBufferData(GL_ARRAY_BUFFER, points_buffer_size, NULL, GL_DYNAMIC_DRAW);
|
---|
337 |
|
---|
338 | offset = 0;
|
---|
339 | for (obj_it = objects.begin(); obj_it != objects.end(); obj_it++) {
|
---|
340 | glBufferSubData(GL_ARRAY_BUFFER, offset, obj_it->selected_colors.size() * sizeof(GLfloat), &obj_it->selected_colors[0]);
|
---|
341 | offset += obj_it->selected_colors.size() * sizeof(GLfloat);
|
---|
342 | }
|
---|
343 |
|
---|
344 | GLuint texcoords_vbo = 0;
|
---|
345 | glGenBuffers(1, &texcoords_vbo);
|
---|
346 | glBindBuffer(GL_ARRAY_BUFFER, texcoords_vbo);
|
---|
347 | glBufferData(GL_ARRAY_BUFFER, textures_buffer_size, NULL, GL_DYNAMIC_DRAW);
|
---|
348 |
|
---|
349 | offset = 0;
|
---|
350 | for (obj_it = objects.begin(); obj_it != objects.end(); obj_it++) {
|
---|
351 | glBufferSubData(GL_ARRAY_BUFFER, offset, obj_it->texcoords.size() * sizeof(GLfloat), &obj_it->texcoords[0]);
|
---|
352 | offset += obj_it->texcoords.size() * sizeof(GLfloat);
|
---|
353 | }
|
---|
354 |
|
---|
355 | GLuint vao = 0;
|
---|
356 | glGenVertexArrays(1, &vao);
|
---|
357 | glBindVertexArray(vao);
|
---|
358 |
|
---|
359 | glEnableVertexAttribArray(0);
|
---|
360 | glEnableVertexAttribArray(1);
|
---|
361 |
|
---|
362 | GLuint vao2 = 0;
|
---|
363 | glGenVertexArrays(1, &vao2);
|
---|
364 | glBindVertexArray(vao2);
|
---|
365 |
|
---|
366 | glEnableVertexAttribArray(0);
|
---|
367 | glEnableVertexAttribArray(1);
|
---|
368 |
|
---|
369 | // I can create a vbo to store all points for all models,
|
---|
370 | // and another vbo to store all colors for all models, but how do I allow alternating between
|
---|
371 | // using colors and textures for each model?
|
---|
372 | // Do I create a third vbo for texture coordinates and change which vertex attribute array I have bound
|
---|
373 | // when I want to draw a textured model?
|
---|
374 | // Or do I create one vao with vertices and colors and another with vertices and textures and switch between the two?
|
---|
375 | // Since I would have to switch shader programs to toggle between using colors or textures,
|
---|
376 | // I think I should use one vao for both cases and have a points vbo, a colors vbo, and a textures vbo
|
---|
377 | // One program will use the points and colors, and the other will use the points and texture coords
|
---|
378 | // Review how to bind vbos to vertex attributes in the shader.
|
---|
379 | //
|
---|
380 | // Binding vbos is done using glVertexAttribPointer(...) on a per-vao basis and is not tied to any specific shader.
|
---|
381 | // This means, I could create two vaos, one for each shader and have one use points+colors, while the other
|
---|
382 | // uses points+texxcoords.
|
---|
383 | //
|
---|
384 | // At some point, when I have lots of objects, I want to group them by shader when drawing them.
|
---|
385 | // I'd probably create some sort of set per shader and have each set contain the ids of all objects currently using that shader
|
---|
386 | // Most likely, I'd want to implement each set using a bit field. Makes it constant time for updates and iterating through them
|
---|
387 | // should not be much of an issue either.
|
---|
388 | // Assuming making lots of draw calls instead of one is not innefficient, I should be fine.
|
---|
389 | // I might also want to use one glDrawElements call per shader to draw multiple non-memory-adjacent models
|
---|
390 | //
|
---|
391 | // DECISION: Use a glDrawElements call per shader since I use a regular array to specify the elements to draw
|
---|
392 | // Actually, this will only work once I get UBOs working since each object will have a different model matrix
|
---|
393 | // For now, I could implement this with a glDrawElements call per object and update the model uniform for each object
|
---|
394 |
|
---|
395 | GLuint shader_program = loadShaderProgram("./color.vert", "./color.frag");
|
---|
396 | GLuint shader_program2 = loadShaderProgram("./texture.vert", "./texture.frag");
|
---|
397 |
|
---|
398 | float speed = 1.0f;
|
---|
399 | float last_position = 0.0f;
|
---|
400 |
|
---|
401 | float cam_speed = 1.0f;
|
---|
402 | float cam_yaw_speed = 60.0f*ONE_DEG_IN_RAD;
|
---|
403 |
|
---|
404 | // glm::lookAt can create the view matrix
|
---|
405 | // glm::perspective can create the projection matrix
|
---|
406 |
|
---|
407 | cam_pos = vec3(0.0f, 0.0f, 2.0f);
|
---|
408 | float cam_yaw = 0.0f * 2.0f * 3.14159f / 360.0f;
|
---|
409 |
|
---|
410 | mat4 T = translate(mat4(), vec3(-cam_pos.x, -cam_pos.y, -cam_pos.z));
|
---|
411 | mat4 R = rotate(mat4(), -cam_yaw, vec3(0.0f, 1.0f, 0.0f));
|
---|
412 | view_mat = R*T;
|
---|
413 |
|
---|
414 | float fov = 67.0f * ONE_DEG_IN_RAD;
|
---|
415 | float aspect = (float)width / (float)height;
|
---|
416 |
|
---|
417 | float range = tan(fov * 0.5f) * NEAR_CLIP;
|
---|
418 | float Sx = NEAR_CLIP / (range * aspect);
|
---|
419 | float Sy = NEAR_CLIP / range;
|
---|
420 | float Sz = -(FAR_CLIP + NEAR_CLIP) / (FAR_CLIP - NEAR_CLIP);
|
---|
421 | float Pz = -(2.0f * FAR_CLIP * NEAR_CLIP) / (FAR_CLIP - NEAR_CLIP);
|
---|
422 |
|
---|
423 | float proj_arr[] = {
|
---|
424 | Sx, 0.0f, 0.0f, 0.0f,
|
---|
425 | 0.0f, Sy, 0.0f, 0.0f,
|
---|
426 | 0.0f, 0.0f, Sz, -1.0f,
|
---|
427 | 0.0f, 0.0f, Pz, 0.0f,
|
---|
428 | };
|
---|
429 | proj_mat = make_mat4(proj_arr);
|
---|
430 |
|
---|
431 | GLint model_test_loc = glGetUniformLocation(shader_program, "model");
|
---|
432 | GLint view_test_loc = glGetUniformLocation(shader_program, "view");
|
---|
433 | GLint proj_test_loc = glGetUniformLocation(shader_program, "proj");
|
---|
434 |
|
---|
435 | GLint model_mat_loc = glGetUniformLocation(shader_program2, "model");
|
---|
436 | GLint view_mat_loc = glGetUniformLocation(shader_program2, "view");
|
---|
437 | GLint proj_mat_loc = glGetUniformLocation(shader_program2, "proj");
|
---|
438 |
|
---|
439 | glUseProgram(shader_program);
|
---|
440 | glUniformMatrix4fv(model_test_loc, 1, GL_FALSE, value_ptr(objects[0].model_mat));
|
---|
441 | glUniformMatrix4fv(view_test_loc, 1, GL_FALSE, value_ptr(view_mat));
|
---|
442 | glUniformMatrix4fv(proj_test_loc, 1, GL_FALSE, value_ptr(proj_mat));
|
---|
443 |
|
---|
444 | glUseProgram(shader_program2);
|
---|
445 | glUniformMatrix4fv(model_mat_loc, 1, GL_FALSE, value_ptr(objects[1].model_mat));
|
---|
446 | glUniformMatrix4fv(view_mat_loc, 1, GL_FALSE, value_ptr(view_mat));
|
---|
447 | glUniformMatrix4fv(proj_mat_loc, 1, GL_FALSE, value_ptr(proj_mat));
|
---|
448 |
|
---|
449 | objects[0].shader_program = shader_program;
|
---|
450 | objects[1].shader_program = shader_program2;
|
---|
451 |
|
---|
452 | vector<int> program1_objects, program2_objects;
|
---|
453 | vector<int>::iterator it;
|
---|
454 |
|
---|
455 | bool cam_moved = false;
|
---|
456 |
|
---|
457 | int frame_count = 0;
|
---|
458 | double elapsed_seconds_fps = 0.0f;
|
---|
459 | double previous_seconds = glfwGetTime();
|
---|
460 |
|
---|
461 | while (!glfwWindowShouldClose(window)) {
|
---|
462 | double current_seconds = glfwGetTime();
|
---|
463 | double elapsed_seconds = current_seconds - previous_seconds;
|
---|
464 | previous_seconds = current_seconds;
|
---|
465 |
|
---|
466 | elapsed_seconds_fps += elapsed_seconds;
|
---|
467 | if (elapsed_seconds_fps > 0.25f) {
|
---|
468 | fps = (double)frame_count / elapsed_seconds_fps;
|
---|
469 | cout << "FPS: " << fps << endl;
|
---|
470 |
|
---|
471 | frame_count = 0;
|
---|
472 | elapsed_seconds_fps = 0.0f;
|
---|
473 | }
|
---|
474 |
|
---|
475 | frame_count++;
|
---|
476 |
|
---|
477 | if (fabs(last_position) > 1.0f) {
|
---|
478 | speed = -speed;
|
---|
479 | }
|
---|
480 |
|
---|
481 | program1_objects.clear();
|
---|
482 | program2_objects.clear();
|
---|
483 |
|
---|
484 | // Handle events (Ideally, move all event-handling code
|
---|
485 | // before the render code)
|
---|
486 |
|
---|
487 | clickedObject = NULL;
|
---|
488 | glfwPollEvents();
|
---|
489 |
|
---|
490 | if (clickedObject == &objects[0]) {
|
---|
491 | selectedObject = &objects[0];
|
---|
492 | }
|
---|
493 | if (clickedObject == &objects[1]) {
|
---|
494 | selectedObject = &objects[1];
|
---|
495 | }
|
---|
496 |
|
---|
497 | if (selectedObject == &objects[1] &&
|
---|
498 | objects[1].shader_program == shader_program2) {
|
---|
499 | objects[1].shader_program = shader_program;
|
---|
500 | } else if (selectedObject != &objects[1] &&
|
---|
501 | objects[1].shader_program == shader_program) {
|
---|
502 | objects[1].shader_program = shader_program2;
|
---|
503 | }
|
---|
504 |
|
---|
505 | // group scene objects by shader
|
---|
506 | for (int i=0; i < objects.size(); i++) {
|
---|
507 | if (objects[i].shader_program == shader_program) {
|
---|
508 | program1_objects.push_back(i);
|
---|
509 | } else if (objects[i].shader_program == shader_program2) {
|
---|
510 | program2_objects.push_back(i);
|
---|
511 | }
|
---|
512 | }
|
---|
513 |
|
---|
514 | /*
|
---|
515 | model[12] = last_position + speed*elapsed_seconds;
|
---|
516 | last_position = model[12];
|
---|
517 | */
|
---|
518 |
|
---|
519 | glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
---|
520 |
|
---|
521 | glUseProgram(shader_program);
|
---|
522 | glBindVertexArray(vao);
|
---|
523 |
|
---|
524 | for (it=program1_objects.begin(); it != program1_objects.end(); it++) {
|
---|
525 | glUniformMatrix4fv(model_test_loc, 1, GL_FALSE, value_ptr(objects[*it].model_mat));
|
---|
526 |
|
---|
527 | glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
|
---|
528 | glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, objects[*it].vertex_vbo_offset);
|
---|
529 |
|
---|
530 | if (selectedObject == &objects[*it]) {
|
---|
531 | glBindBuffer(GL_ARRAY_BUFFER, selected_colors_vbo);
|
---|
532 | } else {
|
---|
533 | glBindBuffer(GL_ARRAY_BUFFER, colors_vbo);
|
---|
534 | }
|
---|
535 | glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, objects[*it].vertex_vbo_offset);
|
---|
536 |
|
---|
537 | glDrawArrays(GL_TRIANGLES, 0, objects[*it].num_points);
|
---|
538 | }
|
---|
539 |
|
---|
540 | glUseProgram(shader_program2);
|
---|
541 | glBindVertexArray(vao2);
|
---|
542 |
|
---|
543 | for (it = program2_objects.begin(); it != program2_objects.end(); it++) {
|
---|
544 | glUniformMatrix4fv(model_mat_loc, 1, GL_FALSE, value_ptr(objects[*it].model_mat));
|
---|
545 |
|
---|
546 | glBindBuffer(GL_ARRAY_BUFFER, points_vbo);
|
---|
547 | glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, objects[*it].vertex_vbo_offset);
|
---|
548 |
|
---|
549 | glBindBuffer(GL_ARRAY_BUFFER, texcoords_vbo);
|
---|
550 | glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, objects[*it].texture_vbo_offset);
|
---|
551 |
|
---|
552 | glDrawArrays(GL_TRIANGLES, 0, objects[*it].num_points);
|
---|
553 | }
|
---|
554 |
|
---|
555 | glfwSwapBuffers(window);
|
---|
556 |
|
---|
557 | if (GLFW_PRESS == glfwGetKey(window, GLFW_KEY_ESCAPE)) {
|
---|
558 | glfwSetWindowShouldClose(window, 1);
|
---|
559 | }
|
---|
560 |
|
---|
561 | float dist = cam_speed * elapsed_seconds;
|
---|
562 | if (glfwGetKey(window, GLFW_KEY_A)) {
|
---|
563 | cam_pos.x -= cos(cam_yaw)*dist;
|
---|
564 | cam_pos.z += sin(cam_yaw)*dist;
|
---|
565 | cam_moved = true;
|
---|
566 | }
|
---|
567 | if (glfwGetKey(window, GLFW_KEY_D)) {
|
---|
568 | cam_pos.x += cos(cam_yaw)*dist;
|
---|
569 | cam_pos.z -= sin(cam_yaw)*dist;
|
---|
570 | cam_moved = true;
|
---|
571 | }
|
---|
572 | if (glfwGetKey(window, GLFW_KEY_W)) {
|
---|
573 | cam_pos.x -= sin(cam_yaw)*dist;
|
---|
574 | cam_pos.z -= cos(cam_yaw)*dist;
|
---|
575 | cam_moved = true;
|
---|
576 | }
|
---|
577 | if (glfwGetKey(window, GLFW_KEY_S)) {
|
---|
578 | cam_pos.x += sin(cam_yaw)*dist;
|
---|
579 | cam_pos.z += cos(cam_yaw)*dist;
|
---|
580 | cam_moved = true;
|
---|
581 | }
|
---|
582 | if (glfwGetKey(window, GLFW_KEY_LEFT)) {
|
---|
583 | cam_yaw += cam_yaw_speed * elapsed_seconds;
|
---|
584 | cam_moved = true;
|
---|
585 | }
|
---|
586 | if (glfwGetKey(window, GLFW_KEY_RIGHT)) {
|
---|
587 | cam_yaw -= cam_yaw_speed * elapsed_seconds;
|
---|
588 | cam_moved = true;
|
---|
589 | }
|
---|
590 | if (cam_moved) {
|
---|
591 | T = translate(mat4(), vec3(-cam_pos.x, -cam_pos.y, -cam_pos.z));
|
---|
592 | R = rotate(mat4(), -cam_yaw, vec3(0.0f, 1.0f, 0.0f));
|
---|
593 | view_mat = R*T;
|
---|
594 |
|
---|
595 | glUseProgram(shader_program);
|
---|
596 | glUniformMatrix4fv(view_test_loc, 1, GL_FALSE, value_ptr(view_mat));
|
---|
597 |
|
---|
598 | glUseProgram(shader_program2);
|
---|
599 | glUniformMatrix4fv(view_mat_loc, 1, GL_FALSE, value_ptr(view_mat));
|
---|
600 |
|
---|
601 | cam_moved = false;
|
---|
602 | }
|
---|
603 | }
|
---|
604 |
|
---|
605 | glfwTerminate();
|
---|
606 | return 0;
|
---|
607 | }
|
---|
608 |
|
---|
609 | GLuint loadShader(GLenum type, string file) {
|
---|
610 | cout << "Loading shader from file " << file << endl;
|
---|
611 |
|
---|
612 | ifstream shaderFile(file);
|
---|
613 | GLuint shaderId = 0;
|
---|
614 |
|
---|
615 | if (shaderFile.is_open()) {
|
---|
616 | string line, shaderString;
|
---|
617 |
|
---|
618 | while(getline(shaderFile, line)) {
|
---|
619 | shaderString += line + "\n";
|
---|
620 | }
|
---|
621 | shaderFile.close();
|
---|
622 | const char* shaderCString = shaderString.c_str();
|
---|
623 |
|
---|
624 | shaderId = glCreateShader(type);
|
---|
625 | glShaderSource(shaderId, 1, &shaderCString, NULL);
|
---|
626 | glCompileShader(shaderId);
|
---|
627 |
|
---|
628 | cout << "Loaded successfully" << endl;
|
---|
629 | } else {
|
---|
630 | cout << "Failed to load the file" << endl;
|
---|
631 | }
|
---|
632 |
|
---|
633 | return shaderId;
|
---|
634 | }
|
---|
635 |
|
---|
636 | GLuint loadShaderProgram(string vertexShaderPath, string fragmentShaderPath) {
|
---|
637 | GLuint vs = loadShader(GL_VERTEX_SHADER, vertexShaderPath);
|
---|
638 | GLuint fs = loadShader(GL_FRAGMENT_SHADER, fragmentShaderPath);
|
---|
639 |
|
---|
640 | GLuint shader_program = glCreateProgram();
|
---|
641 | glAttachShader(shader_program, vs);
|
---|
642 | glAttachShader(shader_program, fs);
|
---|
643 |
|
---|
644 | glLinkProgram(shader_program);
|
---|
645 |
|
---|
646 | return shader_program;
|
---|
647 | }
|
---|
648 |
|
---|
649 | unsigned char* loadImage(string file_name, int* x, int* y) {
|
---|
650 | int n;
|
---|
651 | int force_channels = 4; // This forces RGBA (4 bytes per pixel)
|
---|
652 | unsigned char* image_data = stbi_load(file_name.c_str(), x, y, &n, force_channels);
|
---|
653 |
|
---|
654 | int width_in_bytes = *x * 4;
|
---|
655 | unsigned char *top = NULL;
|
---|
656 | unsigned char *bottom = NULL;
|
---|
657 | unsigned char temp = 0;
|
---|
658 | int half_height = *y / 2;
|
---|
659 |
|
---|
660 | // flip image upside-down to account for OpenGL treating lower-left as (0, 0)
|
---|
661 | for (int row = 0; row < half_height; row++) {
|
---|
662 | top = image_data + row * width_in_bytes;
|
---|
663 | bottom = image_data + (*y - row - 1) * width_in_bytes;
|
---|
664 | for (int col = 0; col < width_in_bytes; col++) {
|
---|
665 | temp = *top;
|
---|
666 | *top = *bottom;
|
---|
667 | *bottom = temp;
|
---|
668 | top++;
|
---|
669 | bottom++;
|
---|
670 | }
|
---|
671 | }
|
---|
672 |
|
---|
673 | if (!image_data) {
|
---|
674 | fprintf(stderr, "ERROR: could not load %s\n", file_name.c_str());
|
---|
675 | }
|
---|
676 |
|
---|
677 | // Not Power-of-2 check
|
---|
678 | if ((*x & (*x - 1)) != 0 || (*y & (*y - 1)) != 0) {
|
---|
679 | fprintf(stderr, "WARNING: texture %s is not power-of-2 dimensions\n", file_name.c_str());
|
---|
680 | }
|
---|
681 |
|
---|
682 | return image_data;
|
---|
683 | }
|
---|
684 |
|
---|
685 | bool faceClicked(array<vec3, 3> points, SceneObject* obj, vec4 world_ray, vec4 cam, vec4& click_point) {
|
---|
686 | // LINE EQUATION: P = O + Dt
|
---|
687 | // O = cam
|
---|
688 | // D = ray_world
|
---|
689 |
|
---|
690 | // PLANE EQUATION: P dot n + d = 0
|
---|
691 | // n is the normal vector
|
---|
692 | // d is the offset from the origin
|
---|
693 |
|
---|
694 | // Take the cross-product of two vectors on the plane to get the normal
|
---|
695 | vec3 v1 = points[1] - points[0];
|
---|
696 | vec3 v2 = points[2] - points[0];
|
---|
697 |
|
---|
698 | vec3 normal = vec3(v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x);
|
---|
699 |
|
---|
700 | print4DVector("Full world ray", world_ray);
|
---|
701 |
|
---|
702 | vec3 local_ray = (inverse(obj->model_mat) * world_ray).xyz();
|
---|
703 | vec3 local_cam = (inverse(obj->model_mat) * cam).xyz();
|
---|
704 |
|
---|
705 | local_ray = local_ray - local_cam;
|
---|
706 |
|
---|
707 | float d = -glm::dot(points[0], normal);
|
---|
708 | cout << "d: " << d << endl;
|
---|
709 |
|
---|
710 | float t = -(glm::dot(local_cam, normal) + d) / glm::dot(local_ray, normal);
|
---|
711 | cout << "t: " << t << endl;
|
---|
712 |
|
---|
713 | vec3 intersection = local_cam + t*local_ray;
|
---|
714 | printVector("Intersection", intersection);
|
---|
715 |
|
---|
716 | if (insideTriangle(intersection, points)) {
|
---|
717 | click_point = obj->model_mat * vec4(intersection, 1.0f);
|
---|
718 | return true;
|
---|
719 | } else {
|
---|
720 | return false;
|
---|
721 | }
|
---|
722 | }
|
---|
723 | bool insideTriangle(vec3 p, array<vec3, 3> triangle_points) {
|
---|
724 | vec3 v21 = triangle_points[1] - triangle_points[0];
|
---|
725 | vec3 v31 = triangle_points[2] - triangle_points[0];
|
---|
726 | vec3 pv1 = p - triangle_points[0];
|
---|
727 |
|
---|
728 | float y = (pv1.y*v21.x - pv1.x*v21.y) / (v31.y*v21.x - v31.x*v21.y);
|
---|
729 | float x = (pv1.x-y*v31.x) / v21.x;
|
---|
730 |
|
---|
731 | return x > 0.0f && y > 0.0f && x+y < 1.0f;
|
---|
732 | }
|
---|
733 |
|
---|
734 | void printVector(string label, vec3 v) {
|
---|
735 | cout << label << " -> (" << v.x << "," << v.y << "," << v.z << ")" << endl;
|
---|
736 | }
|
---|
737 |
|
---|
738 | void print4DVector(string label, vec4 v) {
|
---|
739 | cout << label << " -> (" << v.x << "," << v.y << "," << v.z << "," << v.w << ")" << endl;
|
---|
740 | }
|
---|