blob: 0d0fb1b47dacc9be865605d81ec9d7adb476422c (
plain)
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
|
#pragma once
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <chrono>
#include <cmath>
#include "core/application.h"
#include "core/camera.h"
#include "rendering/renderer.h"
#include "rendering/shader.h"
#include "rendering/vertex_array.h"
#include "rendering/texture.h"
#include "rendering/uniform_buffer.h"
#include "rendering/texture_manager.h"
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#define _USE_MATH_DEFINES
#ifndef M_PI
#define M_PI 3.14159265358979323846
#endif
namespace Donut
{
const double c = 299792458.0;
const double G = 6.67430e-11;
struct BlackHole
{
glm::vec3 m_position;
double m_mass;
double m_radius;
double m_rs;
BlackHole(glm::vec3 pos, float mass)
: m_position(pos), m_mass(mass)
{
m_rs = 2.0 * G * m_mass / (c * c);
}
bool intercept(float px, float py, float pz) const
{
double dx = double(px) - double(m_position.x);
double dy = double(py) - double(m_position.y);
double dz = double(pz) - double(m_position.z);
double dist2 = dx * dx + dy * dy + dz * dz;
return dist2 < m_rs * m_rs;
}
};
struct ObjectData
{
glm::vec4 m_pos_radius;
glm::vec4 m_color;
float m_mass;
glm::vec3 m_velocity = glm::vec3(0.0f, 0.0f, 0.0f);
};
class Engine
{
public:
Engine();
~Engine() = default;
void draw_full_screen_quad();
void dispatch_compute(const Camera& cam);
void upload_camera_ubo(const Camera& cam);
void upload_objects_ubo(const std::vector<ObjectData>& objs);
void upload_disk_ubo();
void upload_simulation_ubo();
void render_scene();
void update_physics(float delta_time);
void update_window_dimensions();
int get_width() const { return m_width; }
int get_height() const { return m_height; }
std::vector<ObjectData>& get_objects() { return m_objects; }
BlackHole& get_sag_a() { return m_sag_a; }
Camera& get_camera() { return m_camera; }
bool& get_gravity() { return m_gravity; }
void update_performance(float delta_time);
void set_target_fps(int fps) { m_target_fps = fps; }
int get_target_fps() const { return m_target_fps; }
float get_current_fps() const { return m_current_fps; }
void set_compute_height(int height) { m_compute_height = height; }
int get_compute_height() const { return m_compute_height; }
int get_compute_width() const { return (m_width * m_compute_height) / m_height; }
void update_compute_dimensions();
int get_max_steps_moving() const { return m_max_steps_moving; }
int get_max_steps_static() const { return m_max_steps_static; }
float get_early_exit_distance() const { return m_early_exit_distance; }
void set_max_steps_moving(int steps) { m_max_steps_moving = steps; }
void set_max_steps_static(int steps) { m_max_steps_static = steps; }
void set_early_exit_distance(float distance) { m_early_exit_distance = distance; }
private:
Ref<Shader> create_compute_program(const char* path);
std::pair<Ref<VertexArray>, Ref<Texture2D>> quad_vao();
private:
Ref<VertexArray> m_quad_vao;
Ref<Texture2D> m_texture;
Ref<Shader> m_shader_program;
Ref<Shader> m_compute_program;
Ref<UniformBuffer> m_camera_ubo;
Ref<UniformBuffer> m_disk_ubo;
Ref<UniformBuffer> m_objects_ubo;
Ref<UniformBuffer> m_simulation_ubo;
int m_width;
int m_height;
float m_width_f = 100*10e10f;
float m_height_f = 75*10e10f;
int m_target_fps = 60;
float m_current_fps = 60.0f;
float m_last_frame_time = 0.0f;
int m_compute_height = 150;
std::vector<ObjectData> m_objects;
BlackHole m_sag_a;
Camera m_camera;
bool m_gravity = false;
int m_max_steps_moving = 60000;
int m_max_steps_static = 30000;
float m_early_exit_distance = 5e11f;
};
};
|
