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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
|
/** CSci-4611 Assignment 3: Earthquake
*/
#include "quake_app.h"
#include "config.h"
#include <iostream>
#include <sstream>
// Number of seconds in 1 year (approx.)
const int PLAYBACK_WINDOW = 12 * 28 * 24 * 60 * 60;
using namespace std;
QuakeApp::QuakeApp() : GraphicsApp(1280,720, "Earthquake"),
playback_scale_(15000000.0), debug_mode_(false)
{
// Define a search path for finding data files (images and earthquake db)
search_path_.push_back(".");
search_path_.push_back("./data");
search_path_.push_back(DATA_DIR_INSTALL);
search_path_.push_back(DATA_DIR_BUILD);
quake_db_ = EarthquakeDatabase(Platform::FindFile("earthquakes.txt", search_path_));
current_time_ = quake_db_.earthquake(quake_db_.min_index()).date().ToSeconds();
}
QuakeApp::~QuakeApp() {
}
void QuakeApp::InitNanoGUI() {
// Setup the GUI window
nanogui::Window *window = new nanogui::Window(screen(), "Earthquake Controls");
window->setPosition(Eigen::Vector2i(10, 10));
window->setSize(Eigen::Vector2i(400,200));
window->setLayout(new nanogui::GroupLayout());
date_label_ = new nanogui::Label(window, "Current Date: MM/DD/YYYY", "sans-bold");
globe_btn_ = new nanogui::Button(window, "Globe");
globe_btn_->setCallback(std::bind(&QuakeApp::OnGlobeBtnPressed, this));
globe_btn_->setTooltip("Toggle between map and globe.");
new nanogui::Label(window, "Playback Speed", "sans-bold");
nanogui::Widget *panel = new nanogui::Widget(window);
panel->setLayout(new nanogui::BoxLayout(nanogui::Orientation::Horizontal,
nanogui::Alignment::Middle, 0, 20));
nanogui::Slider *slider = new nanogui::Slider(panel);
slider->setValue(0.5f);
slider->setFixedWidth(120);
speed_box_ = new nanogui::TextBox(panel);
speed_box_->setFixedSize(Eigen::Vector2i(60, 25));
speed_box_->setValue("50");
speed_box_->setUnits("%");
slider->setCallback(std::bind(&QuakeApp::OnSliderUpdate, this, std::placeholders::_1));
speed_box_->setFixedSize(Eigen::Vector2i(60,25));
speed_box_->setFontSize(20);
speed_box_->setAlignment(nanogui::TextBox::Alignment::Right);
nanogui::Button* debug_btn = new nanogui::Button(window, "Toggle Debug Mode");
debug_btn->setCallback(std::bind(&QuakeApp::OnDebugBtnPressed, this));
debug_btn->setTooltip("Toggle displaying mesh triangles and normals (can be slow)");
screen()->performLayout();
}
void QuakeApp::OnLeftMouseDrag(const Point2 &pos, const Vector2 &delta) {
// Optional: In our demo, we adjust the tilt of the globe here when the
// mouse is dragged up/down on the screen.
}
void QuakeApp::OnGlobeBtnPressed() {
// TODO: This is where you can switch between flat earth mode and globe mode
globe_mode_ = !globe_mode_;
earth_.set_globe_mode(globe_mode_);
if (globe_mode_)
globe_btn_->setCaption("Map");
else
globe_btn_->setCaption("Globe");
}
void QuakeApp::OnDebugBtnPressed() {
debug_mode_ = !debug_mode_;
}
void QuakeApp::OnSliderUpdate(float value) {
speed_box_->setValue(std::to_string((int) (value * 100)));
playback_scale_ = 30000000.0*value;
}
void QuakeApp::UpdateSimulation(double dt) {
// Advance the current time and loop back to the start if time is past the last earthquake
current_time_ += playback_scale_ * dt;
if (current_time_ > quake_db_.earthquake(quake_db_.max_index()).date().ToSeconds()) {
current_time_ = quake_db_.earthquake(quake_db_.min_index()).date().ToSeconds();
}
if (current_time_ < quake_db_.earthquake(quake_db_.min_index()).date().ToSeconds()) {
current_time_ = quake_db_.earthquake(quake_db_.max_index()).date().ToSeconds();
}
Date d(current_time_);
stringstream s;
s << "Current date: " << d.month()
<< "/" << d.day()
<< "/" << d.year();
date_label_->setCaption(s.str());
// TODO: Any animation, morphing, rotation of the earth, or other things that should
// be updated once each frame would go here.
if (globe_mode_) {
rotation_angle_ += GfxMath::ToRadians(5) / 60;
} else {
rotation_angle_ = 0;
}
}
void QuakeApp::InitOpenGL() {
// Set up the camera in a good position to see the entire earth in either mode
proj_matrix_ = Matrix4::Perspective(60.0f, aspect_ratio(), 0.1f, 50.0f);
view_matrix_ = Matrix4::LookAt(Point3(0,0,3.5), Point3(0,0,0), Vector3(0,1,0));
glClearColor(0.0, 0.0, 0.0, 1);
// Initialize the earth object
earth_.Init(search_path_);
// Initialize the texture used for the background image
stars_tex_.InitFromFile(Platform::FindFile("iss006e40544.png", search_path_));
globe_mode_ = false;
}
void QuakeApp::DrawUsingOpenGL() {
quick_shapes_.DrawFullscreenTexture(Color(1,1,1), stars_tex_);
// You can leave this as the identity matrix and we will have a fine view of
// the earth. If you want to add any rotation or other animation of the
// earth, the model_matrix is where you would apply that.
Matrix4 model_matrix = Matrix4::RotationY(rotation_angle_);
// Draw the earth
earth_.Draw(model_matrix, view_matrix_, proj_matrix_);
if (debug_mode_) {
earth_.DrawDebugInfo(model_matrix, view_matrix_, proj_matrix_);
}
// TODO: You'll also need to draw the earthquakes. It's up to you exactly
// how you wish to do that.
// Earthquake eq;
float year_ago = current_time_ - PLAYBACK_WINDOW;
int start_index = quake_db_.FindMostRecentQuake(Date(year_ago));
int end_index = quake_db_.FindMostRecentQuake(Date(current_time_));
for (int i = start_index; i < end_index; i++) {
Earthquake eq = quake_db_.earthquake(i);
float time = eq.date().ToSeconds();
if (time > year_ago && time < current_time_) {
double magnitude_range = quake_db_.max_magnitude() - quake_db_.min_magnitude();
double magnitude = (quake_db_.max_magnitude() -eq.magnitude()) / magnitude_range * 10.0;
float size = magnitude * 0.01 * ((time - year_ago) / (current_time_ - year_ago));
if (size < 0.005)
size = 0.01;
if (size > 0.2)
size = 0.2;
// Set position of quake
// Depends on if in globe mode or not
Point3 pos;
if (globe_mode_)
pos = earth_.LatLongToSphere(eq.latitude(), eq.longitude());
else
pos = earth_.LatLongToPlane(eq.latitude(), eq.longitude());
Color qColor = Color(1,1,1); // black, default (SHOULD NEVER BE SEEN)
if (magnitude < 3.0)
qColor = Color(0,0,1); // blue
else if (magnitude < 4.0)
qColor = Color(0,1,0); // green
else if (magnitude < 5.0)
qColor = Color(1,1,0); // yellow
else
qColor = Color(1,0,0); // red
// Draw quake
// Vector3 translation = pos - Point3(0,0,0);
Matrix4 quake_matrix = Matrix4::Translation(Vector3(pos[0],
pos[1], pos[2]));
Matrix4 scale_matrix = Matrix4::Scale(Vector3(size, size, size));
Matrix4 transform = quake_matrix * scale_matrix;
quick_shapes_.DrawSphere(model_matrix * transform, view_matrix_, proj_matrix_, qColor);
}
}
}
|
