=== modified file 'android/AndroidManifest.xml'
@@ -17,4 +17,4 @@
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-feature android:glEsVersion="0x00020000"/>
<uses-sdk android:minSdkVersion="9"/>
-</manifest>
+</manifest>
=== modified file 'android/src/org/linaro/glmark2/Glmark2Activity.java'
@@ -57,7 +57,7 @@
new DialogInterface.OnClickListener() {
public void onClick(DialogInterface dialog, int id) {
Glmark2Activity.this.finish();
- /*
+ /*
* Force process shutdown. There is no safer way to
* do this, as we have open threads we can't close
* when we fail to get an EGLConfig
=== modified file 'android/src/org/linaro/glmark2/Glmark2SurfaceView.java'
@@ -18,7 +18,7 @@
mActivity = activity;
setEGLContextClientVersion(2);
-
+
// Uncomment the commands below to get an RGBA8888 surface and config.
//this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
//setEGLConfigChooser(new Glmark2ConfigChooser(8, 8, 8, 8, 16, 0));
@@ -96,7 +96,7 @@
throw new IllegalArgumentException("eglChooseConfig#2 failed");
}
- /*
+ /*
* Try to find a config that matches exactly the RGBA size
* specified by the user and is >= for depth and stencil.
*/
=== modified file 'data/shaders/bump-normals.frag'
@@ -17,7 +17,7 @@
vec3 normal_raw = texture2D(NormalMap, TextureCoord).xyz;
// Map "color" range [0, 1.0] to normal range [-1.0, 1.0]
vec3 normal_scaled = normal_raw * 2.0 - 1.0;
-
+
// Convert the normal to eye coordinates. Note that the normal map
// we are using is using object coordinates (not tangent!) for the
// normals, so we can multiply by the NormalMatrix as usual.
=== modified file 'data/shaders/light-phong.vert'
@@ -9,7 +9,7 @@
varying vec4 vertex_position;
void main(void)
-{
+{
vec4 current_position = vec4(position, 1.0);
// Transform the normal to eye coordinates
=== modified file 'src/benchmark.cpp'
@@ -28,7 +28,7 @@
using std::vector;
using std::map;
-std::map<string, Scene *> Benchmark::mSceneMap;
+std::map<string, Scene *> Benchmark::sceneMap_;
static Scene &
get_scene_from_description(const string &s)
@@ -37,7 +37,7 @@
Util::split(s, ':', elems);
- const string &name = !elems.empty() ? elems[0] : "";
+ const string &name = !elems.empty() ? elems[0] : "";
return Benchmark::get_scene_by_name(name);
}
@@ -71,7 +71,7 @@
void
Benchmark::register_scene(Scene &scene)
{
- mSceneMap[scene.name()] = &scene;
+ sceneMap_[scene.name()] = &scene;
}
Scene &
@@ -79,55 +79,55 @@
{
map<string, Scene *>::const_iterator iter;
- if ((iter = mSceneMap.find(name)) != mSceneMap.end())
+ if ((iter = sceneMap_.find(name)) != sceneMap_.end())
return *(iter->second);
else
return Scene::dummy();
}
Benchmark::Benchmark(Scene &scene, const vector<OptionPair> &options) :
- mScene(scene), mOptions(options)
+ scene_(scene), options_(options)
{
}
Benchmark::Benchmark(const string &name, const vector<OptionPair> &options) :
- mScene(Benchmark::get_scene_by_name(name)), mOptions(options)
+ scene_(Benchmark::get_scene_by_name(name)), options_(options)
{
}
Benchmark::Benchmark(const string &s) :
- mScene(get_scene_from_description(s)),
- mOptions(get_options_from_description(s))
+ scene_(get_scene_from_description(s)),
+ options_(get_options_from_description(s))
{
}
Scene &
Benchmark::setup_scene()
{
- mScene.reset_options();
+ scene_.reset_options();
load_options();
- mScene.load();
- mScene.setup();
+ scene_.load();
+ scene_.setup();
- return mScene;
+ return scene_;
}
void
Benchmark::teardown_scene()
{
- mScene.teardown();
- mScene.unload();
+ scene_.teardown();
+ scene_.unload();
}
void
Benchmark::load_options()
{
- for (vector<OptionPair>::iterator iter = mOptions.begin();
- iter != mOptions.end();
+ for (vector<OptionPair>::iterator iter = options_.begin();
+ iter != options_.end();
iter++)
{
- mScene.set_option(iter->first, iter->second);
+ scene_.set_option(iter->first, iter->second);
}
}
=== modified file 'src/benchmark.h'
@@ -44,15 +44,15 @@
static void register_scene(Scene &scene);
static Scene &get_scene_by_name(const std::string &name);
- static const std::map<std::string, Scene *> &scenes() { return mSceneMap; }
+ static const std::map<std::string, Scene *> &scenes() { return sceneMap_; }
private:
- Scene &mScene;
- std::vector<OptionPair> mOptions;
+ Scene &scene_;
+ std::vector<OptionPair> options_;
void load_options();
- static std::map<std::string, Scene *> mSceneMap;
+ static std::map<std::string, Scene *> sceneMap_;
};
#endif
=== modified file 'src/canvas-android.cpp'
@@ -18,6 +18,7 @@
*
* Authors:
* Alexandros Frantzis (glmark2)
+ * Jesse Barker
*/
#include "canvas-android.h"
#include "log.h"
@@ -28,10 +29,14 @@
#include <fstream>
#include <sstream>
+/******************
+ * Public methods *
+ ******************/
+
bool
CanvasAndroid::init()
{
- resize(mWidth, mHeight);
+ resize(width_, height_);
if (!eglSwapInterval(eglGetCurrentDisplay(), 0))
Log::info("** Failed to set swap interval. Results may be bounded above by refresh rate.\n");
@@ -51,7 +56,7 @@
void
CanvasAndroid::visible(bool visible)
{
- (void)visible;
+ static_cast<void>(visible);
}
void
@@ -93,15 +98,15 @@
void
CanvasAndroid::write_to_file(std::string &filename)
{
- char *pixels = new char[mWidth * mHeight * 4];
+ char *pixels = new char[width_ * height_ * 4];
- for (int i = 0; i < mHeight; i++) {
- glReadPixels(0, i, mWidth, 1, GL_RGBA, GL_UNSIGNED_BYTE,
- &pixels[(mHeight - i - 1) * mWidth * 4]);
+ for (int i = 0; i < height_; i++) {
+ glReadPixels(0, i, width_, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+ &pixels[(height_ - i - 1) * width_ * 4]);
}
std::ofstream output (filename.c_str(), std::ios::out | std::ios::binary);
- output.write(pixels, 4 * mWidth * mHeight);
+ output.write(pixels, 4 * width_ * height_);
delete [] pixels;
}
@@ -115,14 +120,18 @@
void
CanvasAndroid::resize(int width, int height)
{
- mWidth = width;
- mHeight = height;
+ width_ = width;
+ height_ = height;
- glViewport(0, 0, mWidth, mHeight);
- mProjection = LibMatrix::Mat4::perspective(60.0, mWidth / (float)mHeight,
+ glViewport(0, 0, width_, height_);
+ projection_ = LibMatrix::Mat4::perspective(60.0, width_ / static_cast<float>(height_),
1.0, 1024.0);
}
+/*******************
+ * Private methods *
+ *******************/
+
void
CanvasAndroid::init_gl_extensions()
{
@@ -138,9 +147,9 @@
}
if (extString.find("GL_OES_mapbuffer") != std::string::npos) {
- GLExtensions::MapBuffer =
+ GLExtensions::MapBuffer =
reinterpret_cast<PFNGLMAPBUFFEROESPROC>(eglGetProcAddress("glMapBufferOES"));
- GLExtensions::UnmapBuffer =
+ GLExtensions::UnmapBuffer =
reinterpret_cast<PFNGLUNMAPBUFFEROESPROC>(eglGetProcAddress("glUnmapBufferOES"));
}
}
=== modified file 'src/canvas-android.h'
@@ -24,6 +24,13 @@
#include "canvas.h"
+/**
+ * Canvas for rendering to Android surfaces.
+ *
+ * This class doesn't perform any GLES2.0 surface and context management
+ * (contrary to the CanvasX11* classes); these are handled in the Java
+ * Android code.
+ */
class CanvasAndroid : public Canvas
{
public:
=== modified file 'src/canvas-x11-egl.cpp'
@@ -61,6 +61,28 @@
return vis_info;
}
+bool
+CanvasX11EGL::make_current()
+{
+ if (!ensure_egl_surface())
+ return false;
+
+ if (egl_context_ == eglGetCurrentContext())
+ return true;
+
+ if (!eglMakeCurrent(egl_display_, egl_surface_, egl_surface_, egl_context_)) {
+ Log::error("Error: eglMakeCurrent failed with error %d\n", eglGetError());
+ return false;
+ }
+
+ if (!eglSwapInterval(egl_display_, 0))
+ Log::info("** Failed to set swap interval. Results may be bounded above by refresh rate.\n");
+
+ init_gl_extensions();
+
+ return true;
+}
+
/*******************
* Private methods *
*******************/
@@ -210,9 +232,9 @@
}
if (extString.find("GL_OES_mapbuffer") != std::string::npos) {
- GLExtensions::MapBuffer =
+ GLExtensions::MapBuffer =
reinterpret_cast<PFNGLMAPBUFFEROESPROC>(eglGetProcAddress("glMapBufferOES"));
- GLExtensions::UnmapBuffer =
+ GLExtensions::UnmapBuffer =
reinterpret_cast<PFNGLUNMAPBUFFEROESPROC>(eglGetProcAddress("glUnmapBufferOES"));
}
#elif USE_GL
@@ -220,25 +242,3 @@
GLExtensions::UnmapBuffer = glUnmapBuffer;
#endif
}
-
-bool
-CanvasX11EGL::make_current()
-{
- if (!ensure_egl_surface())
- return false;
-
- if (egl_context_ == eglGetCurrentContext())
- return true;
-
- if (!eglMakeCurrent(egl_display_, egl_surface_, egl_surface_, egl_context_)) {
- Log::error("eglMakeCurrent failed with error %d\n", eglGetError());
- return false;
- }
-
- if (!eglSwapInterval(egl_display_, 0))
- Log::info("** Failed to set swap interval. Results may be bounded above by refresh rate.\n");
-
- init_gl_extensions();
-
- return true;
-}
=== modified file 'src/canvas-x11-egl.h'
@@ -26,6 +26,9 @@
#include <EGL/egl.h>
+/**
+ * Canvas for rendering to an X11 window using EGL.
+ */
class CanvasX11EGL : public CanvasX11
{
public:
=== modified file 'src/canvas-x11-glx.cpp'
@@ -102,7 +102,7 @@
extString = exts;
}
- /*
+ /*
* GLX_EXT_swap_control or GL_MESA_swap_control. Note that
* GLX_SGI_swap_control is not enough because it doesn't allow 0 as a valid
* value (i.e. you can't turn off VSync).
=== modified file 'src/canvas-x11-glx.h'
@@ -28,6 +28,9 @@
#include <GL/glx.h>
#include <GL/glxext.h>
+/**
+ * Canvas for rendering to an X11 window using GLX.
+ */
class CanvasX11GLX : public CanvasX11
{
public:
=== modified file 'src/canvas-x11.cpp'
@@ -18,6 +18,7 @@
*
* Authors:
* Alexandros Frantzis (glmark2)
+ * Jesse Barker
*/
#include "canvas-x11.h"
#include "log.h"
@@ -28,47 +29,9 @@
#include <fstream>
#include <sstream>
-static Window
-create_canvas_x_window(Display *xdpy, const char *name, int width, int height,
- const XVisualInfo *vis_info)
-{
- XSetWindowAttributes attr;
- unsigned long mask;
- Window win = 0;
- Window root = RootWindow(xdpy, DefaultScreen(xdpy));
-
- Log::debug("Creating XWindow W: %d H: %d VisualID: 0x%x\n",
- width, height, (int)vis_info->visualid);
- /* window attributes */
- attr.background_pixel = 0;
- attr.border_pixel = 0;
- attr.colormap = XCreateColormap(xdpy, root, vis_info->visual, AllocNone);
- attr.event_mask = KeyPressMask;
- mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
-
- win = XCreateWindow(xdpy, root, 0, 0, width, height,
- 0, vis_info->depth, InputOutput,
- vis_info->visual, mask, &attr);
-
- /* set hints and properties */
- {
- XSizeHints sizehints;
- sizehints.min_width = width;
- sizehints.min_height = height;
- sizehints.max_width = width;
- sizehints.max_height = height;
- sizehints.flags = PMaxSize | PMinSize;
- XSetNormalHints(xdpy, win, &sizehints);
- XSetStandardProperties(xdpy, win, name, name,
- None, NULL, 0, &sizehints);
- }
-
- /* Gracefully handle Window Delete event from window manager */
- Atom wmDelete = XInternAtom(xdpy, "WM_DELETE_WINDOW", True);
- XSetWMProtocols(xdpy, win, &wmDelete, 1);
-
- return win;
-}
+/******************
+ * Public methods *
+ ******************/
bool
CanvasX11::init()
@@ -77,7 +40,7 @@
if (!xdpy_)
return false;
- resize(mWidth, mHeight);
+ resize(width_, height_);
if (!xwin_)
return false;
@@ -158,22 +121,22 @@
void
CanvasX11::write_to_file(std::string &filename)
{
- char *pixels = new char[mWidth * mHeight * 4];
+ char *pixels = new char[width_ * height_ * 4];
- for (int i = 0; i < mHeight; i++) {
- glReadPixels(0, i, mWidth, 1, GL_RGBA, GL_UNSIGNED_BYTE,
- &pixels[(mHeight - i - 1) * mWidth * 4]);
+ for (int i = 0; i < height_; i++) {
+ glReadPixels(0, i, width_, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+ &pixels[(height_ - i - 1) * width_ * 4]);
}
std::ofstream output (filename.c_str(), std::ios::out | std::ios::binary);
- output.write(pixels, 4 * mWidth * mHeight);
+ output.write(pixels, 4 * width_ * height_);
delete [] pixels;
}
bool
CanvasX11::should_quit()
-{
+{
XEvent event;
if (!XPending(xdpy_))
@@ -198,7 +161,7 @@
{
/* Recreate an existing window only if it has actually been resized */
if (xwin_) {
- if (mWidth != width || mHeight != height) {
+ if (width_ != width || height_ != height) {
XDestroyWindow(xdpy_, xwin_);
xwin_ = 0;
}
@@ -207,23 +170,20 @@
}
}
- mWidth = width;
- mHeight = height;
-
- XVisualInfo *visinfo = get_xvisualinfo();
-
- xwin_ = create_canvas_x_window(xdpy_, "glmark2 "GLMARK_VERSION, mWidth, mHeight, visinfo);
-
- XFree(visinfo);
-
- glViewport(0, 0, mWidth, mHeight);
- mProjection = LibMatrix::Mat4::perspective(60.0, mWidth / (float)mHeight,
+ width_ = width;
+ height_ = height;
+
+ if (!ensure_x_window())
+ Log::error("Error: Couldn't create X Window!\n");
+
+ glViewport(0, 0, width_, height_);
+ projection_ = LibMatrix::Mat4::perspective(60.0, width_ / static_cast<float>(height_),
1.0, 1024.0);
}
bool
CanvasX11::supports_gl2()
-{
+{
std::string gl_version_str(reinterpret_cast<const char*>(glGetString(GL_VERSION)));
int gl_major(0);
@@ -238,10 +198,78 @@
else
start_pos++;
- std::stringstream ss;
- ss << gl_version_str.substr(start_pos, point_pos - start_pos + 1);
- ss >> gl_major;
+ gl_major = Util::fromString<int>(
+ gl_version_str.substr(start_pos, point_pos - start_pos + 1)
+ );
}
return gl_major >= 2;
}
+
+/*******************
+ * Private methods *
+ *******************/
+
+bool
+CanvasX11::ensure_x_window()
+{
+ if (xwin_)
+ return true;
+
+ if (!xdpy_) {
+ Log::error("Error: X11 Display has not been initialized!\n");
+ return false;
+ }
+
+ XVisualInfo *vis_info = get_xvisualinfo();
+ if (!vis_info) {
+ Log::error("Error: Could not get a valid XVisualInfo!\n");
+ return false;
+ }
+
+ Log::debug("Creating XWindow W: %d H: %d VisualID: 0x%x\n",
+ width_, height_, vis_info->visualid);
+
+ /* window attributes */
+ XSetWindowAttributes attr;
+ unsigned long mask;
+ Window root = RootWindow(xdpy_, DefaultScreen(xdpy_));
+
+ attr.background_pixel = 0;
+ attr.border_pixel = 0;
+ attr.colormap = XCreateColormap(xdpy_, root, vis_info->visual, AllocNone);
+ attr.event_mask = KeyPressMask;
+ mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+
+ xwin_ = XCreateWindow(xdpy_, root, 0, 0, width_, height_,
+ 0, vis_info->depth, InputOutput,
+ vis_info->visual, mask, &attr);
+
+ XFree(vis_info);
+
+ if (!xwin_) {
+ Log::error("Error: XCreateWindow() failed!\n");
+ return false;
+ }
+
+ /* set hints and properties */
+ {
+ static const char *name("glmark2 "GLMARK_VERSION);
+ XSizeHints sizehints;
+ sizehints.min_width = width_;
+ sizehints.min_height = height_;
+ sizehints.max_width = width_;
+ sizehints.max_height = height_;
+ sizehints.flags = PMaxSize | PMinSize;
+ XSetNormalHints(xdpy_, xwin_, &sizehints);
+ XSetStandardProperties(xdpy_, xwin_, name, name,
+ None, NULL, 0, &sizehints);
+ }
+
+ /* Gracefully handle Window Delete event from window manager */
+ Atom wmDelete = XInternAtom(xdpy_, "WM_DELETE_WINDOW", True);
+ XSetWMProtocols(xdpy_, xwin_, &wmDelete, 1);
+
+ return true;
+}
+
=== modified file 'src/canvas-x11.h'
@@ -26,6 +26,9 @@
#include <X11/Xlib.h>
#include <X11/Xutil.h>
+/**
+ * Canvas for rendering with GL to an X11 window.
+ */
class CanvasX11 : public Canvas
{
public:
@@ -45,13 +48,50 @@
CanvasX11(int width, int height) :
Canvas(width, height), xwin_(0), xdpy_(0) {}
+ /**
+ * Gets the XVisualInfo to use for creating the X window with.
+ *
+ * The caller should XFree() the returned XVisualInfo when done.
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @return the XVisualInfo
+ */
virtual XVisualInfo *get_xvisualinfo() = 0;
+
+ /**
+ * Makes the canvas the current target for GL rendering.
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @return whether the operation succeeded
+ */
virtual bool make_current() = 0;
+
+ /**
+ * Swaps the GL buffers (assuming double buffering is used).
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @return whether the operation succeeded
+ */
virtual void swap_buffers() = 0;
+
+ /**
+ * Whether the current implementation supports GL(ES) 2.0.
+ *
+ * @return true if it supports GL(ES) 2.0, false otherwise
+ */
bool supports_gl2();
+
+ /** The X window associated with this canvas. */
Window xwin_;
+ /** The X display associated with this canvas. */
Display *xdpy_;
+
+private:
+ bool ensure_x_window();
};
#endif
=== modified file 'src/canvas.h'
@@ -20,6 +20,7 @@
* Authors:
* Ben Smith (original glmark benchmark)
* Alexandros Frantzis (glmark2)
+ * Jesse Barker
*/
#ifndef GLMARK2_CANVAS_H_
#define GLMARK2_CANVAS_H_
@@ -31,16 +32,27 @@
#include <string>
#include <stdio.h>
+/**
+ * Abstraction for a GL rendering target.
+ */
class Canvas
{
public:
virtual ~Canvas() {}
+ /**
+ * A pixel value.
+ */
struct Pixel {
Pixel():
r(0), g(0), b(0), a(0) {}
Pixel(uint8_t r, uint8_t g, uint8_t b, uint8_t a):
r(r), g(g), b(b), a(a) {}
+ /**
+ * Gets the pixel value as a 32-bit integer in 0xAABBGGRR format.
+ *
+ * @return the pixel value
+ */
uint32_t to_le32()
{
return static_cast<uint32_t>(r) +
@@ -55,37 +67,140 @@
uint8_t a;
};
+ /**
+ * Initializes the canvas and makes it the target of GL operations.
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @return whether initialization succeeded
+ */
virtual bool init() { return false; }
- virtual void visible(bool visible) { (void)visible; }
+
+ /**
+ * Changes the visibility of the canvas.
+ *
+ * The canvas is initially not visible.
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @param visible true to make the Canvas visible, false otherwise
+ */
+ virtual void visible(bool visible) { static_cast<void>(visible); }
+
+ /**
+ * Clears the canvas.
+ * This method should be implemented in derived classes.
+ */
virtual void clear() {}
+
+ /**
+ * Ensures that the canvas on-screen representation gets updated
+ * with the latest canvas contents.
+ *
+ * This method should be implemented in derived classes.
+ */
virtual void update() {}
+
+ /**
+ * Prints information about the canvas.
+ *
+ * This method should be implemented in derived classes.
+ */
virtual void print_info() {}
+
+ /**
+ * Reads a pixel from the canvas.
+ *
+ * The (0, 0) point is the lower left corner. The X and Y coordinates
+ * increase towards the right and top, respectively.
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @param x the X coordinate
+ * @param y the Y coordinate
+ *
+ * @return the pixel
+ */
virtual Pixel read_pixel(int x, int y)
{
- (void)x;
- (void)y;
+ static_cast<void>(x);
+ static_cast<void>(y);
return Pixel();
}
- virtual void write_to_file(std::string &filename) { (void)filename; }
+
+ /**
+ * Writes the canvas contents to a file.
+ *
+ * The pixel save order is upper left to lower right. Each pixel value
+ * is stored as four consecutive bytes R,G,B,A.
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @param filename the name of the file to write to
+ */
+ virtual void write_to_file(std::string &filename) { static_cast<void>(filename); }
+
+ /**
+ * Whether we should quit the application.
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @return true if we should quit, false otherwise
+ */
virtual bool should_quit() { return false; }
- virtual void resize(int width, int height) { (void)width; (void)height; }
-
+
+ /**
+ * Resizes the canvas.
+ *
+ * This method should be implemented in derived classes.
+ *
+ * @param width the new width in pixels
+ * @param height the new height in pixels
+ *
+ * @return true if we should quit, false otherwise
+ */
+ virtual void resize(int width, int height) { static_cast<void>(width); static_cast<void>(height); }
+
+ /**
+ * Gets a dummy canvas object.
+ *
+ * @return the dummy canvas
+ */
static Canvas &dummy()
{
static Canvas dummy_canvas(0, 0);
return dummy_canvas;
}
- int width() { return mWidth; }
- int height() { return mHeight; }
- const LibMatrix::mat4 &projection() { return mProjection; }
+ /**
+ * Gets the width of the canvas.
+ *
+ * @return the width in pixels
+ */
+ int width() { return width_; }
+
+ /**
+ * Gets the height of the canvas.
+ *
+ * @return the height in pixels
+ */
+ int height() { return height_; }
+
+ /**
+ * Gets the projection matrix recommended for use with the canvas.
+ *
+ * It's not mandatory to use this projection matrix.
+ *
+ * @return the projection matrix
+ */
+ const LibMatrix::mat4 &projection() { return projection_; }
protected:
- Canvas(int width, int height) : mWidth(width), mHeight(height) {}
+ Canvas(int width, int height) : width_(width), height_(height) {}
- int mWidth;
- int mHeight;
- LibMatrix::mat4 mProjection;
+ int width_;
+ int height_;
+ LibMatrix::mat4 projection_;
};
#endif
=== modified file 'src/gl-headers.h'
@@ -35,7 +35,7 @@
#endif
#endif
-/**
+/**
* Struct that holds pointers to functions that belong to extensions
* in either GL2.0 or GLES2.0.
*/
=== modified file 'src/main.cpp'
@@ -162,7 +162,7 @@
Log::info(" [Option] %s\n"
" Description : %s\n"
" Default Value: %s\n",
- opt.name.c_str(),
+ opt.name.c_str(),
opt.description.c_str(),
opt.default_value.c_str());
}
@@ -258,7 +258,8 @@
}
}
-int main(int argc, char *argv[])
+int
+main(int argc, char *argv[])
{
if (!Options::parse_args(argc, argv))
=== modified file 'src/mesh.cpp'
@@ -80,14 +80,14 @@
bool
-Mesh::check_attrib(int pos, int size)
+Mesh::check_attrib(unsigned int pos, int dim)
{
- if (pos > (int)vertex_format_.size()) {
+ if (pos > vertex_format_.size()) {
Log::error("Trying to set non-existent attribute\n");
return false;
}
- if (vertex_format_[pos].first != size) {
+ if (vertex_format_[pos].first != dim) {
Log::error("Trying to set attribute with value of invalid type\n");
return false;
}
@@ -114,7 +114,7 @@
* etc
*/
void
-Mesh::set_attrib(int pos, const LibMatrix::vec2 &v, std::vector<float> *vertex)
+Mesh::set_attrib(unsigned int pos, const LibMatrix::vec2 &v, std::vector<float> *vertex)
{
if (!check_attrib(pos, 2))
return;
@@ -128,7 +128,7 @@
}
void
-Mesh::set_attrib(int pos, const LibMatrix::vec3 &v, std::vector<float> *vertex)
+Mesh::set_attrib(unsigned int pos, const LibMatrix::vec3 &v, std::vector<float> *vertex)
{
if (!check_attrib(pos, 3))
return;
@@ -143,7 +143,7 @@
}
void
-Mesh::set_attrib(int pos, const LibMatrix::vec4 &v, std::vector<float> *vertex)
+Mesh::set_attrib(unsigned int pos, const LibMatrix::vec4 &v, std::vector<float> *vertex)
{
if (!check_attrib(pos, 4))
return;
@@ -206,7 +206,7 @@
vbo_usage_ = usage;
}
-/**
+/**
* Sets the vertex attribute interleaving mode.
*
* If true the vertex attributes are going to be interleaved in a single
@@ -215,7 +215,7 @@
*
* Interleaving mode takes effect in the next call to ::build_array() or
* ::build_vbo().
- *
+ *
* @param interleave whether to interleave
*/
void
=== modified file 'src/mesh.h'
@@ -40,9 +40,9 @@
void set_vertex_format(const std::vector<int> &format);
void set_attrib_locations(const std::vector<int> &locations);
- void set_attrib(int pos, const LibMatrix::vec2 &v, std::vector<float> *vertex = 0);
- void set_attrib(int pos, const LibMatrix::vec3 &v, std::vector<float> *vertex = 0);
- void set_attrib(int pos, const LibMatrix::vec4 &v, std::vector<float> *vertex = 0);
+ void set_attrib(unsigned int pos, const LibMatrix::vec2 &v, std::vector<float> *vertex = 0);
+ void set_attrib(unsigned int pos, const LibMatrix::vec3 &v, std::vector<float> *vertex = 0);
+ void set_attrib(unsigned int pos, const LibMatrix::vec4 &v, std::vector<float> *vertex = 0);
void next_vertex();
std::vector<std::vector<float> >& vertices();
@@ -81,13 +81,25 @@
double spacing, grid_configuration_func conf_func = 0);
private:
- bool check_attrib(int pos, int size);
+ // check_attrib ensures that the attribute at the specified position is of
+ // the correct dimensionality (see the description of vertex_format_ below).
+ bool check_attrib(unsigned int pos, int dim);
std::vector<float> &ensure_vertex();
void update_single_array(const std::vector<std::pair<size_t, size_t> >& ranges,
size_t n, size_t nfloats, size_t offset);
void update_single_vbo(const std::vector<std::pair<size_t, size_t> >& ranges,
size_t n, size_t nfloats);
+ //
+ // vertex_format_ is a vector of pairs describing the attribute data.
+ // pair.first is the dimension of the attribute (vec2, vec3, vec4) and
+ // pair.second is the number of float values into the vertex data of that
+ // attribute. So, for example, if there are 3 attributes, a vec3 position
+ // a vec3 normal and a vec2 texture coordinate, you would have a
+ // vertex_format_ with 3 elements as follows: {<3, 0>, <3, 3>, <2, 6>} and
+ // the total size of each vertex would be the sum of the dimensions times
+ // the size of a float, or: 8 * sizeof(float) == 32 bytes
+ //
std::vector<std::pair<int, int> > vertex_format_;
std::vector<int> attrib_locations_;
int vertex_size_;
=== modified file 'src/model.cpp'
@@ -21,6 +21,7 @@
* Ben Smith (original glmark benchmark)
* Alexandros Frantzis (glmark2)
*/
+#include "mesh.h"
#include "model.h"
#include "vec.h"
#include "log.h"
@@ -376,15 +377,6 @@
return true;
}
-template<typename T> T
-fromString(const string& asString)
-{
- std::stringstream ss(asString);
- T retVal;
- ss >> retVal;
- return retVal;
-}
-
void
get_values(const string& source, vec3& v)
{
@@ -406,7 +398,7 @@
}
string::size_type numChars(endPos - startPos);
string xs(source, startPos, numChars);
- float x = fromString<float>(xs);
+ float x = Util::fromString<float>(xs);
// Then the second value...
startPos = endPos + 1;
endPos = source.find(" ", startPos);
@@ -417,7 +409,7 @@
}
numChars = endPos - startPos;
string ys(source, startPos, numChars);
- float y = fromString<float>(ys);
+ float y = Util::fromString<float>(ys);
// And the third value (there might be a fourth, but we don't care)...
startPos = endPos + 1;
endPos = source.find(" ", startPos);
@@ -430,10 +422,10 @@
numChars = endPos - startPos;
}
string zs(source, startPos, endPos - startPos);
- float z = fromString<float>(zs);
+ float z = Util::fromString<float>(zs);
v.x(x);
v.y(y);
- v.z(z);
+ v.z(z);
}
void
@@ -457,7 +449,7 @@
}
string::size_type numChars(endPos - startPos);
string xs(source, startPos, numChars);
- float x = fromString<float>(xs);
+ float x = Util::fromString<float>(xs);
// Then the second value (there might be a third, but we don't care)...
startPos = endPos + 1;
endPos = source.find(" ", startPos);
@@ -470,7 +462,7 @@
numChars = endPos - startPos;
}
string ys(source, startPos, numChars);
- float y = fromString<float>(ys);
+ float y = Util::fromString<float>(ys);
v.x(x);
v.y(y);
}
@@ -496,7 +488,7 @@
}
string::size_type numChars(endPos - startPos);
string xs(source, startPos, numChars);
- unsigned int x = fromString<unsigned int>(xs);
+ unsigned int x = Util::fromString<unsigned int>(xs);
// Then the second value...
startPos = endPos+1;
endPos = source.find(" ", startPos);
@@ -507,7 +499,7 @@
}
numChars = endPos - startPos;
string ys(source, startPos, numChars);
- unsigned int y = fromString<unsigned int>(ys);
+ unsigned int y = Util::fromString<unsigned int>(ys);
// And the third value (there might be a fourth, but we don't care)...
startPos = endPos + 1;
endPos = source.find(" ", startPos);
@@ -520,10 +512,10 @@
numChars = endPos - startPos;
}
string zs(source, startPos, numChars);
- unsigned int z = fromString<unsigned int>(zs);
+ unsigned int z = Util::fromString<unsigned int>(zs);
v.x(x);
v.y(y);
- v.z(z);
+ v.z(z);
}
bool
=== modified file 'src/model.h'
@@ -24,13 +24,13 @@
#ifndef GLMARK2_MODEL_H_
#define GLMARK2_MODEL_H_
-#include "mesh.h"
-
-#include <sys/stat.h>
-#include <stdio.h>
-#include <stdlib.h>
+#include <string>
#include <vector>
#include <map>
+#include "vec.h"
+
+// Forward declare the mesh object. We don't need the whole header here.
+class Mesh;
enum ModelFormat
{
@@ -46,7 +46,7 @@
ModelFormat format_;
ModelDescriptor();
public:
- ModelDescriptor(const std::string& name, ModelFormat format,
+ ModelDescriptor(const std::string& name, ModelFormat format,
const std::string& pathname) :
name_(name),
pathname_(pathname),
@@ -78,7 +78,7 @@
void calculate_normals();
void convert_to_mesh(Mesh &mesh);
- void convert_to_mesh(Mesh &mesh,
+ void convert_to_mesh(Mesh &mesh,
const std::vector<std::pair<AttribType, int> > &attribs);
const LibMatrix::vec3& minVec() const { return minVec_; }
const LibMatrix::vec3& maxVec() const { return maxVec_; }
=== modified file 'src/options.cpp'
@@ -54,11 +54,11 @@
{0, 0, 0, 0}
};
-/**
+/**
* Parses a size string of the form WxH
- *
+ *
* @param str the string to parse
- * @param size the parsed size (width, height)
+ * @param size the parsed size (width, height)
*/
static void
parse_size(const std::string &str, std::pair<int,int> &size)
@@ -66,19 +66,15 @@
std::vector<std::string> d;
Util::split(str, 'x', d);
- std::stringstream ss(d[0]);
- ss >> size.first;
+ size.first = Util::fromString<int>(d[0]);
/*
* Parse the second element (height). If there is none, use the value
* of the first element for the second (width = height)
*/
- if (d.size() > 1) {
- ss.clear();
- ss.str(d[1]);
- ss >> size.second;
- }
- else
+ if (d.size() > 1)
+ size.second = Util::fromString<int>(d[1]);
+ else
size.second = size.first;
}
=== modified file 'src/scene-buffer.cpp'
@@ -18,6 +18,7 @@
*
* Authors:
* Alexandros Frantzis (glmark2)
+ * Jesse Barker
*/
#include "scene.h"
#include "log.h"
@@ -32,7 +33,7 @@
* Wave implementation *
***********************/
-/**
+/**
* A callback used to set up the grid by the Wave class.
* It is called for each "quad" of the grid.
*/
@@ -43,9 +44,14 @@
LibMatrix::vec3 &ur,
LibMatrix::vec3 &lr)
{
- (void)x; (void)y; (void)n_x; (void)n_y;
+ // These parameters are unused in this instance of a virtual callback
+ // function.
+ static_cast<void>(x);
+ static_cast<void>(y);
+ static_cast<void>(n_x);
+ static_cast<void>(n_y);
- /*
+ /*
* Order matters here, so that Wave::vertex_length_index() can work.
* Vertices of the triangles at index i that belong to length index i
* are even, those that belong to i + 1 are odd.
@@ -56,7 +62,7 @@
for (int i = 0; i < 6; i++) {
mesh.next_vertex();
- /*
+ /*
* Set the vertex position and the three vertex positions
* of the triangle this vertex belongs to.
*/
@@ -67,15 +73,15 @@
}
}
-/**
+/**
* Renders a grid mesh modulated by a sine wave
*/
class WaveMesh
{
public:
- /**
+ /**
* Creates a wave mesh.
- *
+ *
* @param length the total length of the grid (in model coordinates)
* @param width the total width of the grid (in model coordinates)
* @param nlength the number of length-wise grid subdivisions
@@ -98,9 +104,9 @@
~WaveMesh() { reset(); }
- /**
+ /**
* Updates the state of a wave mesh.
- *
+ *
* @param elapsed the time elapsed since the beginning of the rendering
*/
void update(double elapsed)
@@ -134,7 +140,7 @@
{
/* First vertex of length index range */
size_t vstart(iter->first * nwidth_ * 6 + (iter->first % 2));
- /*
+ /*
* First vertex not included in the range. We should also update all
* vertices of triangles touching index i.
*/
@@ -182,7 +188,7 @@
std::vector<double> displacement_;
- /**
+ /**
* Calculates the length index of a vertex.
*/
size_t vertex_length_index(size_t v)
@@ -190,11 +196,11 @@
return v / (6 * nwidth_) + (v % 2);
}
- /**
+ /**
* The sine wave function with duty-cycle.
*
* @param x the space coordinate
- *
+ *
* @return the operation error code
*/
double wave_func(double x)
@@ -203,10 +209,10 @@
if (r < 0)
r += wave_full_period_;
- /*
+ /*
* Return either the sine value or 0.0, depending on the
* wave duty cycle.
- */
+ */
if (r > wave_period_)
{
return 0;
@@ -217,12 +223,12 @@
}
}
- /**
+ /**
* Calculates the displacement of the wave.
- *
+ *
* @param n the length index
* @param elapsed the time elapsed since the beginning of the rendering
- *
+ *
* @return the displacement at point n at time elapsed
*/
double displacement(size_t n, double elapsed)
@@ -232,7 +238,7 @@
return wave_func(x - wave_velocity_ * elapsed);
}
- /**
+ /**
* Creates the GL shader program.
*/
void create_program()
@@ -253,12 +259,12 @@
}
}
- /**
+ /**
* Creates the grid mesh.
*/
void create_mesh()
{
- /*
+ /*
* We need to pass the positions of all vertex of the triangle
* in order to draw the wireframe.
*/
@@ -295,19 +301,19 @@
Scene(pCanvas, "buffer")
{
priv_ = new SceneBufferPrivate();
- mOptions["interleave"] = Scene::Option("interleave", "false",
+ options_["interleave"] = Scene::Option("interleave", "false",
"Whether to interleave vertex attribute data [true,false]");
- mOptions["update-method"] = Scene::Option("update-method", "map",
+ options_["update-method"] = Scene::Option("update-method", "map",
"[map,subdata]");
- mOptions["update-fraction"] = Scene::Option("update-fraction", "1.0",
+ options_["update-fraction"] = Scene::Option("update-fraction", "1.0",
"The fraction of the mesh length that is updated at every iteration (0.0-1.0)");
- mOptions["update-dispersion"] = Scene::Option("update-dispersion", "0.0",
+ options_["update-dispersion"] = Scene::Option("update-dispersion", "0.0",
"How dispersed the updates are [0.0 - 1.0]");
- mOptions["columns"] = Scene::Option("columns", "100",
+ options_["columns"] = Scene::Option("columns", "100",
"The number of mesh subdivisions length-wise");
- mOptions["rows"] = Scene::Option("rows", "20",
+ options_["rows"] = Scene::Option("rows", "20",
"The number of mesh subdisivisions width-wise");
- mOptions["buffer-usage"] = Scene::Option("buffer-usage", "static",
+ options_["buffer-usage"] = Scene::Option("buffer-usage", "static",
"How the buffer will be used [static,stream,dynamic]");
}
@@ -319,7 +325,7 @@
int
SceneBuffer::load()
{
- mRunning = false;
+ running_ = false;
return 1;
}
@@ -336,7 +342,7 @@
Scene::setup();
- bool interleave = (mOptions["interleave"].value == "true");
+ bool interleave = (options_["interleave"].value == "true");
Mesh::VBOUpdateMethod update_method;
Mesh::VBOUsage usage;
double update_fraction;
@@ -344,32 +350,24 @@
size_t nlength;
size_t nwidth;
- if (mOptions["update-method"].value == "map")
+ if (options_["update-method"].value == "map")
update_method = Mesh::VBOUpdateMethodMap;
- else if (mOptions["update-method"].value == "subdata")
+ else if (options_["update-method"].value == "subdata")
update_method = Mesh::VBOUpdateMethodSubData;
else
update_method = Mesh::VBOUpdateMethodMap;
- if (mOptions["buffer-usage"].value == "static")
+ if (options_["buffer-usage"].value == "static")
usage = Mesh::VBOUsageStatic;
- else if (mOptions["buffer-usage"].value == "stream")
+ else if (options_["buffer-usage"].value == "stream")
usage = Mesh::VBOUsageStream;
else
usage = Mesh::VBOUsageDynamic;
- std::stringstream ss;
- ss << mOptions["update-fraction"].value;
- ss >> update_fraction;
- ss.clear();
- ss << mOptions["update-dispersion"].value;
- ss >> update_dispersion;
- ss.clear();
- ss << mOptions["columns"].value;
- ss >> nlength;
- ss.clear();
- ss << mOptions["rows"].value;
- ss >> nwidth;
+ update_fraction = Util::fromString<double>(options_["update-fraction"].value);
+ update_dispersion = Util::fromString<double>(options_["update-dispersion"].value);
+ nlength = Util::fromString<size_t>(options_["columns"].value);
+ nwidth = Util::fromString<size_t>(options_["rows"].value);
if (update_method == Mesh::VBOUpdateMethodMap &&
(GLExtensions::MapBuffer == 0 || GLExtensions::UnmapBuffer == 0))
@@ -389,14 +387,14 @@
priv_->wave->mesh().build_vbo();
priv_->wave->program().start();
- priv_->wave->program()["Viewport"] = LibMatrix::vec2(mCanvas.width(), mCanvas.height());
+ priv_->wave->program()["Viewport"] = LibMatrix::vec2(canvas_.width(), canvas_.height());
glDisable(GL_CULL_FACE);
- mCurrentFrame = 0;
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ currentFrame_ = 0;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
void
@@ -414,18 +412,18 @@
SceneBuffer::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double elapsed_time = current_time - mStartTime;
-
- mLastUpdateTime = current_time;
-
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
+ double elapsed_time = current_time - startTime_;
+
+ lastUpdateTime_ = current_time;
+
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
}
priv_->wave->update(elapsed_time);
- mCurrentFrame++;
+ currentFrame_++;
}
void
@@ -434,7 +432,7 @@
LibMatrix::Stack4 model_view;
// Load the ModelViewProjectionMatrix uniform in the shader
- LibMatrix::mat4 model_view_proj(mCanvas.projection());
+ LibMatrix::mat4 model_view_proj(canvas_.projection());
model_view.translate(0.0, 0.0, -4.0);
model_view.rotate(45.0, -1.0, 0.0, 0.0);
model_view_proj *= model_view.getCurrent();
=== modified file 'src/scene-build.cpp'
@@ -30,7 +30,7 @@
SceneBuild::SceneBuild(Canvas &pCanvas) :
Scene(pCanvas, "build"),
- mOrientModel(false)
+ orientModel_(false)
{
const ModelMap& modelMap = Model::find_models();
std::string optionDesc("Which model to use [");
@@ -48,11 +48,11 @@
doSeparator = true;
}
optionDesc += "]";
- mOptions["use-vbo"] = Scene::Option("use-vbo", "true",
+ options_["use-vbo"] = Scene::Option("use-vbo", "true",
"Whether to use VBOs for rendering [true,false]");
- mOptions["interleave"] = Scene::Option("interleave", "false",
+ options_["interleave"] = Scene::Option("interleave", "false",
"Whether to interleave vertex attribute data [true,false]");
- mOptions["model"] = Scene::Option("model", "horse",
+ options_["model"] = Scene::Option("model", "horse",
optionDesc);
}
@@ -60,22 +60,24 @@
{
}
-int SceneBuild::load()
+int
+SceneBuild::load()
{
- mRotationSpeed = 36.0f;
+ rotationSpeed_ = 36.0f;
- mRunning = false;
+ running_ = false;
return 1;
}
-void SceneBuild::unload()
+void
+SceneBuild::unload()
{
- mMesh.reset();
-
+ mesh_.reset();
}
-void SceneBuild::setup()
+void
+SceneBuild::setup()
{
using LibMatrix::vec3;
@@ -93,14 +95,14 @@
vtx_source.add_const("LightSourcePosition", lightPosition);
vtx_source.add_const("MaterialDiffuse", materialDiffuse);
- if (!Scene::load_shaders_from_strings(mProgram, vtx_source.str(),
+ if (!Scene::load_shaders_from_strings(program_, vtx_source.str(),
frg_source.str()))
{
return;
}
Model model;
- const std::string& whichModel(mOptions["model"].value);
+ const std::string& whichModel(options_["model"].value);
bool modelLoaded = model.load(whichModel);
if(!modelLoaded)
@@ -123,9 +125,9 @@
// Horse rotates around the Y axis
if (whichModel == "buddha" || whichModel == "dragon")
{
- mOrientModel = true;
- mOrientationAngle = -90.0;
- mOrientationVec = vec3(1.0, 0.0, 0.0);
+ orientModel_ = true;
+ orientationAngle_ = -90.0;
+ orientationVec_ = vec3(1.0, 0.0, 0.0);
}
model.calculate_normals();
@@ -135,104 +137,106 @@
attribs.push_back(std::pair<Model::AttribType, int>(Model::AttribTypePosition, 3));
attribs.push_back(std::pair<Model::AttribType, int>(Model::AttribTypeNormal, 3));
- model.convert_to_mesh(mMesh, attribs);
+ model.convert_to_mesh(mesh_, attribs);
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- attrib_locations.push_back(mProgram["normal"].location());
- mMesh.set_attrib_locations(attrib_locations);
-
- mUseVbo = (mOptions["use-vbo"].value == "true");
- bool interleave = (mOptions["interleave"].value == "true");
-
- mMesh.vbo_update_method(Mesh::VBOUpdateMethodMap);
- mMesh.interleave(interleave);
-
- if (mUseVbo)
- mMesh.build_vbo();
+ attrib_locations.push_back(program_["position"].location());
+ attrib_locations.push_back(program_["normal"].location());
+ mesh_.set_attrib_locations(attrib_locations);
+
+ useVbo_ = (options_["use-vbo"].value == "true");
+ bool interleave = (options_["interleave"].value == "true");
+
+ mesh_.vbo_update_method(Mesh::VBOUpdateMethodMap);
+ mesh_.interleave(interleave);
+
+ if (useVbo_)
+ mesh_.build_vbo();
else
- mMesh.build_array();
+ mesh_.build_array();
/* Calculate a projection matrix that is a good fit for the model */
vec3 maxVec = model.maxVec();
vec3 minVec = model.minVec();
vec3 diffVec = maxVec - minVec;
- mCenterVec = maxVec + minVec;
- mCenterVec /= 2.0;
+ centerVec_ = maxVec + minVec;
+ centerVec_ /= 2.0;
float diameter = diffVec.length();
- mRadius = diameter / 2;
- float fovy = 2.0 * atanf(mRadius / (2.0 + mRadius));
+ radius_ = diameter / 2;
+ float fovy = 2.0 * atanf(radius_ / (2.0 + radius_));
fovy /= M_PI;
fovy *= 180.0;
- float aspect(static_cast<float>(mCanvas.width())/static_cast<float>(mCanvas.height()));
- mPerspective.setIdentity();
- mPerspective *= LibMatrix::Mat4::perspective(fovy, aspect, 2.0, 2.0 + diameter);
-
- mProgram.start();
-
- mCurrentFrame = 0;
- mRotation = 0.0;
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ float aspect(static_cast<float>(canvas_.width())/static_cast<float>(canvas_.height()));
+ perspective_.setIdentity();
+ perspective_ *= LibMatrix::Mat4::perspective(fovy, aspect, 2.0, 2.0 + diameter);
+
+ program_.start();
+
+ currentFrame_ = 0;
+ rotation_ = 0.0;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
void
SceneBuild::teardown()
{
- mProgram.stop();
- mProgram.release();
+ program_.stop();
+ program_.release();
- mMesh.reset();
+ mesh_.reset();
Scene::teardown();
}
-void SceneBuild::update()
+void
+SceneBuild::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double dt = current_time - mLastUpdateTime;
- double elapsed_time = current_time - mStartTime;
-
- mLastUpdateTime = current_time;
-
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
+ double dt = current_time - lastUpdateTime_;
+ double elapsed_time = current_time - startTime_;
+
+ lastUpdateTime_ = current_time;
+
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
}
- mRotation += mRotationSpeed * dt;
+ rotation_ += rotationSpeed_ * dt;
- mCurrentFrame++;
+ currentFrame_++;
}
-void SceneBuild::draw()
+void
+SceneBuild::draw()
{
LibMatrix::Stack4 model_view;
// Load the ModelViewProjectionMatrix uniform in the shader
- LibMatrix::mat4 model_view_proj(mPerspective);
- model_view.translate(-mCenterVec.x(), -mCenterVec.y(), -(mCenterVec.z() + 2.0 + mRadius));
- model_view.rotate(mRotation, 0.0f, 1.0f, 0.0f);
- if (mOrientModel)
+ LibMatrix::mat4 model_view_proj(perspective_);
+ model_view.translate(-centerVec_.x(), -centerVec_.y(), -(centerVec_.z() + 2.0 + radius_));
+ model_view.rotate(rotation_, 0.0f, 1.0f, 0.0f);
+ if (orientModel_)
{
- model_view.rotate(mOrientationAngle, mOrientationVec.x(), mOrientationVec.y(), mOrientationVec.z());
+ model_view.rotate(orientationAngle_, orientationVec_.x(), orientationVec_.y(), orientationVec_.z());
}
model_view_proj *= model_view.getCurrent();
- mProgram["ModelViewProjectionMatrix"] = model_view_proj;
+ program_["ModelViewProjectionMatrix"] = model_view_proj;
// Load the NormalMatrix uniform in the shader. The NormalMatrix is the
// inverse transpose of the model view matrix.
LibMatrix::mat4 normal_matrix(model_view.getCurrent());
normal_matrix.inverse().transpose();
- mProgram["NormalMatrix"] = normal_matrix;
+ program_["NormalMatrix"] = normal_matrix;
- if (mUseVbo) {
- mMesh.render_vbo();
+ if (useVbo_) {
+ mesh_.render_vbo();
}
else {
- mMesh.render_array();
+ mesh_.render_array();
}
}
@@ -241,12 +245,12 @@
{
static const double radius_3d(std::sqrt(3.0));
- if (mRotation != 0)
+ if (rotation_ != 0)
return Scene::ValidationUnknown;
Canvas::Pixel ref(0xa7, 0xa7, 0xa7, 0xff);
- Canvas::Pixel pixel = mCanvas.read_pixel(mCanvas.width() / 2,
- mCanvas.height() / 2);
+ Canvas::Pixel pixel = canvas_.read_pixel(canvas_.width() / 2,
+ canvas_.height() / 2);
double dist = pixel_value_distance(pixel, ref);
if (dist < radius_3d + 0.01) {
=== modified file 'src/scene-bump.cpp'
@@ -28,9 +28,9 @@
SceneBump::SceneBump(Canvas &pCanvas) :
Scene(pCanvas, "bump"),
- mTexture(0), mRotation(0.0f), mRotationSpeed(0.0f)
+ texture_(0), rotation_(0.0f), rotationSpeed_(0.0f)
{
- mOptions["bump-render"] = Scene::Option("bump-render", "off",
+ options_["bump-render"] = Scene::Option("bump-render", "off",
"How to render bumps [off, normals, high-poly]");
}
@@ -38,16 +38,18 @@
{
}
-int SceneBump::load()
+int
+SceneBump::load()
{
- mRotationSpeed = 36.0f;
+ rotationSpeed_ = 36.0f;
- mRunning = false;
+ running_ = false;
return 1;
}
-void SceneBump::unload()
+void
+SceneBump::unload()
{
}
@@ -80,7 +82,7 @@
attribs.push_back(std::pair<Model::AttribType, int>(Model::AttribTypePosition, 3));
attribs.push_back(std::pair<Model::AttribType, int>(Model::AttribTypeNormal, 3));
- model.convert_to_mesh(mMesh, attribs);
+ model.convert_to_mesh(mesh_, attribs);
/* Load shaders */
ShaderSource vtx_source(vtx_shader_filename);
@@ -90,16 +92,16 @@
frg_source.add_const("LightSourcePosition", lightPosition);
frg_source.add_const("LightSourceHalfVector", halfVector);
- if (!Scene::load_shaders_from_strings(mProgram, vtx_source.str(),
+ if (!Scene::load_shaders_from_strings(program_, vtx_source.str(),
frg_source.str()))
{
return;
}
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- attrib_locations.push_back(mProgram["normal"].location());
- mMesh.set_attrib_locations(attrib_locations);
+ attrib_locations.push_back(program_["position"].location());
+ attrib_locations.push_back(program_["normal"].location());
+ mesh_.set_attrib_locations(attrib_locations);
}
void
@@ -119,7 +121,7 @@
halfVector += LibMatrix::vec3(0.0, 0.0, 1.0);
halfVector.normalize();
- /*
+ /*
* We don't care about the vertex normals. We are using a per-fragment
* normal map (in object space coordinates).
*/
@@ -127,7 +129,7 @@
attribs.push_back(std::pair<Model::AttribType, int>(Model::AttribTypePosition, 3));
attribs.push_back(std::pair<Model::AttribType, int>(Model::AttribTypeTexcoord, 2));
- model.convert_to_mesh(mMesh, attribs);
+ model.convert_to_mesh(mesh_, attribs);
/* Load shaders */
ShaderSource vtx_source(vtx_shader_filename);
@@ -137,26 +139,27 @@
frg_source.add_const("LightSourcePosition", lightPosition);
frg_source.add_const("LightSourceHalfVector", halfVector);
- if (!Scene::load_shaders_from_strings(mProgram, vtx_source.str(),
+ if (!Scene::load_shaders_from_strings(program_, vtx_source.str(),
frg_source.str()))
{
return;
}
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- attrib_locations.push_back(mProgram["texcoord"].location());
- mMesh.set_attrib_locations(attrib_locations);
+ attrib_locations.push_back(program_["position"].location());
+ attrib_locations.push_back(program_["texcoord"].location());
+ mesh_.set_attrib_locations(attrib_locations);
- Texture::load(GLMARK_DATA_PATH"/textures/asteroid-normal-map.png", &mTexture,
+ Texture::load(GLMARK_DATA_PATH"/textures/asteroid-normal-map.png", &texture_,
GL_NEAREST, GL_NEAREST, 0);
}
-void SceneBump::setup()
+void
+SceneBump::setup()
{
Scene::setup();
- const std::string &bump_render = mOptions["bump-render"].value;
+ const std::string &bump_render = options_["bump-render"].value;
Model::find_models();
if (bump_render == "normals")
@@ -165,72 +168,74 @@
setup_model_plain(bump_render);
- mMesh.build_vbo();
+ mesh_.build_vbo();
- mProgram.start();
+ program_.start();
// Load texture sampler value
- mProgram["NormalMap"] = 0;
+ program_["NormalMap"] = 0;
- mCurrentFrame = 0;
- mRotation = 0.0;
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ currentFrame_ = 0;
+ rotation_ = 0.0;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
void
SceneBump::teardown()
{
- mMesh.reset();
-
- mProgram.stop();
- mProgram.release();
-
- glDeleteTextures(1, &mTexture);
- mTexture = 0;
+ mesh_.reset();
+
+ program_.stop();
+ program_.release();
+
+ glDeleteTextures(1, &texture_);
+ texture_ = 0;
Scene::teardown();
}
-void SceneBump::update()
+void
+SceneBump::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double dt = current_time - mLastUpdateTime;
- double elapsed_time = current_time - mStartTime;
-
- mLastUpdateTime = current_time;
-
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
+ double dt = current_time - lastUpdateTime_;
+ double elapsed_time = current_time - startTime_;
+
+ lastUpdateTime_ = current_time;
+
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
}
- mRotation += mRotationSpeed * dt;
+ rotation_ += rotationSpeed_ * dt;
- mCurrentFrame++;
+ currentFrame_++;
}
-void SceneBump::draw()
+void
+SceneBump::draw()
{
LibMatrix::Stack4 model_view;
// Load the ModelViewProjectionMatrix uniform in the shader
- LibMatrix::mat4 model_view_proj(mCanvas.projection());
+ LibMatrix::mat4 model_view_proj(canvas_.projection());
model_view.translate(0.0f, 0.0f, -3.5f);
- model_view.rotate(mRotation, 0.0f, 1.0f, 0.0f);
+ model_view.rotate(rotation_, 0.0f, 1.0f, 0.0f);
model_view_proj *= model_view.getCurrent();
- mProgram["ModelViewProjectionMatrix"] = model_view_proj;
+ program_["ModelViewProjectionMatrix"] = model_view_proj;
// Load the NormalMatrix uniform in the shader. The NormalMatrix is the
// inverse transpose of the model view matrix.
LibMatrix::mat4 normal_matrix(model_view.getCurrent());
normal_matrix.inverse().transpose();
- mProgram["NormalMatrix"] = normal_matrix;
+ program_["NormalMatrix"] = normal_matrix;
- mMesh.render_vbo();
+ mesh_.render_vbo();
}
Scene::ValidationResult
@@ -238,15 +243,15 @@
{
static const double radius_3d(std::sqrt(3.0));
- if (mRotation != 0)
+ if (rotation_ != 0)
return Scene::ValidationUnknown;
Canvas::Pixel ref;
- Canvas::Pixel pixel = mCanvas.read_pixel(mCanvas.width() / 2,
- mCanvas.height() / 2);
+ Canvas::Pixel pixel = canvas_.read_pixel(canvas_.width() / 2,
+ canvas_.height() / 2);
- const std::string &bump_render = mOptions["bump-render"].value;
+ const std::string &bump_render = options_["bump-render"].value;
if (bump_render == "off")
ref = Canvas::Pixel(0x81, 0x81, 0x81, 0xff);
=== modified file 'src/scene-conditionals.cpp'
@@ -25,9 +25,9 @@
#include "vec.h"
#include "log.h"
#include "shader-source.h"
+#include "util.h"
#include <cmath>
-#include <sstream>
static const std::string shader_file_base(GLMARK_DATA_PATH"/shaders/conditionals");
@@ -39,13 +39,13 @@
SceneConditionals::SceneConditionals(Canvas &pCanvas) :
SceneGrid(pCanvas, "conditionals")
{
- mOptions["fragment-steps"] = Scene::Option("fragment-steps", "1",
+ options_["fragment-steps"] = Scene::Option("fragment-steps", "1",
"The number of computational steps in the fragment shader");
- mOptions["fragment-conditionals"] = Scene::Option("fragment-conditionals", "true",
+ options_["fragment-conditionals"] = Scene::Option("fragment-conditionals", "true",
"Whether each computational step includes an if-else clause");
- mOptions["vertex-steps"] = Scene::Option("vertex-steps", "1",
+ options_["vertex-steps"] = Scene::Option("vertex-steps", "1",
"The number of computational steps in the vertex shader");
- mOptions["vertex-conditionals"] = Scene::Option("vertex-conditionals", "true",
+ options_["vertex-conditionals"] = Scene::Option("vertex-conditionals", "true",
"Whether each computational step includes an if-else clause");
}
@@ -89,38 +89,30 @@
return source.str();
}
-void SceneConditionals::setup()
+void
+SceneConditionals::setup()
{
SceneGrid::setup();
/* Parse options */
- bool vtx_conditionals = mOptions["vertex-conditionals"].value == "true";
- bool frg_conditionals = mOptions["fragment-conditionals"].value == "true";
- int vtx_steps = 0;
- int frg_steps = 0;
-
- std::stringstream ss;
-
- ss << mOptions["vertex-steps"].value;
- ss >> vtx_steps;
- ss.clear();
- ss << mOptions["fragment-steps"].value;
- ss >> frg_steps;
-
+ bool vtx_conditionals = options_["vertex-conditionals"].value == "true";
+ bool frg_conditionals = options_["fragment-conditionals"].value == "true";
+ int vtx_steps(Util::fromString<int>(options_["vertex-steps"].value));
+ int frg_steps(Util::fromString<int>(options_["fragment-steps"].value));
/* Load shaders */
std::string vtx_shader(get_vertex_shader_source(vtx_steps, vtx_conditionals));
std::string frg_shader(get_fragment_shader_source(frg_steps, frg_conditionals));
- if (!Scene::load_shaders_from_strings(mProgram, vtx_shader, frg_shader))
+ if (!Scene::load_shaders_from_strings(program_, vtx_shader, frg_shader))
return;
- mProgram.start();
+ program_.start();
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- mMesh.set_attrib_locations(attrib_locations);
+ attrib_locations.push_back(program_["position"].location());
+ mesh_.set_attrib_locations(attrib_locations);
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
=== modified file 'src/scene-default-options.cpp'
@@ -22,12 +22,13 @@
#include "scene.h"
#include "benchmark.h"
-void SceneDefaultOptions::setup()
+void
+SceneDefaultOptions::setup()
{
const std::map<std::string, Scene *> &scenes = Benchmark::scenes();
- for (std::list<std::pair<std::string, std::string> >::const_iterator iter = mDefaultOptions.begin();
- iter != mDefaultOptions.end();
+ for (std::list<std::pair<std::string, std::string> >::const_iterator iter = defaultOptions_.begin();
+ iter != defaultOptions_.end();
iter++)
{
for (std::map<std::string, Scene *>::const_iterator scene_iter = scenes.begin();
@@ -42,6 +43,6 @@
bool
SceneDefaultOptions::set_option(const std::string &opt, const std::string &val)
{
- mDefaultOptions.push_back(std::pair<std::string, std::string>(opt, val));
+ defaultOptions_.push_back(std::pair<std::string, std::string>(opt, val));
return true;
}
=== modified file 'src/scene-desktop.cpp'
@@ -50,9 +50,9 @@
unsigned int side = 2 * radius + 1;
- for (size_t i = 0; i < radius + 1; i++) {
+ for (unsigned int i = 0; i < radius + 1; i++) {
float s2 = 2.0 * sigma * sigma;
- float k = 1.0 / std::sqrt(M_PI * s2) * std::exp( - ((float)i * i) / s2);
+ float k = 1.0 / std::sqrt(M_PI * s2) * std::exp( - (static_cast<float>(i) * i) / s2);
std::stringstream ss_tmp;
ss_tmp << "Kernel" << i;
frg_source.add_const(ss_tmp.str(), k);
@@ -60,10 +60,10 @@
std::stringstream ss;
ss << "result = " << std::endl;
-
+
if (direction == BlurDirectionHorizontal) {
- for (size_t i = 0; i < side; i++) {
- int offset = (int)(i - radius);
+ for (unsigned int i = 0; i < side; i++) {
+ int offset = static_cast<int>(i - radius);
ss << "texture2D(Texture0, TextureCoord + vec2(" <<
offset << ".0 * TextureStepX, 0.0)) * Kernel" <<
std::abs(offset) << " +" << std::endl;
@@ -71,8 +71,8 @@
ss << "0.0 ;" << std::endl;
}
else if (direction == BlurDirectionVertical) {
- for (size_t i = 0; i < side; i++) {
- int offset = (int)(i - radius);
+ for (unsigned int i = 0; i < side; i++) {
+ int offset = static_cast<int>(i - radius);
ss << "texture2D(Texture0, TextureCoord + vec2(0.0, " <<
offset << ".0 * TextureStepY)) * Kernel" <<
std::abs(offset) << " +" << std::endl;
@@ -80,10 +80,10 @@
ss << "0.0 ;" << std::endl;
}
else if (direction == BlurDirectionBoth) {
- for (size_t i = 0; i < side; i++) {
- int ioffset = (int)(i - radius);
- for (size_t j = 0; j < side; j++) {
- int joffset = (int)(j - radius);
+ for (unsigned int i = 0; i < side; i++) {
+ int ioffset = static_cast<int>(i - radius);
+ for (unsigned int j = 0; j < side; j++) {
+ int joffset = static_cast<int>(j - radius);
ss << "texture2D(Texture0, TextureCoord + vec2(" <<
ioffset << ".0 * TextureStepX, " <<
joffset << ".0 * TextureStepY))" <<
@@ -97,7 +97,7 @@
frg_source.replace("$CONVOLUTION$", ss.str());
}
-/**
+/**
* A RenderObject represents a source and target of rendering
* operations.
*/
@@ -153,7 +153,7 @@
fbo_ = 0;
}
- /*
+ /*
* Release the shader program when object of this class
* are no longer in use.
*/
@@ -197,7 +197,12 @@
glClear(GL_COLOR_BUFFER_BIT);
}
- virtual void render_to(RenderObject& target, Program& program = main_program)
+ virtual void render_to(RenderObject& target)
+ {
+ render_to(target, main_program);
+ }
+
+ virtual void render_to(RenderObject& target, Program& program)
{
LibMatrix::vec2 anchor(pos_);
LibMatrix::vec2 ll(pos_ - anchor);
@@ -254,13 +259,13 @@
ll_tex.x(), ur_tex.y(),
ur_tex.x(), ur_tex.y(),
};
-
+
make_current();
glBindTexture(GL_TEXTURE_2D, target.texture());
draw_quad_with_program(position_blur, texcoord_blur, program);
}
- /**
+ /**
* Normalizes a position from [0, size] to [-1.0, 1.0]
*/
LibMatrix::vec2 normalize_position(const LibMatrix::vec2& pos)
@@ -268,7 +273,7 @@
return pos * 2.0 / size_ - 1.0;
}
- /**
+ /**
* Normalizes a position from [0, size] to [0.0, 1.0]
*/
LibMatrix::vec2 normalize_texcoord(const LibMatrix::vec2& pos)
@@ -332,7 +337,7 @@
int RenderObject::use_count = 0;
Program RenderObject::main_program;
-/**
+/**
* A RenderObject representing the screen.
*
* Rendering to this objects renders to the screen framebuffer.
@@ -343,7 +348,7 @@
virtual void init() {}
};
-/**
+/**
* A RenderObject with a background image.
*
* The image is drawn to the RenderObject automatically when the
@@ -406,7 +411,7 @@
GLuint background_texture_;
};
-/**
+/**
* A RenderObject that blurs the target it is drawn to.
*/
class RenderWindowBlur : public RenderObject
@@ -425,7 +430,7 @@
if (draw_contents_ && RenderWindowBlur::use_count == 0)
window_contents_.init();
- RenderWindowBlur::use_count++;
+ RenderWindowBlur::use_count++;
}
virtual void release()
@@ -446,10 +451,8 @@
window_contents_.size(size);
}
- virtual void render_to(RenderObject& target, Program& program)
+ virtual void render_to(RenderObject& target)
{
- (void)program;
-
if (separable_) {
Program& blur_program_h1 = blur_program_h(target.size().x());
Program& blur_program_v1 = blur_program_v(target.size().y());
@@ -465,7 +468,7 @@
for (unsigned int i = 0; i < passes_; i++) {
if (i % 2 == 0)
render_from(target, blur_program1);
- else
+ else
RenderObject::render_to(target, blur_program1);
}
@@ -473,7 +476,7 @@
RenderObject::render_to(target);
}
- /*
+ /*
* Blend the window contents with the target texture.
*/
if (draw_contents_) {
@@ -488,7 +491,7 @@
private:
Program& blur_program(unsigned int w, unsigned int h)
{
- /*
+ /*
* If the size of the window has changed we must recreate
* the shader to contain the correct texture step values.
*/
@@ -515,7 +518,7 @@
Program& blur_program_h(unsigned int w)
{
- /*
+ /*
* If the size of the window has changed we must recreate
* the shader to contain the correct texture step values.
*/
@@ -540,7 +543,7 @@
Program& blur_program_v(unsigned int h)
{
- /*
+ /*
* If the size of the window has changed we must recreate
* the shader to contain the correct texture step values.
*/
@@ -577,7 +580,7 @@
};
-/**
+/**
* A RenderObject that draws a drop shadow around the window.
*/
class RenderWindowShadow : public RenderObject
@@ -592,7 +595,7 @@
{
RenderObject::init();
- /*
+ /*
* Only have one instance of the resources.
* This works only if all windows have the same size, which
* is currently the case for this scene. If this condition
@@ -607,7 +610,7 @@
window_contents_.init();
}
- RenderWindowShadow::use_count++;
+ RenderWindowShadow::use_count++;
}
virtual void release()
@@ -640,10 +643,8 @@
window_contents_.size(size);
}
- virtual void render_to(RenderObject& target, Program& program)
+ virtual void render_to(RenderObject& target)
{
- (void)program;
-
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -659,7 +660,7 @@
shadow_v_.position(position() +
LibMatrix::vec2(size().x() + shadow_v_.size().y(), 0.0));
shadow_v_.render_to(target);
-
+
/* Bottom right shadow */
shadow_corner_.rotation(0.0);
shadow_corner_.position(position() +
@@ -669,7 +670,7 @@
/* Top right shadow */
shadow_corner_.rotation(90.0);
- shadow_corner_.position(position() + size() +
+ shadow_corner_.position(position() + size() +
LibMatrix::vec2(shadow_corner_.size().x(),
-shadow_corner_.size().y()));
shadow_corner_.render_to(target);
@@ -679,7 +680,7 @@
shadow_corner_.position(position());
shadow_corner_.render_to(target);
- /*
+ /*
* Blend the window contents with the target texture.
*/
if (draw_contents_) {
@@ -711,10 +712,10 @@
RenderClearImage RenderWindowShadow::shadow_corner_(GLMARK_DATA_PATH"/textures/desktop-shadow-corner.png");
/*******************************
- * SceneDesktop implementation *
+ * SceneDesktop implementation *
*******************************/
-/**
+/**
* Private structure used to avoid contaminating scene.h with all of the
* SceneDesktop internal classes.
*/
@@ -728,7 +729,7 @@
desktop(GLMARK_DATA_PATH"/textures/effect-2d.png") {}
~SceneDesktopPrivate() { Util::dispose_pointer_vector(windows); }
-
+
};
@@ -736,19 +737,19 @@
Scene(canvas, "desktop")
{
priv_ = new SceneDesktopPrivate();
- mOptions["effect"] = Scene::Option("effect", "blur",
+ options_["effect"] = Scene::Option("effect", "blur",
"the effect to use [blur]");
- mOptions["windows"] = Scene::Option("windows", "4",
+ options_["windows"] = Scene::Option("windows", "4",
"the number of windows");
- mOptions["window-size"] = Scene::Option("window-size", "0.35",
+ options_["window-size"] = Scene::Option("window-size", "0.35",
"the window size as a percentage of the minimum screen dimension [0.0 - 0.5]");
- mOptions["passes"] = Scene::Option("passes", "1",
+ options_["passes"] = Scene::Option("passes", "1",
"the number of effect passes (effect dependent)");
- mOptions["blur-radius"] = Scene::Option("blur-radius", "5",
+ options_["blur-radius"] = Scene::Option("blur-radius", "5",
"the blur effect radius (in pixels)");
- mOptions["separable"] = Scene::Option("separable", "true",
+ options_["separable"] = Scene::Option("separable", "true",
"use separable convolution for the blur effect");
- mOptions["shadow-size"] = Scene::Option("shadow-size", "20",
+ options_["shadow-size"] = Scene::Option("shadow-size", "20",
"the size of the shadow (in pixels)");
}
@@ -773,28 +774,19 @@
{
Scene::setup();
- std::stringstream ss;
+ /* Parse the options */
unsigned int windows(0);
unsigned int passes(0);
unsigned int blur_radius(0);
float window_size_factor(0.0);
unsigned int shadow_size(0);
- bool separable(mOptions["separable"].value == "true");
+ bool separable(options_["separable"].value == "true");
- ss << mOptions["windows"].value;
- ss >> windows;
- ss.clear();
- ss << mOptions["window-size"].value;
- ss >> window_size_factor;
- ss.clear();
- ss << mOptions["passes"].value;
- ss >> passes;
- ss.clear();
- ss << mOptions["blur-radius"].value;
- ss >> blur_radius;
- ss.clear();
- ss << mOptions["shadow-size"].value;
- ss >> shadow_size;
+ windows = Util::fromString<unsigned int>(options_["windows"].value);
+ window_size_factor = Util::fromString<float>(options_["window-size"].value);
+ passes = Util::fromString<unsigned int>(options_["passes"].value);
+ blur_radius = Util::fromString<unsigned int>(options_["blur-radius"].value);
+ shadow_size = Util::fromString<unsigned int>(options_["shadow-size"].value);
/* Ensure we get a transparent clear color for all following operations */
glClearColor(0.0, 0.0, 0.0, 0.0);
@@ -804,36 +796,35 @@
/* Set up the screen and desktop RenderObjects */
priv_->screen.init();
priv_->desktop.init();
- priv_->screen.size(LibMatrix::vec2(mCanvas.width(), mCanvas.height()));
- priv_->desktop.size(LibMatrix::vec2(mCanvas.width(), mCanvas.height()));
+ priv_->screen.size(LibMatrix::vec2(canvas_.width(), canvas_.height()));
+ priv_->desktop.size(LibMatrix::vec2(canvas_.width(), canvas_.height()));
/* Create the windows */
- float angular_step(2.0 * M_PI / windows);
- unsigned int min_dimension = std::min(mCanvas.width(), mCanvas.height());
+ const float angular_step(2.0 * M_PI / windows);
+ unsigned int min_dimension = std::min(canvas_.width(), canvas_.height());
float window_size(min_dimension * window_size_factor);
static const LibMatrix::vec2 corner_offset(window_size / 2.0,
window_size / 2.0);
for (unsigned int i = 0; i < windows; i++) {
- LibMatrix::vec2 center(mCanvas.width() * (0.5 + 0.25 * cos(i * angular_step)),
- mCanvas.height() * (0.5 + 0.25 * sin(i * angular_step)));
+ LibMatrix::vec2 center(canvas_.width() * (0.5 + 0.25 * cos(i * angular_step)),
+ canvas_.height() * (0.5 + 0.25 * sin(i * angular_step)));
RenderObject* win;
- if (mOptions["effect"].value == "shadow")
+ if (options_["effect"].value == "shadow")
win = new RenderWindowShadow(shadow_size);
else
win = new RenderWindowBlur(passes, blur_radius, separable);
- (void)angular_step;
win->init();
win->position(center - corner_offset);
win->size(LibMatrix::vec2(window_size, window_size));
- /*
+ /*
* Set the speed in increments of about 30 degrees (but not exactly,
* so we don't get windows moving just on the X axis or Y axis).
*/
- win->speed(LibMatrix::vec2(cos(0.1 + i * M_PI / 6.0) * mCanvas.width() / 3,
- sin(0.1 + i * M_PI / 6.0) * mCanvas.height() / 3));
- /*
+ win->speed(LibMatrix::vec2(cos(0.1 + i * M_PI / 6.0) * canvas_.width() / 3,
+ sin(0.1 + i * M_PI / 6.0) * canvas_.height() / 3));
+ /*
* Perform a dummy rendering to ensure internal shaders are initialized
* now, in order not to affect the benchmarking.
*/
@@ -841,16 +832,16 @@
priv_->windows.push_back(win);
}
- /*
+ /*
* Ensure the screen is the current rendering target (it might have changed
* to a FBO in the previous steps).
*/
priv_->screen.make_current();
- mCurrentFrame = 0;
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ currentFrame_ = 0;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
void
@@ -872,10 +863,10 @@
SceneDesktop::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double dt = current_time - mLastUpdateTime;
- double elapsed_time = current_time - mStartTime;
+ double dt = current_time - lastUpdateTime_;
+ double elapsed_time = current_time - startTime_;
- mLastUpdateTime = current_time;
+ lastUpdateTime_ = current_time;
std::vector<RenderObject *>& windows(priv_->windows);
@@ -894,14 +885,14 @@
win->position().y() + win->speed().y() * dt);
if (new_pos.x() < 0.0 ||
- new_pos.x() + win->size().x() > ((float)mCanvas.width()))
+ new_pos.x() + win->size().x() > static_cast<float>(canvas_.width()))
{
win->speed(LibMatrix::vec2(-win->speed().x(), win->speed().y()));
should_update = false;
}
if (new_pos.y() < 0.0 ||
- new_pos.y() + win->size().y() > ((float)mCanvas.height()))
+ new_pos.y() + win->size().y() > static_cast<float>(canvas_.height()))
{
win->speed(LibMatrix::vec2(win->speed().x(), -win->speed().y()));
should_update = false;
@@ -911,12 +902,12 @@
win->position(new_pos);
}
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
}
- mCurrentFrame++;
+ currentFrame_++;
}
void
=== modified file 'src/scene-effect-2d.cpp'
@@ -36,10 +36,10 @@
SceneEffect2D::SceneEffect2D(Canvas &pCanvas) :
Scene(pCanvas, "effect2d")
{
- mOptions["kernel"] = Scene::Option("kernel",
+ options_["kernel"] = Scene::Option("kernel",
"0,0,0;0,1,0;0,0,0",
"The convolution kernel matrix to use [format: \"a,b,c...;d,e,f...\"");;
- mOptions["normalize"] = Scene::Option("normalize", "true",
+ options_["normalize"] = Scene::Option("normalize", "true",
"Whether to normalize the supplied convolution kernel matrix [true,false]");
}
@@ -113,7 +113,7 @@
ss_def << std::fixed;
ss_convolution.precision(1);
ss_convolution << std::fixed;
-
+
ss_convolution << "result = ";
for(std::vector<float>::const_iterator iter = array.begin();
@@ -143,12 +143,12 @@
return source.str();
}
-/**
+/**
* Creates a string containing a printout of a kernel matrix.
- *
+ *
* @param filter the vector containing the filter coefficients
* @param width the width of the filter
- *
+ *
* @return the printout
*/
static std::string
@@ -170,19 +170,19 @@
return ss.str();
}
-/**
+/**
* Parses a string representation of a matrix and returns it
* in row-major format.
*
* In the string representation, elements are delimited using
* commas (',') and rows are delimited using semi-colons (';').
* eg 0,0,0;0,1.0,0;0,0,0
- *
+ *
* @param str the matrix string representation to parse
* @param matrix the float vector to populate
* @param[out] width the width of the matrix
- * @param[out] height the height of the matrix
- *
+ * @param[out] height the height of the matrix
+ *
* @return whether parsing succeeded
*/
static bool
@@ -205,21 +205,18 @@
if (w != UINT_MAX && elems.size() != w) {
Log::error("Matrix row %u contains %u elements, whereas previous"
- " rows had %u\n",
+ " rows had %u\n",
iter - rows.begin(), elems.size(), w);
return false;
}
w = elems.size();
-
+
for (std::vector<std::string>::const_iterator iter_el = elems.begin();
iter_el != elems.end();
iter_el++)
{
- std::stringstream ss(*iter_el);
- float f;
-
- ss >> f;
+ float f(Util::fromString<float>(*iter_el));
matrix.push_back(f);
if (iter_el == elems.begin())
Log::debug("%f ", f);
@@ -232,13 +229,13 @@
width = w;
height = rows.size();
-
+
return true;
}
-/**
+/**
* Normalizes a convolution kernel matrix.
- *
+ *
* @param filter the filter to normalize
*/
static void
@@ -246,7 +243,7 @@
{
float sum = std::accumulate(kernel.begin(), kernel.end(), 0.0);
- /*
+ /*
* If sum is essentially zero, perform a zero-sum normalization.
* This normalizes positive and negative values separately,
*/
@@ -261,37 +258,40 @@
}
}
- /*
+ /*
* We can simply compare with 0.0f here, because we just care about
* avoiding division-by-zero.
*/
if (sum == 0.0)
return;
-
+
for (std::vector<float>::iterator iter = kernel.begin();
iter != kernel.end();
iter++)
{
- *iter /= sum;
+ *iter /= sum;
}
}
-int SceneEffect2D::load()
+int
+SceneEffect2D::load()
{
Texture::load(GLMARK_DATA_PATH"/textures/effect-2d.png", &texture_,
GL_NEAREST, GL_NEAREST, 0);
- mRunning = false;
+ running_ = false;
return 1;
}
-void SceneEffect2D::unload()
+void
+SceneEffect2D::unload()
{
glDeleteTextures(1, &texture_);
}
-void SceneEffect2D::setup()
+void
+SceneEffect2D::setup()
{
Scene::setup();
@@ -302,14 +302,14 @@
unsigned int kernel_height = 0;
/* Parse the kernel matrix from the options */
- if (!parse_matrix(mOptions["kernel"].value, kernel,
+ if (!parse_matrix(options_["kernel"].value, kernel,
kernel_width, kernel_height))
{
return;
}
/* Normalize the kernel matrix if needed */
- if (mOptions["normalize"].value == "true") {
+ if (options_["normalize"].value == "true") {
normalize(kernel);
Log::debug("Normalized kernel matrix:\n%s",
kernel_printout(kernel, kernel_width).c_str());
@@ -318,7 +318,7 @@
/* Create and load the shaders */
ShaderSource vtx_source(vtx_shader_filename);
ShaderSource frg_source;
- frg_source.append(create_convolution_fragment_shader(mCanvas, kernel,
+ frg_source.append(create_convolution_fragment_shader(canvas_, kernel,
kernel_width,
kernel_height));
@@ -347,13 +347,14 @@
// Load texture sampler value
program_["Texture0"] = 0;
- mCurrentFrame = 0;
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ currentFrame_ = 0;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
-void SceneEffect2D::teardown()
+void
+SceneEffect2D::teardown()
{
mesh_.reset();
@@ -363,22 +364,24 @@
Scene::teardown();
}
-void SceneEffect2D::update()
+void
+SceneEffect2D::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double elapsed_time = current_time - mStartTime;
-
- mLastUpdateTime = current_time;
-
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
+ double elapsed_time = current_time - startTime_;
+
+ lastUpdateTime_ = current_time;
+
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
}
- mCurrentFrame++;
+ currentFrame_++;
}
-void SceneEffect2D::draw()
+void
+SceneEffect2D::draw()
{
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture_);
=== modified file 'src/scene-function.cpp'
@@ -25,8 +25,7 @@
#include "vec.h"
#include "log.h"
#include "shader-source.h"
-
-#include <sstream>
+#include "util.h"
static const std::string shader_file_base(GLMARK_DATA_PATH"/shaders/function");
@@ -39,17 +38,17 @@
SceneFunction::SceneFunction(Canvas &pCanvas) :
SceneGrid(pCanvas, "function")
{
- mOptions["fragment-steps"] = Scene::Option("fragment-steps", "1",
+ options_["fragment-steps"] = Scene::Option("fragment-steps", "1",
"The number of computational steps in the fragment shader");
- mOptions["fragment-function"] = Scene::Option("fragment-function", "true",
+ options_["fragment-function"] = Scene::Option("fragment-function", "true",
"Whether each computational step includes a function call");
- mOptions["vertex-steps"] = Scene::Option("vertex-steps", "1",
+ options_["vertex-steps"] = Scene::Option("vertex-steps", "1",
"The number of computational steps in the vertex shader");
- mOptions["vertex-function"] = Scene::Option("vertex-function", "true",
+ options_["vertex-function"] = Scene::Option("vertex-function", "true",
"Whether each computational step includes an if-else clause");
- mOptions["vertex-complexity"] = Scene::Option("vertex-complexity", "low",
+ options_["vertex-complexity"] = Scene::Option("vertex-complexity", "low",
"The complexity of each computational step in the vertex shader");
- mOptions["fragment-complexity"] = Scene::Option("fragment-complexity", "low",
+ options_["fragment-complexity"] = Scene::Option("fragment-complexity", "low",
"The complexity of each computational step in the fragment shader");
}
@@ -115,25 +114,18 @@
return source.str();
}
-void SceneFunction::setup()
+void
+SceneFunction::setup()
{
SceneGrid::setup();
/* Parse options */
- bool vtx_function = mOptions["vertex-function"].value == "true";
- bool frg_function = mOptions["fragment-function"].value == "true";
- std::string vtx_complexity = mOptions["vertex-complexity"].value;
- std::string frg_complexity = mOptions["fragment-complexity"].value;
- int vtx_steps = 0;
- int frg_steps = 0;
-
- std::stringstream ss;
-
- ss << mOptions["vertex-steps"].value;
- ss >> vtx_steps;
- ss.clear();
- ss << mOptions["fragment-steps"].value;
- ss >> frg_steps;
+ bool vtx_function = options_["vertex-function"].value == "true";
+ bool frg_function = options_["fragment-function"].value == "true";
+ std::string vtx_complexity = options_["vertex-complexity"].value;
+ std::string frg_complexity = options_["fragment-complexity"].value;
+ int vtx_steps = Util::fromString<int>(options_["vertex-steps"].value);
+ int frg_steps = Util::fromString<int>(options_["fragment-steps"].value);
/* Load shaders */
std::string vtx_shader(get_vertex_shader_source(vtx_steps, vtx_function,
@@ -141,16 +133,16 @@
std::string frg_shader(get_fragment_shader_source(frg_steps, frg_function,
frg_complexity));
- if (!Scene::load_shaders_from_strings(mProgram, vtx_shader, frg_shader))
+ if (!Scene::load_shaders_from_strings(program_, vtx_shader, frg_shader))
return;
- mProgram.start();
+ program_.start();
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- mMesh.set_attrib_locations(attrib_locations);
+ attrib_locations.push_back(program_["position"].location());
+ mesh_.set_attrib_locations(attrib_locations);
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
=== modified file 'src/scene-grid.cpp'
@@ -24,15 +24,14 @@
#include "stack.h"
#include "vec.h"
#include "log.h"
-
-#include <sstream>
+#include "util.h"
SceneGrid::SceneGrid(Canvas &pCanvas, const std::string &name) :
Scene(pCanvas, name)
{
- mOptions["grid-size"] = Scene::Option("grid-size", "32",
+ options_["grid-size"] = Scene::Option("grid-size", "32",
"The number of squares per side of the grid (controls the number of vertices)");
- mOptions["grid-length"] = Scene::Option("grid-length", "5.0",
+ options_["grid-length"] = Scene::Option("grid-length", "5.0",
"The length of each side of the grid (normalized) (controls the area drawn to)");
}
@@ -40,92 +39,90 @@
{
}
-int SceneGrid::load()
+int
+SceneGrid::load()
{
- mRotationSpeed = 36.0f;
- mRunning = false;
+ rotationSpeed_ = 36.0f;
+ running_ = false;
return 1;
}
-void SceneGrid::unload()
+void
+SceneGrid::unload()
{
}
-void SceneGrid::setup()
+void
+SceneGrid::setup()
{
Scene::setup();
- int grid_size = 0;
- double grid_length = 0;
-
- std::stringstream ss;
-
- ss << mOptions["grid-size"].value;
- ss >> grid_size;
- ss.clear();
- ss << mOptions["grid-length"].value;
- ss >> grid_length;
+ 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);
- mMesh.set_vertex_format(vertex_format);
+ 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);
- mMesh.make_grid(grid_size, grid_size, grid_length, grid_length,
+ mesh_.make_grid(grid_size, grid_size, grid_length, grid_length,
grid_size > 1 ? spacing : 0);
- mMesh.build_vbo();
+ mesh_.build_vbo();
- mCurrentFrame = 0;
- mRotation = 0.0f;
+ currentFrame_ = 0;
+ rotation_ = 0.0f;
}
-void SceneGrid::teardown()
+void
+SceneGrid::teardown()
{
- mProgram.stop();
- mProgram.release();
- mMesh.reset();
+ program_.stop();
+ program_.release();
+ mesh_.reset();
Scene::teardown();
}
-void SceneGrid::update()
+void
+SceneGrid::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double dt = current_time - mLastUpdateTime;
- double elapsed_time = current_time - mStartTime;
-
- mLastUpdateTime = current_time;
-
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
+ double dt = current_time - lastUpdateTime_;
+ double elapsed_time = current_time - startTime_;
+
+ lastUpdateTime_ = current_time;
+
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
}
- mRotation += mRotationSpeed * dt;
+ rotation_ += rotationSpeed_ * dt;
- mCurrentFrame++;
+ currentFrame_++;
}
-void SceneGrid::draw()
+void
+SceneGrid::draw()
{
// Load the ModelViewProjectionMatrix uniform in the shader
LibMatrix::Stack4 model_view;
- LibMatrix::mat4 model_view_proj(mCanvas.projection());
+ LibMatrix::mat4 model_view_proj(canvas_.projection());
model_view.translate(0.0f, 0.0f, -5.0f);
- model_view.rotate(mRotation, 0.0f, 0.0f, 1.0f);
+ model_view.rotate(rotation_, 0.0f, 0.0f, 1.0f);
model_view_proj *= model_view.getCurrent();
- mProgram["ModelViewProjectionMatrix"] = model_view_proj;
+ program_["ModelViewProjectionMatrix"] = model_view_proj;
- mMesh.render_vbo();
+ mesh_.render_vbo();
}
Scene::ValidationResult
=== modified file 'src/scene-loop.cpp'
@@ -25,8 +25,7 @@
#include "vec.h"
#include "log.h"
#include "shader-source.h"
-
-#include <sstream>
+#include "util.h"
static const std::string shader_file_base(GLMARK_DATA_PATH"/shaders/loop");
@@ -38,17 +37,17 @@
SceneLoop::SceneLoop(Canvas &pCanvas) :
SceneGrid(pCanvas, "loop")
{
- mOptions["fragment-steps"] = Scene::Option("fragment-steps", "1",
+ options_["fragment-steps"] = Scene::Option("fragment-steps", "1",
"The number of computational steps in the fragment shader");
- mOptions["fragment-loop"] = Scene::Option("fragment-function", "true",
+ options_["fragment-loop"] = Scene::Option("fragment-function", "true",
"Whether to execute the steps in the vertex shader using a for loop");
- mOptions["vertex-steps"] = Scene::Option("vertex-steps", "1",
+ options_["vertex-steps"] = Scene::Option("vertex-steps", "1",
"The number of computational steps in the vertex shader");
- mOptions["vertex-loop"] = Scene::Option("vertex-function", "true",
+ options_["vertex-loop"] = Scene::Option("vertex-function", "true",
"Whether to execute the steps in the vertex shader using a for loop");
- mOptions["vertex-uniform"] = Scene::Option("vertex-uniform", "true",
+ options_["vertex-uniform"] = Scene::Option("vertex-uniform", "true",
"Whether to use a uniform in the vertex shader for the number of loop iterations to perform (i.e. vertex-steps)");
- mOptions["fragment-uniform"] = Scene::Option("fragment-uniform", "true",
+ options_["fragment-uniform"] = Scene::Option("fragment-uniform", "true",
"Whether to use a uniform in the fragment shader for the number of loop iterations to perform (i.e. fragment-steps)");
}
@@ -68,9 +67,7 @@
source_main.replace("$NLOOPS$", "FragmentLoops");
}
else {
- std::stringstream ss_steps;
- ss_steps << steps;
- source_main.replace("$NLOOPS$", ss_steps.str());
+ source_main.replace("$NLOOPS$", Util::toString(steps));
}
}
else {
@@ -95,9 +92,7 @@
source_main.replace("$NLOOPS$", "VertexLoops");
}
else {
- std::stringstream ss_steps;
- ss_steps << steps;
- source_main.replace("$NLOOPS$", ss_steps.str());
+ source_main.replace("$NLOOPS$", Util::toString(steps));
}
}
else {
@@ -111,25 +106,18 @@
}
-void SceneLoop::setup()
+void
+SceneLoop::setup()
{
SceneGrid::setup();
/* Parse options */
- bool vtx_loop = mOptions["vertex-loop"].value == "true";
- bool frg_loop = mOptions["fragment-loop"].value == "true";
- bool vtx_uniform = mOptions["vertex-uniform"].value == "true";
- bool frg_uniform = mOptions["fragment-uniform"].value == "true";
- int vtx_steps = 0;
- int frg_steps = 0;
-
- std::stringstream ss;
-
- ss << mOptions["vertex-steps"].value;
- ss >> vtx_steps;
- ss.clear();
- ss << mOptions["fragment-steps"].value;
- ss >> frg_steps;
+ bool vtx_loop = options_["vertex-loop"].value == "true";
+ bool frg_loop = options_["fragment-loop"].value == "true";
+ bool vtx_uniform = options_["vertex-uniform"].value == "true";
+ bool frg_uniform = options_["fragment-uniform"].value == "true";
+ int vtx_steps = Util::fromString<int>(options_["vertex-steps"].value);
+ int frg_steps = Util::fromString<int>(options_["fragment-steps"].value);
/* Load shaders */
std::string vtx_shader(get_vertex_shader_source(vtx_steps, vtx_loop,
@@ -137,19 +125,19 @@
std::string frg_shader(get_fragment_shader_source(frg_steps, frg_loop,
frg_uniform));
- if (!Scene::load_shaders_from_strings(mProgram, vtx_shader, frg_shader))
+ if (!Scene::load_shaders_from_strings(program_, vtx_shader, frg_shader))
return;
- mProgram.start();
+ program_.start();
- mProgram["VertexLoops"] = vtx_steps;
- mProgram["FragmentLoops"] = frg_steps;
+ program_["VertexLoops"] = vtx_steps;
+ program_["FragmentLoops"] = frg_steps;
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- mMesh.set_attrib_locations(attrib_locations);
+ attrib_locations.push_back(program_["position"].location());
+ mesh_.set_attrib_locations(attrib_locations);
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
=== modified file 'src/scene-pulsar.cpp'
@@ -21,45 +21,57 @@
* Ben Smith (original glmark benchmark)
* Alexandros Frantzis (glmark2)
* Marc Ordinas i Llopis, Collabora Ltd. (pulsar scene)
+ * Jesse Barker
*/
+#include <stdlib.h>
#include "scene.h"
#include "mat.h"
#include "stack.h"
#include "vec.h"
#include "log.h"
-#include "program.h"
#include "shader-source.h"
+#include "util.h"
#include <cmath>
+using LibMatrix::vec2;
+using LibMatrix::vec3;
+using LibMatrix::vec4;
+using LibMatrix::mat4;
+using LibMatrix::Stack4;
+
ScenePulsar::ScenePulsar(Canvas &pCanvas) :
Scene(pCanvas, "pulsar"),
- mTexture(0)
+ numQuads_(0),
+ texture_(0)
{
- mOptions["quads"] = Scene::Option("quads", "5", "Number of quads to render");
- mOptions["texture"] = Scene::Option("texture", "false", "Enable texturing");
- mOptions["light"] = Scene::Option("light", "false", "Enable lighting");
- mOptions["random"] = Scene::Option("random", "false", "Enable random rotation speeds");
+ options_["quads"] = Scene::Option("quads", "5", "Number of quads to render");
+ options_["texture"] = Scene::Option("texture", "false", "Enable texturing");
+ options_["light"] = Scene::Option("light", "false", "Enable lighting");
+ options_["random"] = Scene::Option("random", "false", "Enable random rotation speeds");
}
ScenePulsar::~ScenePulsar()
{
}
-int ScenePulsar::load()
+int
+ScenePulsar::load()
{
- mScale = LibMatrix::vec3(1.0, 1.0, 1.0);
+ scale_ = vec3(1.0, 1.0, 1.0);
- mRunning = false;
+ running_ = false;
return 1;
}
-void ScenePulsar::unload()
+void
+ScenePulsar::unload()
{
}
-void ScenePulsar::setup()
+void
+ScenePulsar::setup()
{
Scene::setup();
@@ -70,23 +82,21 @@
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// Create a rotation for each quad.
- std::stringstream ss;
- ss << mOptions["quads"].value;
- ss >> mNumQuads;
+ numQuads_ = Util::fromString<int>(options_["quads"].value);
srand((unsigned)time(0));
- for (int i = 0; i < mNumQuads; i++) {
- mRotations.push_back(LibMatrix::vec3());
- if (mOptions["random"].value == "true") {
- mRotationSpeeds.push_back(LibMatrix::vec3(((float)rand() / (float)RAND_MAX) * 5.0,
- ((float)rand() / (float)RAND_MAX) * 5.0,
- 0.0));
+ for (int i = 0; i < numQuads_; i++) {
+ rotations_.push_back(vec3());
+ if (options_["random"].value == "true") {
+ rotationSpeeds_.push_back(vec3((static_cast<float>(rand()) / static_cast<float>(RAND_MAX)) * 5.0,
+ (static_cast<float>(rand()) / static_cast<float>(RAND_MAX)) * 5.0,
+ 0.0));
}
else {
float integral;
float x_rot = std::modf((i + 1) * M_PI, &integral);
float y_rot = std::modf((i + 1) * M_E, &integral);
- mRotationSpeeds.push_back(LibMatrix::vec3(x_rot * 5.0,
+ rotationSpeeds_.push_back(vec3(x_rot * 5.0,
y_rot * 5.0,
0.0));
}
@@ -95,16 +105,16 @@
// Load shaders
std::string vtx_shader_filename;
std::string frg_shader_filename;
- static const LibMatrix::vec4 lightPosition(-20.0f, 20.0f,-20.0f, 1.0f);
- if (mOptions["light"].value == "true") {
+ static const vec4 lightPosition(-20.0f, 20.0f,-20.0f, 1.0f);
+ if (options_["light"].value == "true") {
vtx_shader_filename = GLMARK_DATA_PATH"/shaders/pulsar-light.vert";
} else {
vtx_shader_filename = GLMARK_DATA_PATH"/shaders/pulsar.vert";
}
- if (mOptions["texture"].value == "true") {
+ if (options_["texture"].value == "true") {
frg_shader_filename = GLMARK_DATA_PATH"/shaders/light-basic-tex.frag";
- Texture::load(GLMARK_DATA_PATH"/textures/crate-base.png", &mTexture,
+ Texture::load(GLMARK_DATA_PATH"/textures/crate-base.png", &texture_,
GL_NEAREST, GL_NEAREST, 0);
} else {
@@ -113,12 +123,12 @@
ShaderSource vtx_source(vtx_shader_filename);
ShaderSource frg_source(frg_shader_filename);
- if (mOptions["light"].value == "true") {
+ if (options_["light"].value == "true") {
// Load the light position constant
vtx_source.add_const("LightSourcePosition", lightPosition);
}
- if (!Scene::load_shaders_from_strings(mProgram, vtx_source.str(),
+ if (!Scene::load_shaders_from_strings(program_, vtx_source.str(),
frg_source.str()))
{
return;
@@ -126,23 +136,24 @@
create_and_setup_mesh();
- mProgram.start();
-
- mCurrentFrame = 0;
-
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ program_.start();
+
+ currentFrame_ = 0;
+
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
-void ScenePulsar::teardown()
+void
+ScenePulsar::teardown()
{
- mProgram.stop();
- mProgram.release();
+ program_.stop();
+ program_.release();
- if (mOptions["texture"].value == "true") {
- glDeleteTextures(1, &mTexture);
- mTexture = 0;
+ if (options_["texture"].value == "true") {
+ glDeleteTextures(1, &texture_);
+ texture_ = 0;
}
// Re-enable back-face culling
@@ -150,61 +161,63 @@
// Disable alpha blending
glDisable(GL_BLEND);
- mPlaneMesh.reset();
+ mesh_.reset();
Scene::teardown();
}
-void ScenePulsar::update()
+void
+ScenePulsar::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double dt = current_time - mLastUpdateTime;
- double elapsed_time = current_time - mStartTime;
-
- mLastUpdateTime = current_time;
-
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
- }
-
- for (int i = 0; i < mNumQuads; i++) {
- mRotations[i] += mRotationSpeeds[i] * (dt * 60);
- }
-
- mScale = LibMatrix::vec3(cos(elapsed_time / 3.60) * 10.0, sin(elapsed_time / 3.60) * 10.0, 1.0);
-
- mCurrentFrame++;
+ double dt = current_time - lastUpdateTime_;
+ double elapsed_time = current_time - startTime_;
+
+ lastUpdateTime_ = current_time;
+
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
+ }
+
+ for (int i = 0; i < numQuads_; i++) {
+ rotations_[i] += rotationSpeeds_[i] * (dt * 60);
+ }
+
+ scale_ = vec3(cos(elapsed_time / 3.60) * 10.0, sin(elapsed_time / 3.60) * 10.0, 1.0);
+
+ currentFrame_++;
}
-void ScenePulsar::draw()
+void
+ScenePulsar::draw()
{
- if (mOptions["texture"].value == "true") {
+ if (options_["texture"].value == "true") {
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D, mTexture);
+ glBindTexture(GL_TEXTURE_2D, texture_);
}
- for (int i = 0; i < mNumQuads; i++) {
+ for (int i = 0; i < numQuads_; i++) {
// Load the ModelViewProjectionMatrix uniform in the shader
- LibMatrix::Stack4 model_view;
- LibMatrix::mat4 model_view_proj(mCanvas.projection());
- model_view.scale(mScale.x(), mScale.y(), mScale.z());
+ Stack4 model_view;
+ mat4 model_view_proj(canvas_.projection());
+ model_view.scale(scale_.x(), scale_.y(), scale_.z());
model_view.translate(0.0f, 0.0f, -10.0f);
- model_view.rotate(mRotations[i].x(), 1.0f, 0.0f, 0.0f);
- model_view.rotate(mRotations[i].y(), 0.0f, 1.0f, 0.0f);
- model_view.rotate(mRotations[i].z(), 0.0f, 0.0f, 1.0f);
+ model_view.rotate(rotations_[i].x(), 1.0f, 0.0f, 0.0f);
+ model_view.rotate(rotations_[i].y(), 0.0f, 1.0f, 0.0f);
+ model_view.rotate(rotations_[i].z(), 0.0f, 0.0f, 1.0f);
model_view_proj *= model_view.getCurrent();
- mProgram["ModelViewProjectionMatrix"] = model_view_proj;
+ program_["ModelViewProjectionMatrix"] = model_view_proj;
- if (mOptions["light"].value == "true") {
+ if (options_["light"].value == "true") {
// Load the NormalMatrix uniform in the shader. The NormalMatrix is the
// inverse transpose of the model view matrix.
- LibMatrix::mat4 normal_matrix(model_view.getCurrent());
+ mat4 normal_matrix(model_view.getCurrent());
normal_matrix.inverse().transpose();
- mProgram["NormalMatrix"] = normal_matrix;
+ program_["NormalMatrix"] = normal_matrix;
}
- mPlaneMesh.render_vbo();
+ mesh_.render_vbo();
}
}
@@ -214,42 +227,43 @@
return ValidationUnknown;
}
-void ScenePulsar::create_and_setup_mesh()
+void
+ScenePulsar::create_and_setup_mesh()
{
- bool texture = mOptions["texture"].value == "true";
- bool light = mOptions["light"].value == "true";
+ bool texture = options_["texture"].value == "true";
+ bool light = options_["light"].value == "true";
struct PlaneMeshVertex {
- LibMatrix::vec3 position;
- LibMatrix::vec4 color;
- LibMatrix::vec2 texcoord;
- LibMatrix::vec3 normal;
+ vec3 position;
+ vec4 color;
+ vec2 texcoord;
+ vec3 normal;
};
PlaneMeshVertex plane_vertices[] = {
{
- LibMatrix::vec3(-1.0, -1.0, 0.0),
- LibMatrix::vec4(1.0, 0.0, 0.0, 0.4),
- LibMatrix::vec2(0.0, 0.0),
- LibMatrix::vec3(0.0, 0.0, 1.0)
- },
- {
- LibMatrix::vec3(-1.0, 1.0, 0.0),
- LibMatrix::vec4(0.0, 1.0, 0.0, 0.4),
- LibMatrix::vec2(0.0, 1.0),
- LibMatrix::vec3(0.0, 0.0, 1.0)
- },
- {
- LibMatrix::vec3(1.0, 1.0, 0.0),
- LibMatrix::vec4(0.0, 0.0, 1.0, 0.4),
- LibMatrix::vec2(1.0, 1.0),
- LibMatrix::vec3(0.0, 0.0, 1.0)
- },
- {
- LibMatrix::vec3(1.0, -1.0, 0.0),
- LibMatrix::vec4(1.0, 1.0, 1.0, 1.0),
- LibMatrix::vec2(1.0, 0.0),
- LibMatrix::vec3(0.0, 0.0, 1.0)
+ vec3(-1.0, -1.0, 0.0),
+ vec4(1.0, 0.0, 0.0, 0.4),
+ vec2(0.0, 0.0),
+ vec3(0.0, 0.0, 1.0)
+ },
+ {
+ vec3(-1.0, 1.0, 0.0),
+ vec4(0.0, 1.0, 0.0, 0.4),
+ vec2(0.0, 1.0),
+ vec3(0.0, 0.0, 1.0)
+ },
+ {
+ vec3(1.0, 1.0, 0.0),
+ vec4(0.0, 0.0, 1.0, 0.4),
+ vec2(1.0, 1.0),
+ vec3(0.0, 0.0, 1.0)
+ },
+ {
+ vec3(1.0, -1.0, 0.0),
+ vec4(1.0, 1.0, 1.0, 1.0),
+ vec2(1.0, 0.0),
+ vec3(0.0, 0.0, 1.0)
}
};
@@ -264,31 +278,31 @@
if (light)
vertex_format.push_back(3); // Normal
- mPlaneMesh.set_vertex_format(vertex_format);
+ mesh_.set_vertex_format(vertex_format);
// Build the plane mesh
for (size_t i = 0; i < sizeof(vertex_index) / sizeof(*vertex_index); i++) {
PlaneMeshVertex& vertex = plane_vertices[vertex_index[i]];
- mPlaneMesh.next_vertex();
- mPlaneMesh.set_attrib(0, vertex.position);
- mPlaneMesh.set_attrib(1, vertex.color);
+ mesh_.next_vertex();
+ mesh_.set_attrib(0, vertex.position);
+ mesh_.set_attrib(1, vertex.color);
if (texture)
- mPlaneMesh.set_attrib(2, vertex.texcoord);
+ mesh_.set_attrib(2, vertex.texcoord);
if (light)
- mPlaneMesh.set_attrib(2 + ((int)texture), vertex.normal);
+ mesh_.set_attrib(2 + static_cast<int>(texture), vertex.normal);
}
- mPlaneMesh.build_vbo();
+ mesh_.build_vbo();
// Set attribute locations
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- attrib_locations.push_back(mProgram["vtxcolor"].location());
+ attrib_locations.push_back(program_["position"].location());
+ attrib_locations.push_back(program_["vtxcolor"].location());
if (texture)
- attrib_locations.push_back(mProgram["texcoord"].location());
+ attrib_locations.push_back(program_["texcoord"].location());
if (light)
- attrib_locations.push_back(mProgram["normal"].location());
- mPlaneMesh.set_attrib_locations(attrib_locations);
+ attrib_locations.push_back(program_["normal"].location());
+ mesh_.set_attrib_locations(attrib_locations);
}
=== modified file 'src/scene-shading.cpp'
@@ -26,6 +26,7 @@
#include "stack.h"
#include "vec.h"
#include "log.h"
+#include "util.h"
#include "shader-source.h"
#include <cmath>
@@ -35,27 +36,9 @@
using std::string;
using std::endl;
-template<typename T> T
-fromString(const string& asString)
-{
- std::stringstream ss(asString);
- T retVal;
- ss >> retVal;
- return retVal;
-}
-
-template<typename T>
-string
-toString(const T t)
-{
- std::stringstream ss;
- ss << t;
- return ss.str();
-}
-
SceneShading::SceneShading(Canvas &pCanvas) :
Scene(pCanvas, "shading"),
- mOrientModel(false)
+ orientModel_(false)
{
const ModelMap& modelMap = Model::find_models();
std::string optionDesc("Which model to use [");
@@ -73,11 +56,11 @@
doSeparator = true;
}
optionDesc += "]";
- mOptions["shading"] = Scene::Option("shading", "gouraud",
+ options_["shading"] = Scene::Option("shading", "gouraud",
"[gouraud, blinn-phong-inf, phong]");
- mOptions["num-lights"] = Scene::Option("num-lights", "1",
+ options_["num-lights"] = Scene::Option("num-lights", "1",
"The number of lights applied to the scene (phong only)");
- mOptions["model"] = Scene::Option("model", "cat",
+ options_["model"] = Scene::Option("model", "cat",
optionDesc);
}
@@ -85,18 +68,20 @@
{
}
-int SceneShading::load()
+int
+SceneShading::load()
{
- mRotationSpeed = 36.0f;
+ rotationSpeed_ = 36.0f;
- mRunning = false;
+ running_ = false;
return 1;
}
-void SceneShading::unload()
+void
+SceneShading::unload()
{
- mMesh.reset();
+ mesh_.reset();
}
static string
@@ -120,7 +105,7 @@
{
// Construct constant names for the light position and color and add it
// to the list of constants for the shader.
- string indexString(toString(l));
+ string indexString(Util::toString(l));
string curLightPosition(lightPositionName + indexString);
string curLightColor(lightColorName + indexString);
float sin_theta(sin(theta * l));
@@ -145,7 +130,8 @@
return source.str();
}
-void SceneShading::setup()
+void
+SceneShading::setup()
{
Scene::setup();
@@ -161,7 +147,7 @@
// Load and add constants to shaders
std::string vtx_shader_filename;
std::string frg_shader_filename;
- const std::string &shading = mOptions["shading"].value;
+ const std::string &shading = options_["shading"].value;
ShaderSource vtx_source;
ShaderSource frg_source;
if (shading == "gouraud") {
@@ -183,21 +169,21 @@
else if (shading == "phong") {
vtx_shader_filename = GLMARK_DATA_PATH"/shaders/light-phong.vert";
frg_shader_filename = GLMARK_DATA_PATH"/shaders/light-phong.frag";
- unsigned int num_lights = fromString<unsigned int>(mOptions["num-lights"].value);
+ unsigned int num_lights = Util::fromString<unsigned int>(options_["num-lights"].value);
string fragsource = get_fragment_shader_source(frg_shader_filename, num_lights);
frg_source.append(fragsource);
frg_source.add_const("MaterialDiffuse", materialDiffuse);
vtx_source.append_file(vtx_shader_filename);
}
- if (!Scene::load_shaders_from_strings(mProgram, vtx_source.str(),
+ if (!Scene::load_shaders_from_strings(program_, vtx_source.str(),
frg_source.str()))
{
return;
}
Model model;
- const std::string& whichModel(mOptions["model"].value);
+ const std::string& whichModel(options_["model"].value);
bool modelLoaded = model.load(whichModel);
if(!modelLoaded)
@@ -220,9 +206,9 @@
// Horse rotates around the Y axis
if (whichModel == "buddha" || whichModel == "dragon")
{
- mOrientModel = true;
- mOrientationAngle = -90.0;
- mOrientationVec = vec3(1.0, 0.0, 0.0);
+ orientModel_ = true;
+ orientationAngle_ = -90.0;
+ orientationVec_ = vec3(1.0, 0.0, 0.0);
}
model.calculate_normals();
@@ -232,90 +218,93 @@
attribs.push_back(std::pair<Model::AttribType, int>(Model::AttribTypePosition, 3));
attribs.push_back(std::pair<Model::AttribType, int>(Model::AttribTypeNormal, 3));
- model.convert_to_mesh(mMesh, attribs);
+ model.convert_to_mesh(mesh_, attribs);
- mMesh.build_vbo();
+ mesh_.build_vbo();
/* Calculate a projection matrix that is a good fit for the model */
vec3 maxVec = model.maxVec();
vec3 minVec = model.minVec();
vec3 diffVec = maxVec - minVec;
- mCenterVec = maxVec + minVec;
- mCenterVec /= 2.0;
+ centerVec_ = maxVec + minVec;
+ centerVec_ /= 2.0;
float diameter = diffVec.length();
- mRadius = diameter / 2;
- float fovy = 2.0 * atanf(mRadius / (2.0 + mRadius));
+ radius_ = diameter / 2;
+ float fovy = 2.0 * atanf(radius_ / (2.0 + radius_));
fovy /= M_PI;
fovy *= 180.0;
- float aspect(static_cast<float>(mCanvas.width())/static_cast<float>(mCanvas.height()));
- mPerspective.setIdentity();
- mPerspective *= LibMatrix::Mat4::perspective(fovy, aspect, 2.0, 2.0 + diameter);
+ float aspect(static_cast<float>(canvas_.width())/static_cast<float>(canvas_.height()));
+ perspective_.setIdentity();
+ perspective_ *= LibMatrix::Mat4::perspective(fovy, aspect, 2.0, 2.0 + diameter);
- mProgram.start();
+ program_.start();
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- attrib_locations.push_back(mProgram["normal"].location());
- mMesh.set_attrib_locations(attrib_locations);
+ attrib_locations.push_back(program_["position"].location());
+ attrib_locations.push_back(program_["normal"].location());
+ mesh_.set_attrib_locations(attrib_locations);
- mCurrentFrame = 0;
- mRotation = 0.0f;
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ currentFrame_ = 0;
+ rotation_ = 0.0f;
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
-void SceneShading::teardown()
+void
+SceneShading::teardown()
{
- mProgram.stop();
- mProgram.release();
+ program_.stop();
+ program_.release();
Scene::teardown();
}
-void SceneShading::update()
+void
+SceneShading::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double dt = current_time - mLastUpdateTime;
- double elapsed_time = current_time - mStartTime;
-
- mLastUpdateTime = current_time;
-
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
+ double dt = current_time - lastUpdateTime_;
+ double elapsed_time = current_time - startTime_;
+
+ lastUpdateTime_ = current_time;
+
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
}
- mRotation += mRotationSpeed * dt;
+ rotation_ += rotationSpeed_ * dt;
- mCurrentFrame++;
+ currentFrame_++;
}
-void SceneShading::draw()
+void
+SceneShading::draw()
{
// Load the ModelViewProjectionMatrix uniform in the shader
LibMatrix::Stack4 model_view;
- model_view.translate(-mCenterVec.x(), -mCenterVec.y(), -(mCenterVec.z() + 2.0 + mRadius));
- model_view.rotate(mRotation, 0.0f, 1.0f, 0.0f);
- if (mOrientModel)
+ model_view.translate(-centerVec_.x(), -centerVec_.y(), -(centerVec_.z() + 2.0 + radius_));
+ model_view.rotate(rotation_, 0.0f, 1.0f, 0.0f);
+ if (orientModel_)
{
- model_view.rotate(mOrientationAngle, mOrientationVec.x(), mOrientationVec.y(), mOrientationVec.z());
+ model_view.rotate(orientationAngle_, orientationVec_.x(), orientationVec_.y(), orientationVec_.z());
}
- LibMatrix::mat4 model_view_proj(mPerspective);
+ LibMatrix::mat4 model_view_proj(perspective_);
model_view_proj *= model_view.getCurrent();
- mProgram["ModelViewProjectionMatrix"] = model_view_proj;
+ program_["ModelViewProjectionMatrix"] = model_view_proj;
// Load the NormalMatrix uniform in the shader. The NormalMatrix is the
// inverse transpose of the model view matrix.
LibMatrix::mat4 normal_matrix(model_view.getCurrent());
normal_matrix.inverse().transpose();
- mProgram["NormalMatrix"] = normal_matrix;
+ program_["NormalMatrix"] = normal_matrix;
// Load the modelview matrix itself
- mProgram["ModelViewMatrix"] = model_view.getCurrent();
+ program_["ModelViewMatrix"] = model_view.getCurrent();
- mMesh.render_vbo();
+ mesh_.render_vbo();
}
Scene::ValidationResult
@@ -323,21 +312,21 @@
{
static const double radius_3d(std::sqrt(3.0));
- if (mRotation != 0)
+ if (rotation_ != 0)
return Scene::ValidationUnknown;
Canvas::Pixel ref;
- Canvas::Pixel pixel = mCanvas.read_pixel(mCanvas.width() / 3,
- mCanvas.height() / 3);
+ Canvas::Pixel pixel = canvas_.read_pixel(canvas_.width() / 3,
+ canvas_.height() / 3);
- const std::string &filter = mOptions["shading"].value;
+ const std::string &filter = options_["shading"].value;
if (filter == "gouraud")
ref = Canvas::Pixel(0x00, 0x00, 0x2d, 0xff);
else if (filter == "blinn-phong-inf")
ref = Canvas::Pixel(0x1a, 0x1a, 0x3e, 0xff);
- else if (filter == "phong" && mOptions["num-lights"].value == "1")
+ else if (filter == "phong" && options_["num-lights"].value == "1")
ref = Canvas::Pixel(0x05, 0x05, 0xad, 0xff);
else
return Scene::ValidationUnknown;
=== modified file 'src/scene-texture.cpp'
@@ -34,7 +34,7 @@
SceneTexture::SceneTexture(Canvas &pCanvas) :
Scene(pCanvas, "texture")
{
- mOptions["texture-filter"] = Scene::Option("texture-filter", "nearest",
+ options_["texture-filter"] = Scene::Option("texture-filter", "nearest",
"[nearest, linear, mipmap]");
}
@@ -42,7 +42,8 @@
{
}
-int SceneTexture::load()
+int
+SceneTexture::load()
{
Model::find_models();
Model model;
@@ -51,22 +52,24 @@
return 0;
model.calculate_normals();
- model.convert_to_mesh(mCubeMesh);
- mCubeMesh.build_vbo();
-
- mRotationSpeed = LibMatrix::vec3(36.0f, 36.0f, 36.0f);
-
- mRunning = false;
+ model.convert_to_mesh(mesh_);
+ mesh_.build_vbo();
+
+ rotationSpeed_ = LibMatrix::vec3(36.0f, 36.0f, 36.0f);
+
+ running_ = false;
return 1;
}
-void SceneTexture::unload()
+void
+SceneTexture::unload()
{
- mCubeMesh.reset();
+ mesh_.reset();
}
-void SceneTexture::setup()
+void
+SceneTexture::setup()
{
Scene::setup();
@@ -82,22 +85,22 @@
vtx_source.add_const("LightSourcePosition", lightPosition);
vtx_source.add_const("MaterialDiffuse", materialDiffuse);
- if (!Scene::load_shaders_from_strings(mProgram, vtx_source.str(),
+ if (!Scene::load_shaders_from_strings(program_, vtx_source.str(),
frg_source.str()))
{
return;
}
std::vector<GLint> attrib_locations;
- attrib_locations.push_back(mProgram["position"].location());
- attrib_locations.push_back(mProgram["normal"].location());
- attrib_locations.push_back(mProgram["texcoord"].location());
- mCubeMesh.set_attrib_locations(attrib_locations);
+ attrib_locations.push_back(program_["position"].location());
+ attrib_locations.push_back(program_["normal"].location());
+ attrib_locations.push_back(program_["texcoord"].location());
+ mesh_.set_attrib_locations(attrib_locations);
// Create texture according to selected filtering
GLint min_filter = GL_NONE;
GLint mag_filter = GL_NONE;
- const std::string &filter = mOptions["texture-filter"].value;
+ const std::string &filter = options_["texture-filter"].value;
if (filter == "nearest") {
min_filter = GL_NEAREST;
@@ -112,70 +115,73 @@
mag_filter = GL_LINEAR;
}
- Texture::load(GLMARK_DATA_PATH"/textures/crate-base.png", &mTexture,
+ Texture::load(GLMARK_DATA_PATH"/textures/crate-base.png", &texture_,
min_filter, mag_filter, 0);
- mProgram.start();
+ program_.start();
- mCurrentFrame = 0;
- mRotation = LibMatrix::vec3();
- mRunning = true;
- mStartTime = Scene::get_timestamp_us() / 1000000.0;
- mLastUpdateTime = mStartTime;
+ currentFrame_ = 0;
+ rotation_ = LibMatrix::vec3();
+ running_ = true;
+ startTime_ = Scene::get_timestamp_us() / 1000000.0;
+ lastUpdateTime_ = startTime_;
}
-void SceneTexture::teardown()
+void
+SceneTexture::teardown()
{
- mProgram.stop();
- mProgram.release();
+ program_.stop();
+ program_.release();
- glDeleteTextures(1, &mTexture);
+ glDeleteTextures(1, &texture_);
Scene::teardown();
}
-void SceneTexture::update()
+void
+SceneTexture::update()
{
double current_time = Scene::get_timestamp_us() / 1000000.0;
- double dt = current_time - mLastUpdateTime;
- double elapsed_time = current_time - mStartTime;
-
- mLastUpdateTime = current_time;
-
- if (elapsed_time >= mDuration) {
- mAverageFPS = mCurrentFrame / elapsed_time;
- mRunning = false;
+ double dt = current_time - lastUpdateTime_;
+ double elapsed_time = current_time - startTime_;
+
+ lastUpdateTime_ = current_time;
+
+ if (elapsed_time >= duration_) {
+ averageFPS_ = currentFrame_ / elapsed_time;
+ running_ = false;
}
- mRotation += mRotationSpeed * dt;
+ rotation_ += rotationSpeed_ * dt;
- mCurrentFrame++;
+ currentFrame_++;
}
-void SceneTexture::draw()
+void
+SceneTexture::draw()
{
// Load the ModelViewProjectionMatrix uniform in the shader
LibMatrix::Stack4 model_view;
- LibMatrix::mat4 model_view_proj(mCanvas.projection());
+ LibMatrix::mat4 model_view_proj(canvas_.projection());
model_view.translate(0.0f, 0.0f, -5.0f);
- model_view.rotate(mRotation.x(), 1.0f, 0.0f, 0.0f);
- model_view.rotate(mRotation.y(), 0.0f, 1.0f, 0.0f);
- model_view.rotate(mRotation.z(), 0.0f, 0.0f, 1.0f);
+ model_view.rotate(rotation_.x(), 1.0f, 0.0f, 0.0f);
+ model_view.rotate(rotation_.y(), 0.0f, 1.0f, 0.0f);
+ model_view.rotate(rotation_.z(), 0.0f, 0.0f, 1.0f);
model_view_proj *= model_view.getCurrent();
- mProgram["ModelViewProjectionMatrix"] = model_view_proj;
+ program_["ModelViewProjectionMatrix"] = model_view_proj;
// Load the NormalMatrix uniform in the shader. The NormalMatrix is the
// inverse transpose of the model view matrix.
LibMatrix::mat4 normal_matrix(model_view.getCurrent());
normal_matrix.inverse().transpose();
- mProgram["NormalMatrix"] = normal_matrix;
+ program_["NormalMatrix"] = normal_matrix;
glActiveTexture(GL_TEXTURE0);
- glBindTexture(GL_TEXTURE_2D, mTexture);
+ glBindTexture(GL_TEXTURE_2D, texture_);
- mCubeMesh.render_vbo();
+ mesh_.render_vbo();
}
Scene::ValidationResult
@@ -183,15 +189,15 @@
{
static const double radius_3d(std::sqrt(3.0));
- if (mRotation.x() != 0 || mRotation.y() != 0 || mRotation.z() != 0)
+ if (rotation_.x() != 0 || rotation_.y() != 0 || rotation_.z() != 0)
return Scene::ValidationUnknown;
Canvas::Pixel ref;
- Canvas::Pixel pixel = mCanvas.read_pixel(mCanvas.width() / 2 + 3,
- mCanvas.height() / 2 + 3);
+ Canvas::Pixel pixel = canvas_.read_pixel(canvas_.width() / 2 + 3,
+ canvas_.height() / 2 + 3);
- const std::string &filter = mOptions["texture-filter"].value;
+ const std::string &filter = options_["texture-filter"].value;
if (filter == "nearest")
ref = Canvas::Pixel(0x3b, 0x3a, 0x39, 0xff);
=== modified file 'src/scene.cpp'
@@ -25,6 +25,7 @@
#include "log.h"
#include "shader-source.h"
#include "options.h"
+#include "util.h"
#include <sstream>
#include <cmath>
#include <sys/time.h>
@@ -34,16 +35,16 @@
using std::map;
Scene::Scene(Canvas &pCanvas, const string &name) :
- mCanvas(pCanvas), mName(name),
- mStartTime(0), mLastUpdateTime(0), mCurrentFrame(0), mAverageFPS(0),
- mRunning(0), mDuration(0)
+ canvas_(pCanvas), name_(name),
+ startTime_(0), lastUpdateTime_(0), currentFrame_(0), averageFPS_(0),
+ running_(0), duration_(0)
{
- mOptions["duration"] = Scene::Option("duration", "10.0",
+ options_["duration"] = Scene::Option("duration", "10.0",
"The duration of each benchmark in seconds");
- mOptions["vertex-precision"] = Scene::Option("vertex-precision",
+ options_["vertex-precision"] = Scene::Option("vertex-precision",
"default,default,default,default",
"The precision values for the vertex shader (\"int,float,sampler2d,samplercube\")");
- mOptions["fragment-precision"] = Scene::Option("fragment-precision",
+ options_["fragment-precision"] = Scene::Option("fragment-precision",
"default,default,default,default",
"The precision values for the fragment shader (\"int,float,sampler2d,samplercube\")");
}
@@ -52,41 +53,46 @@
{
}
-int Scene::load()
+int
+Scene::load()
{
return 1;
}
-void Scene::unload()
+void
+Scene::unload()
{
}
-void Scene::setup()
+void
+Scene::setup()
{
- stringstream ss(mOptions["duration"].value);
- ss >> mDuration;
+ duration_ = Util::fromString<double>(options_["duration"].value);
ShaderSource::default_precision(
- ShaderSource::Precision(mOptions["vertex-precision"].value),
+ ShaderSource::Precision(options_["vertex-precision"].value),
ShaderSource::ShaderTypeVertex
);
ShaderSource::default_precision(
- ShaderSource::Precision(mOptions["fragment-precision"].value),
+ ShaderSource::Precision(options_["fragment-precision"].value),
ShaderSource::ShaderTypeFragment
);
}
-void Scene::teardown()
-{
-}
-
-void Scene::update()
-{
-}
-
-void Scene::draw()
+void
+Scene::teardown()
+{
+}
+
+void
+Scene::update()
+{
+}
+
+void
+Scene::draw()
{
}
@@ -95,28 +101,30 @@
{
stringstream ss;
- ss << "[" << mName << "] " << Scene::construct_title(title) << " ";
+ ss << "[" << name_ << "] " << Scene::construct_title(title) << " ";
return ss.str();
}
-unsigned Scene::average_fps()
+unsigned
+Scene::average_fps()
{
- return mAverageFPS;
+ return averageFPS_;
}
-bool Scene::is_running()
+bool
+Scene::is_running()
{
- return mRunning;
+ return running_;
}
bool
Scene::set_option(const string &opt, const string &val)
-{
- map<string, Option>::iterator iter = mOptions.find(opt);
+{
+ map<string, Option>::iterator iter = options_.find(opt);
- if (iter == mOptions.end())
+ if (iter == options_.end())
return false;
iter->second.value = val;
@@ -128,8 +136,8 @@
void
Scene::reset_options()
{
- for (map<string, Option>::iterator iter = mOptions.begin();
- iter != mOptions.end();
+ for (map<string, Option>::iterator iter = options_.begin();
+ iter != options_.end();
iter++)
{
Option &opt = iter->second;
@@ -141,10 +149,10 @@
bool
Scene::set_option_default(const string &opt, const string &val)
-{
- map<string, Option>::iterator iter = mOptions.find(opt);
+{
+ map<string, Option>::iterator iter = options_.find(opt);
- if (iter == mOptions.end())
+ if (iter == options_.end())
return false;
iter->second.default_value = val;
@@ -159,8 +167,8 @@
stringstream ss;
if (title == "") {
- for (map<string, Option>::iterator iter = mOptions.begin();
- iter != mOptions.end();
+ for (map<string, Option>::iterator iter = options_.begin();
+ iter != options_.end();
iter++)
{
if (Options::show_all_options || iter->second.set)
=== modified file 'src/scene.h'
@@ -81,11 +81,11 @@
unsigned average_fps();
bool is_running();
- const std::string &name() { return mName; }
+ const std::string &name() { return name_; }
virtual bool set_option(const std::string &opt, const std::string &val);
void reset_options();
bool set_option_default(const std::string &opt, const std::string &val);
- const std::map<std::string, Option> &options() { return mOptions; }
+ const std::map<std::string, Option> &options() { return options_; }
static Scene &dummy()
{
@@ -112,17 +112,15 @@
double pixel_value_distance(Canvas::Pixel p1, Canvas::Pixel p2,
bool use_alpha=false);
- Canvas &mCanvas;
- std::string mName;
- std::map<std::string, Option> mOptions;
-
- double mStartTime;
- double mLastUpdateTime;
- unsigned mCurrentFrame;
- unsigned mAverageFPS; // Average FPS of run
-
- bool mRunning;
- double mDuration; // Duration of run in seconds
+ Canvas &canvas_;
+ std::string name_;
+ std::map<std::string, Option> options_;
+ double startTime_;
+ double lastUpdateTime_;
+ unsigned currentFrame_;
+ unsigned averageFPS_; // Average FPS of run
+ bool running_;
+ double duration_; // Duration of run in seconds
};
/*
@@ -136,7 +134,7 @@
void setup();
private:
- std::list<std::pair<std::string, std::string> > mDefaultOptions;
+ std::list<std::pair<std::string, std::string> > defaultOptions_;
};
class SceneBuild : public Scene
@@ -154,17 +152,17 @@
~SceneBuild();
protected:
- Program mProgram;
- LibMatrix::mat4 mPerspective;
- LibMatrix::vec3 mCenterVec;
- float mRadius;
- Mesh mMesh;
- bool mOrientModel;
- float mOrientationAngle;
- LibMatrix::vec3 mOrientationVec;
- float mRotation;
- float mRotationSpeed;
- bool mUseVbo;
+ Program program_;
+ LibMatrix::mat4 perspective_;
+ LibMatrix::vec3 centerVec_;
+ float radius_;
+ Mesh mesh_;
+ bool orientModel_;
+ float orientationAngle_;
+ LibMatrix::vec3 orientationVec_;
+ float rotation_;
+ float rotationSpeed_;
+ bool useVbo_;
};
class SceneTexture : public Scene
@@ -182,12 +180,11 @@
~SceneTexture();
protected:
- Program mProgram;
-
- Mesh mCubeMesh;
- GLuint mTexture;
- LibMatrix::vec3 mRotation;
- LibMatrix::vec3 mRotationSpeed;
+ Program program_;
+ Mesh mesh_;
+ GLuint texture_;
+ LibMatrix::vec3 rotation_;
+ LibMatrix::vec3 rotationSpeed_;
};
class SceneShading : public Scene
@@ -205,16 +202,16 @@
~SceneShading();
protected:
- Program mProgram;
- float mRadius;
- bool mOrientModel;
- float mOrientationAngle;
- LibMatrix::vec3 mOrientationVec;
- LibMatrix::vec3 mCenterVec;
- LibMatrix::mat4 mPerspective;
- Mesh mMesh;
- float mRotation;
- float mRotationSpeed;
+ Program program_;
+ float radius_;
+ bool orientModel_;
+ float orientationAngle_;
+ LibMatrix::vec3 orientationVec_;
+ LibMatrix::vec3 centerVec_;
+ LibMatrix::mat4 perspective_;
+ Mesh mesh_;
+ float rotation_;
+ float rotationSpeed_;
};
class SceneGrid : public Scene
@@ -232,11 +229,10 @@
~SceneGrid();
protected:
- Program mProgram;
-
- Mesh mMesh;
- float mRotation;
- float mRotationSpeed;
+ Program program_;
+ Mesh mesh_;
+ float rotation_;
+ float rotationSpeed_;
};
class SceneConditionals : public SceneGrid
@@ -281,12 +277,11 @@
~SceneBump();
protected:
- Program mProgram;
-
- Mesh mMesh;
- GLuint mTexture;
- float mRotation;
- float mRotationSpeed;
+ Program program_;
+ Mesh mesh_;
+ GLuint texture_;
+ float rotation_;
+ float rotationSpeed_;
private:
void setup_model_plain(const std::string &type);
void setup_model_normals();
@@ -328,15 +323,13 @@
~ScenePulsar();
protected:
- int mNumQuads;
- Program mProgram;
-
- Mesh mPlaneMesh;
- LibMatrix::vec3 mScale;
- std::vector<LibMatrix::vec3> mRotations;
- std::vector<LibMatrix::vec3> mRotationSpeeds;
-
- GLuint mTexture;
+ int numQuads_;
+ Program program_;
+ Mesh mesh_;
+ LibMatrix::vec3 scale_;
+ std::vector<LibMatrix::vec3> rotations_;
+ std::vector<LibMatrix::vec3> rotationSpeeds_;
+ GLuint texture_;
private:
void create_and_setup_mesh();
=== modified file 'src/shader-source.cpp'
@@ -28,16 +28,16 @@
#include "vec.h"
#include "util.h"
-/**
+/**
* Holds default precision values for all shader types
* (even the unknown type, which is hardwired to default precision values)
*/
std::vector<ShaderSource::Precision>
ShaderSource::default_precision_(ShaderSource::ShaderTypeUnknown + 1);
-/**
+/**
* Loads the contents of a file into a string.
- *
+ *
* @param filename the name of the file
* @param str the string to put the contents of the file into
*/
@@ -64,9 +64,9 @@
}
-/**
+/**
* Appends a string to the shader source.
- *
+ *
* @param str the string to append
*/
void
@@ -75,9 +75,9 @@
source_ << str;
}
-/**
+/**
* Appends the contents of a file to the shader source.
- *
+ *
* @param filename the name of the file to append
*/
void
@@ -88,9 +88,9 @@
source_ << source;
}
-/**
+/**
* Replaces a string in the source with another string.
- *
+ *
* @param remove the string to replace
* @param insert the string to replace with
*/
@@ -109,9 +109,9 @@
source_.str(str);
}
-/**
+/**
* Replaces a string in the source with the contents of a file.
- *
+ *
* @param remove the string to replace
* @param filename the name of the file to read from
*/
@@ -123,12 +123,12 @@
replace(remove, source);
}
-/**
+/**
* Adds a string (usually containing a constant definition) at
* global (per shader) scope.
*
* The string is placed after any default precision qualifiers.
- *
+ *
* @param str the string to add
*/
void
@@ -141,7 +141,7 @@
pos = source.rfind("precision");
if (pos != std::string::npos) {
- /*
+ /*
* Find the next #endif line of a preprocessor block that contains
* the precision qualifier.
*/
@@ -165,12 +165,12 @@
source_.str(source);
}
-/**
+/**
* Adds a string (usually containing a constant definition) at
* global (per shader) scope.
*
* The string is placed after any default precision qualifiers.
- *
+ *
* @param function the function to add the string into
* @param str the string to add
*/
@@ -195,7 +195,7 @@
source_.str(source);
}
-/**
+/**
* Adds a string (usually containing a constant definition) to a shader source
*
* If the function parameter is empty, the string will be added to global
@@ -213,7 +213,7 @@
add_global(str);
}
-/**
+/**
* Adds a float constant definition.
*
* @param name the name of the constant
@@ -231,7 +231,7 @@
add(ss.str(), function);
}
-/**
+/**
* Adds a float array constant definition.
*
* Note that various GLSL versions (including ES) don't support
@@ -262,7 +262,7 @@
add(ss.str(), function);
}
-/**
+/**
* Adds a vec3 constant definition.
*
* @param name the name of the constant
@@ -281,7 +281,7 @@
add(ss.str(), function);
}
-/**
+/**
* Adds a vec4 constant definition.
*
* @param name the name of the constant
@@ -300,7 +300,7 @@
add(ss.str(), function);
}
-/**
+/**
* Adds a mat3 constant definition.
*
* @param name the name of the constant
@@ -322,7 +322,7 @@
add(ss.str(), function);
}
-/**
+/**
* Adds a float array declaration and initialization.
*
* @param name the name of the array
@@ -351,7 +351,7 @@
iter != array.end();
iter++)
{
- ss << name << "[" << iter - array.begin() << "] = " << *iter << ";" << std::endl;
+ ss << name << "[" << iter - array.begin() << "] = " << *iter << ";" << std::endl;
}
add(ss.str(), init_function);
@@ -359,12 +359,12 @@
add(decl, decl_function);
}
-/**
+/**
* Gets the ShaderType for this ShaderSource.
*
* If the ShaderType is unknown, an attempt is made to infer
* the type from the shader source contents.
- *
+ *
* @return the ShaderType
*/
ShaderSource::ShaderType
@@ -385,9 +385,9 @@
return type_;
}
-/**
+/**
* Helper function that emits a precision statement.
- *
+ *
* @param ss the stringstream to add the statement to
* @param val the precision value
* @param type_str the variable type to apply the precision value to
@@ -425,11 +425,11 @@
}
}
-/**
+/**
* Gets a string containing the complete shader source.
*
* Precision statements are applied at this point.
- *
+ *
* @return the shader source
*/
std::string
@@ -445,7 +445,7 @@
/* Create the precision statements */
std::stringstream ss;
-
+
emit_precision(ss, precision.int_precision, "int");
emit_precision(ss, precision.float_precision, "float");
emit_precision(ss, precision.sampler2d_precision, "sampler2D");
@@ -460,11 +460,11 @@
return precision_str + source_.str();
}
-/**
+/**
* Sets the precision that will be used for this shader.
*
* This overrides any default values set with ShaderSource::default_*_precision().
- *
+ *
* @param precision the precision to set
*/
void
@@ -474,9 +474,9 @@
precision_has_been_set_ = true;
}
-/**
+/**
* Gets the precision that will be used for this shader.
- *
+ *
* @return the precision
*/
const ShaderSource::Precision&
@@ -485,14 +485,14 @@
return precision_;
}
-/**
+/**
* Sets the default precision that will be used for a shaders type.
*
* If type is ShaderTypeUnknown the supplied precision is used for all
* shader types.
*
* This can be overriden per ShaderSource object by using ::precision().
- *
+ *
* @param precision the default precision to set
* @param type the ShaderType to use the precision for
*/
@@ -512,14 +512,14 @@
}
}
-/**
+/**
* Gets the default precision that will be used for a shader type.
*
* It is valid to use a type of ShaderTypeUnknown. This will always
* return a Precision with default values.
*
* @param type the ShaderType to get the precision of
- *
+ *
* @return the precision
*/
const ShaderSource::Precision&
@@ -535,7 +535,7 @@
* ShaderSource::Precision constructors *
****************************************/
-/**
+/**
* Creates a ShaderSource::Precision with default precision values.
*/
ShaderSource::Precision::Precision() :
@@ -546,7 +546,7 @@
{
}
-/**
+/**
* Creates a ShaderSource::Precision using the supplied precision values.
*/
ShaderSource::Precision::Precision(ShaderSource::PrecisionValue int_p,
@@ -558,7 +558,7 @@
{
}
-/**
+/**
* Creates a ShaderSource::Precision from a string representation of
* precision values.
*
@@ -566,7 +566,7 @@
* "<int>,<float>,<sampler2d>,<samplercube>"
*
* Each precision value is one of "high", "medium", "low" or "default".
- *
+ *
* @param precision_values the string representation of the precision values
*/
ShaderSource::Precision::Precision(const std::string& precision_values) :
=== modified file 'src/shader-source.h'
@@ -26,7 +26,7 @@
#include "vec.h"
#include "mat.h"
-/**
+/**
* Helper class for loading and manipulating shader sources.
*/
class ShaderSource
=== modified file 'src/util.cpp'
@@ -32,9 +32,9 @@
#include "log.h"
#include "util.h"
-/**
+/**
* Splits a string using a delimiter
- *
+ *
* @param s the string to split
* @param delim the delimitir to use
* @param elems the string vector to populate
=== modified file 'src/util.h'
@@ -27,6 +27,7 @@
#include <string>
#include <vector>
#include <istream>
+#include <sstream>
#ifdef ANDROID
#include <android/asset_manager_jni.h>
@@ -47,6 +48,25 @@
vec.clear();
}
+ template<typename T>
+ static T
+ fromString(const std::string& asString)
+ {
+ std::stringstream ss(asString);
+ T retVal;
+ ss >> retVal;
+ return retVal;
+ }
+
+ template<typename T>
+ static std::string
+ toString(const T t)
+ {
+ std::stringstream ss;
+ ss << t;
+ return ss.str();
+ }
+
#ifdef ANDROID
static void android_set_asset_manager(AAssetManager *asset_manager);