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
|
/*
* Copyright © 2010-2011 Linaro Limited
*
* This file is part of the glmark2 OpenGL (ES) 2.0 benchmark.
*
* glmark2 is free software: you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* glmark2 is distributed in the hope that it will be useful, but WITHOUT ANY
* WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* glmark2. If not, see <http://www.gnu.org/licenses/>.
*
* Authors:
* Alexandros Frantzis (glmark2)
*/
#include "scene.h"
#include "mat.h"
#include "stack.h"
#include "vec.h"
#include "log.h"
#include "util.h"
SceneGrid::SceneGrid(Canvas &pCanvas, const std::string &name) :
Scene(pCanvas, name)
{
options_["grid-size"] = Scene::Option("grid-size", "32",
"The number of squares per side of the grid (controls the number of vertices)");
options_["grid-length"] = Scene::Option("grid-length", "5.0",
"The length of each side of the grid (normalized) (controls the area drawn to)");
}
SceneGrid::~SceneGrid()
{
}
bool
SceneGrid::load()
{
rotationSpeed_ = 36.0f;
running_ = false;
return true;
}
void
SceneGrid::unload()
{
}
void
SceneGrid::setup()
{
Scene::setup();
int grid_size(Util::fromString<int>(options_["grid-size"].value));
double grid_length(Util::fromString<double>(options_["grid-length"].value));
/* Create and configure the grid mesh */
std::vector<int> vertex_format;
vertex_format.push_back(3);
mesh_.set_vertex_format(vertex_format);
/*
* The spacing needed in order for the area of the requested grid
* to be the same as the area of a grid with size 32 and spacing 0.02.
*/
double spacing = grid_length * (1 - 4.38 / 5.0) / (grid_size - 1.0);
mesh_.make_grid(grid_size, grid_size, grid_length, grid_length,
grid_size > 1 ? spacing : 0);
mesh_.build_vbo();
currentFrame_ = 0;
rotation_ = 0.0f;
}
void
SceneGrid::teardown()
{
program_.stop();
program_.release();
mesh_.reset();
Scene::teardown();
}
void
SceneGrid::update()
{
Scene::update();
double elapsed_time = lastUpdateTime_ - startTime_;
rotation_ = rotationSpeed_ * elapsed_time;
}
void
SceneGrid::draw()
{
// Load the ModelViewProjectionMatrix uniform in the shader
LibMatrix::Stack4 model_view;
LibMatrix::mat4 model_view_proj(canvas_.projection());
model_view.translate(0.0f, 0.0f, -5.0f);
model_view.rotate(rotation_, 0.0f, 0.0f, 1.0f);
model_view_proj *= model_view.getCurrent();
program_["ModelViewProjectionMatrix"] = model_view_proj;
mesh_.render_vbo();
}
Scene::ValidationResult
SceneGrid::validate()
{
return Scene::ValidationUnknown;
}
|
