486 lines
18 KiB
C
Executable File
486 lines
18 KiB
C
Executable File
/*
|
|
* Benchmark for GLSL procedural noise functions.
|
|
*
|
|
* Shaders are loaded from external files, named in
|
|
* the macro definitions VERTSHADERFILE and FRAGSHADERFILE*.
|
|
* The main program draws a flat plane covering the
|
|
* viewport, activates each of six fragment shaders in turn
|
|
* and reports the fragment shading performance in Msamples/s
|
|
* for each.
|
|
*
|
|
* This program uses GLFW for convenience, to handle the OS-specific
|
|
* window management stuff. Some Windows-specific stuff for extension
|
|
* loading is still here, but that code is short-circuited on other
|
|
* platforms - this file compiles unedited on Windows, Linux and MacOS X,
|
|
* provided you have the relevant libraries and header files installed
|
|
* and set up your compilation to include the GLFW and OpenGL libraries.
|
|
*
|
|
* Author: Stefan Gustavson (stegu@itn.liu.se) 2004, 2005, 2010, 2011
|
|
* This code is in the public domain.
|
|
*/
|
|
|
|
// Identify the exact version of noise being benchmarked
|
|
#define NOISEVERSION "2011-04-03"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <math.h>
|
|
#include <GL/glfw.h>
|
|
|
|
#ifdef __WIN32__
|
|
// The system level include file for GL extensions might not be up to date.
|
|
#include "GL/glext.h"
|
|
#else
|
|
#include <GL/glext.h>
|
|
#endif
|
|
|
|
|
|
#ifdef __APPLE__
|
|
// MacOS application bundles have the executable inside a directory structure
|
|
#define VERTSHADERFILE "../../../noisebench.vert"
|
|
#define FRAGSHADERFILE_S2D "../../../simplexnoise2D.frag"
|
|
#define FRAGSHADERFILE_S3D "../../../simplexnoise3D.frag"
|
|
#define FRAGSHADERFILE_S4D "../../../simplexnoise4D.frag"
|
|
#define FRAGSHADERFILE_C2D "../../../classicnoise2D.frag"
|
|
#define FRAGSHADERFILE_C3D "../../../classicnoise3D.frag"
|
|
#define FRAGSHADERFILE_C4D "../../../classicnoise4D.frag"
|
|
#define FRAGSHADERFILE_CONST "../../../constant.frag"
|
|
#define LOGFILENAME "../../../ashimanoise.log"
|
|
#else
|
|
// Windows, Linux and other Unix systems expose executables as naked files
|
|
#define VERTSHADERFILE "noisebench.vert"
|
|
#define FRAGSHADERFILE_S2D "simplexnoise2D.frag"
|
|
#define FRAGSHADERFILE_S3D "simplexnoise3D.frag"
|
|
#define FRAGSHADERFILE_S4D "simplexnoise4D.frag"
|
|
#define FRAGSHADERFILE_C2D "classicnoise2D.frag"
|
|
#define FRAGSHADERFILE_C3D "classicnoise3D.frag"
|
|
#define FRAGSHADERFILE_C4D "classicnoise4D.frag"
|
|
#define FRAGSHADERFILE_CONST "constant.frag"
|
|
#define LOGFILENAME "ashimanoise.log"
|
|
#endif
|
|
|
|
#ifdef __WIN32__
|
|
/* Global function pointers for everything we need beyond OpenGL 1.1 */
|
|
PFNGLCREATEPROGRAMPROC glCreateProgram = NULL;
|
|
PFNGLDELETEPROGRAMPROC glDeleteProgram = NULL;
|
|
PFNGLUSEPROGRAMPROC glUseProgram = NULL;
|
|
PFNGLCREATESHADERPROC glCreateShader = NULL;
|
|
PFNGLDELETESHADERPROC glDeleteShader = NULL;
|
|
PFNGLSHADERSOURCEPROC glShaderSource = NULL;
|
|
PFNGLCOMPILESHADERPROC glCompileShader = NULL;
|
|
PFNGLGETSHADERIVPROC glGetShaderiv = NULL;
|
|
PFNGLGETPROGRAMIVPROC glGetProgramiv = NULL;
|
|
PFNGLATTACHSHADERPROC glAttachShader = NULL;
|
|
PFNGLGETSHADERINFOLOGPROC glGetShaderInfoLog = NULL;
|
|
PFNGLGETPROGRAMINFOLOGPROC glGetProgramInfoLog = NULL;
|
|
PFNGLLINKPROGRAMPROC glLinkProgram = NULL;
|
|
PFNGLGETUNIFORMLOCATIONPROC glGetUniformLocation = NULL;
|
|
PFNGLUNIFORM1FVPROC glUniform1fv = NULL;
|
|
#endif
|
|
|
|
/*
|
|
* printError() - Signal an error.
|
|
* Simple printf() to console for portability.
|
|
*/
|
|
void printError(const char *errtype, const char *errmsg) {
|
|
fprintf(stderr, "%s: %s\n", errtype, errmsg);
|
|
}
|
|
|
|
|
|
/*
|
|
* Override the Win32 filelength() function with
|
|
* a version that takes a Unix-style file handle as
|
|
* input instead of a file ID number, and which works
|
|
* on platforms other than Windows.
|
|
*/
|
|
long filelength(FILE *file) {
|
|
long numbytes;
|
|
long savedpos = ftell(file);
|
|
fseek(file, 0, SEEK_END);
|
|
numbytes = ftell(file);
|
|
fseek(file, savedpos, SEEK_SET);
|
|
return numbytes;
|
|
}
|
|
|
|
|
|
/*
|
|
* loadExtensions() - Load OpenGL extensions for anything above OpenGL
|
|
* version 1.1. (This is a requirement only on Windows, so on other
|
|
* platforms, this function just checks for the required extensions.)
|
|
*/
|
|
void loadExtensions() {
|
|
//These extension strings indicate that the OpenGL Shading Language
|
|
// and GLSL shader objects are supported.
|
|
if(!glfwExtensionSupported("GL_ARB_shading_language_100"))
|
|
{
|
|
printError("GL init error", "GL_ARB_shading_language_100 extension was not found");
|
|
return;
|
|
}
|
|
if(!glfwExtensionSupported("GL_ARB_shader_objects"))
|
|
{
|
|
printError("GL init error", "GL_ARB_shader_objects extension was not found");
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
#ifdef __WIN32__
|
|
glCreateProgram = (PFNGLCREATEPROGRAMPROC)glfwGetProcAddress("glCreateProgram");
|
|
glDeleteProgram = (PFNGLDELETEPROGRAMPROC)glfwGetProcAddress("glDeleteProgram");
|
|
glUseProgram = (PFNGLUSEPROGRAMPROC)glfwGetProcAddress("glUseProgram");
|
|
glCreateShader = (PFNGLCREATESHADERPROC)glfwGetProcAddress("glCreateShader");
|
|
glDeleteShader = (PFNGLDELETESHADERPROC)glfwGetProcAddress("glDeleteShader");
|
|
glShaderSource = (PFNGLSHADERSOURCEPROC)glfwGetProcAddress("glShaderSource");
|
|
glCompileShader = (PFNGLCOMPILESHADERPROC)glfwGetProcAddress("glCompileShader");
|
|
glGetShaderiv = (PFNGLGETSHADERIVPROC)glfwGetProcAddress("glGetShaderiv");
|
|
glGetShaderInfoLog = (PFNGLGETSHADERINFOLOGPROC)glfwGetProcAddress("glGetShaderInfoLog");
|
|
glAttachShader = (PFNGLATTACHSHADERPROC)glfwGetProcAddress("glAttachShader");
|
|
glLinkProgram = (PFNGLLINKPROGRAMPROC)glfwGetProcAddress("glLinkProgram");
|
|
glGetProgramiv = (PFNGLGETPROGRAMIVPROC)glfwGetProcAddress("glGetProgramiv");
|
|
glGetProgramInfoLog = (PFNGLGETPROGRAMINFOLOGPROC)glfwGetProcAddress("glGetProgramInfoLog");
|
|
glGetUniformLocation = (PFNGLGETUNIFORMLOCATIONPROC)glfwGetProcAddress("glGetUniformLocation");
|
|
glUniform1fv = (PFNGLUNIFORM1FVPROC)glfwGetProcAddress("glUniform1fv");
|
|
|
|
if( !glCreateProgram || !glDeleteProgram || !glUseProgram ||
|
|
!glCreateShader || !glDeleteShader || !glShaderSource || !glCompileShader ||
|
|
!glGetShaderiv || !glGetShaderInfoLog || !glAttachShader || !glLinkProgram ||
|
|
!glGetProgramiv || !glGetProgramInfoLog || !glGetUniformLocation ||
|
|
!glUniform1fv )
|
|
{
|
|
printError("GL init error", "One or more required OpenGL functions were not found");
|
|
return;
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* readShaderFile(filename) - read a shader source string from a file
|
|
*/
|
|
unsigned char* readShaderFile(const char *filename) {
|
|
FILE *file = fopen(filename, "r");
|
|
if(file == NULL)
|
|
{
|
|
printError("ERROR", "Cannot open shader file!");
|
|
return 0;
|
|
}
|
|
int bytesinfile = filelength(file);
|
|
unsigned char *buffer = (unsigned char*)malloc(bytesinfile+1);
|
|
int bytesread = fread( buffer, 1, bytesinfile, file);
|
|
buffer[bytesread] = 0; // Terminate the string with 0
|
|
fclose(file);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
|
|
/*
|
|
* createShaders() - create, load, compile and link the GLSL shader objects.
|
|
*/
|
|
void createShader(GLuint *programObject, char *vertexshaderfile, char *fragmentshaderfile) {
|
|
GLuint vertexShader;
|
|
GLuint fragmentShader;
|
|
|
|
const char *vertexShaderStrings[1];
|
|
const char *fragmentShaderStrings[1];
|
|
GLint vertexCompiled;
|
|
GLint fragmentCompiled;
|
|
GLint shadersLinked;
|
|
char str[4096]; // For error messages from the GLSL compiler and linker
|
|
|
|
// Create the vertex shader.
|
|
vertexShader = glCreateShader(GL_VERTEX_SHADER);
|
|
|
|
unsigned char *vertexShaderAssembly = readShaderFile( vertexshaderfile );
|
|
vertexShaderStrings[0] = (char*)vertexShaderAssembly;
|
|
glShaderSource( vertexShader, 1, vertexShaderStrings, NULL );
|
|
glCompileShader( vertexShader);
|
|
free((void *)vertexShaderAssembly);
|
|
|
|
glGetShaderiv( vertexShader, GL_COMPILE_STATUS,
|
|
&vertexCompiled );
|
|
if(vertexCompiled == GL_FALSE)
|
|
{
|
|
glGetShaderInfoLog(vertexShader, sizeof(str), NULL, str);
|
|
printError("Vertex shader compile error", str);
|
|
}
|
|
|
|
// Create the fragment shader.
|
|
fragmentShader = glCreateShader( GL_FRAGMENT_SHADER );
|
|
|
|
unsigned char *fragmentShaderAssembly = readShaderFile( fragmentshaderfile );
|
|
fragmentShaderStrings[0] = (char*)fragmentShaderAssembly;
|
|
glShaderSource( fragmentShader, 1, fragmentShaderStrings, NULL );
|
|
glCompileShader( fragmentShader );
|
|
free((void *)fragmentShaderAssembly);
|
|
|
|
glGetProgramiv( fragmentShader, GL_COMPILE_STATUS,
|
|
&fragmentCompiled );
|
|
if(fragmentCompiled == GL_FALSE)
|
|
{
|
|
glGetShaderInfoLog( fragmentShader, sizeof(str), NULL, str );
|
|
printError("Fragment shader compile error", str);
|
|
}
|
|
|
|
// Create a program object and attach the two compiled shaders.
|
|
*programObject = glCreateProgram();
|
|
glAttachShader( *programObject, vertexShader );
|
|
glAttachShader( *programObject, fragmentShader );
|
|
|
|
// Link the program object and print out the info log.
|
|
glLinkProgram( *programObject );
|
|
glGetProgramiv( *programObject, GL_LINK_STATUS, &shadersLinked );
|
|
|
|
if( shadersLinked == GL_FALSE )
|
|
{
|
|
glGetProgramInfoLog( *programObject, sizeof(str), NULL, str );
|
|
printError("Program object linking error", str);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* computeFPS() - Calculate, display and return samples per second.
|
|
* Stats are recomputed only once per second.
|
|
*/
|
|
double computeFPS() {
|
|
|
|
static double t0 = 0.0;
|
|
static int frames = 0;
|
|
static double Msamplespersecond = 0.0;
|
|
static char titlestring[200];
|
|
|
|
double t, fps;
|
|
int width, height;
|
|
|
|
// Get current time
|
|
t = glfwGetTime(); // Gets number of seconds since glfwInit()
|
|
// If one second has passed, or if this is the very first frame
|
|
if( (t-t0) > 1.0 || frames == 0 )
|
|
{
|
|
fps = (double)frames / (t-t0);
|
|
glfwGetWindowSize( &width, &height );
|
|
// This assumes that multisampling for FSAA is disabled.
|
|
Msamplespersecond = 1e-6*fps*width*height;
|
|
sprintf(titlestring, "GLSL simplex noise (%.1f M samples/s)", Msamplespersecond);
|
|
glfwSetWindowTitle(titlestring);
|
|
printf("Speed: %.1f M samples/s\n", Msamplespersecond);
|
|
t0 = t;
|
|
frames = 0;
|
|
}
|
|
frames ++;
|
|
return Msamplespersecond;
|
|
}
|
|
|
|
|
|
/*
|
|
* setupCamera() - set up the OpenGL projection and (model)view matrices
|
|
*/
|
|
void setupCamera() {
|
|
|
|
int width, height;
|
|
|
|
// Get window size. It may start out different from the requested
|
|
// size, and will change if the user resizes the window.
|
|
glfwGetWindowSize( &width, &height );
|
|
if(height<=0) height=1; // Safeguard against iconified/closed window
|
|
|
|
// Set viewport. This is the pixel rectangle we want to draw into.
|
|
glViewport( 0, 0, width, height ); // The entire window
|
|
|
|
// Select and setup the projection matrix.
|
|
glMatrixMode(GL_PROJECTION); // "We want to edit the projection matrix"
|
|
glLoadIdentity(); // Reset the matrix to identity
|
|
// 45 degrees FOV, same aspect ratio as viewport, depth range 1 to 100
|
|
glOrtho( -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f );
|
|
|
|
// Select and setup the modelview matrix.
|
|
glMatrixMode( GL_MODELVIEW ); // "We want to edit the modelview matrix"
|
|
glLoadIdentity(); // Reset the matrix to identity
|
|
}
|
|
|
|
|
|
/*
|
|
* initDisplayList(GLuint *listID, GLdouble scale) - create a display list
|
|
* to render the demo geometry more efficently than by glVertex() calls.
|
|
* (This is currently just as fast as a VBO, and I'm a bit lazy.)
|
|
*/
|
|
void initDisplayList(GLuint *listID)
|
|
{
|
|
*listID = glGenLists(1);
|
|
|
|
glNewList(*listID, GL_COMPILE);
|
|
glColor3f(1.0f, 1.0f, 1.0f); // White base color
|
|
glBegin(GL_TRIANGLE_STRIP);
|
|
glTexCoord2f(0.0f, 0.0f);
|
|
glVertex3f(-1.0f, -1.0f, 0.0f);
|
|
glTexCoord2f(1.0f, 0.0f);
|
|
glVertex3f(1.0f, -1.0f, 0.0f);
|
|
glTexCoord2f(0.0f, 1.0f);
|
|
glVertex3f(-1.0f, 1.0f, 0.0f);
|
|
glTexCoord2f(1.0f, 1.0f);
|
|
glVertex3f(1.0f, 1.0f, 0.0f);
|
|
glEnd();
|
|
glEndList();
|
|
}
|
|
|
|
|
|
/*
|
|
* renderScene() - draw the scene with the shader active
|
|
*/
|
|
void renderScene( GLuint listID, GLuint programObject )
|
|
{
|
|
GLint location_time = -1;
|
|
float time = 0.0f;
|
|
|
|
// Use vertex and fragment shaders.
|
|
glUseProgram( programObject );
|
|
// Update the uniform time variable.
|
|
location_time = glGetUniformLocation( programObject, "time" );
|
|
// glUniform1f() is bugged in Linux Nvidia driver 260.19.06,
|
|
// so we use glUniform1fv() instead to work around the bug.
|
|
if ( location_time != -1 ) {
|
|
time = (float)glfwGetTime();
|
|
glUniform1fv( location_time, 1, &time );
|
|
}
|
|
// Render with the shaders active.
|
|
glCallList( listID );
|
|
// Deactivate the shaders.
|
|
glUseProgram(0);
|
|
}
|
|
|
|
|
|
/*
|
|
* main(argc, argv) - the standard C entry point for the program
|
|
*/
|
|
int main(int argc, char *argv[]) {
|
|
|
|
GLuint displayList;
|
|
GLuint programObject;
|
|
double performance = 0.0;
|
|
int activeshader = 0; // Currently active version of noise shader
|
|
FILE *logfile;
|
|
GLFWvidmode vidmode;
|
|
|
|
GLboolean running = GL_TRUE; // Main loop exits when this is set to GL_FALSE
|
|
|
|
// Initialise GLFW
|
|
glfwInit();
|
|
|
|
// Open a temporary OpenGL window just to determine the desktop size
|
|
if( !glfwOpenWindow(256, 256, 8,8,8,8, 32,0, GLFW_WINDOW) )
|
|
{
|
|
glfwTerminate(); // glfwOpenWindow failed, quit the program.
|
|
return 1;
|
|
}
|
|
glfwGetDesktopMode(&vidmode);
|
|
glfwCloseWindow();
|
|
|
|
// Open a fullscreen window using the current desktop resolution
|
|
if( !glfwOpenWindow(vidmode.Width, vidmode.Height, 8,8,8,8, 32,0, GLFW_FULLSCREEN) )
|
|
{
|
|
glfwTerminate(); // glfwOpenWindow failed, quit the program.
|
|
return 1;
|
|
}
|
|
|
|
// Load the extensions for GLSL - note that this has to be done
|
|
// *after* the window has been opened, or we won't have a GL context
|
|
// to query for those extensions and connect to instances of them.
|
|
loadExtensions();
|
|
|
|
logfile = fopen(LOGFILENAME, "w");
|
|
|
|
fprintf(logfile, "GL vendor: %s\n", glGetString(GL_VENDOR));
|
|
fprintf(logfile, "GL renderer: %s\n", glGetString(GL_RENDERER));
|
|
fprintf(logfile, "GL version: %s\n", glGetString(GL_VERSION));
|
|
fprintf(logfile, "Desktop size: %d x %d pixels\n", vidmode.Width, vidmode.Height);
|
|
fprintf(logfile, "Noise version: %s\n\n", NOISEVERSION);
|
|
|
|
// Disable Z buffering for this simple 2D shader benchmark
|
|
glDisable(GL_DEPTH_TEST); // Use the Z buffer
|
|
|
|
glfwSwapInterval(0); // Do not wait for screen refresh between frames
|
|
|
|
// Compile a display list for the demo geometry, to render it efficiently
|
|
initDisplayList(&displayList);
|
|
|
|
// Main loop
|
|
while(running)
|
|
{
|
|
double benchmarktime = 3.0; // Total time to run each shader
|
|
// Switch between the different versions of noise
|
|
if(activeshader == 0) {
|
|
createShader(&programObject, VERTSHADERFILE, FRAGSHADERFILE_CONST);
|
|
activeshader++;
|
|
fprintf(logfile, "Constant shading, ");
|
|
}
|
|
if((activeshader == 1) && (glfwGetTime() > benchmarktime * activeshader)) {
|
|
fprintf(logfile, "%.1f Msamples/s\n", performance);
|
|
createShader(&programObject, VERTSHADERFILE, FRAGSHADERFILE_S2D);
|
|
activeshader++;
|
|
fprintf(logfile, "2D simplex noise, ");
|
|
}
|
|
if((activeshader == 2) && (glfwGetTime() > benchmarktime * activeshader)) {
|
|
fprintf(logfile, "%.1f Msamples/s\n", performance);
|
|
createShader(&programObject, VERTSHADERFILE, FRAGSHADERFILE_S3D);
|
|
activeshader++;
|
|
fprintf(logfile, "3D simplex noise, ");
|
|
}
|
|
if((activeshader == 3) && (glfwGetTime() > benchmarktime * activeshader)) {
|
|
fprintf(logfile, "%.1f Msamples/s\n", performance);
|
|
createShader(&programObject, VERTSHADERFILE, FRAGSHADERFILE_S4D);
|
|
activeshader++;
|
|
fprintf(logfile, "4D simplex noise, ");
|
|
}
|
|
if((activeshader == 4) && (glfwGetTime() > benchmarktime * activeshader)) {
|
|
fprintf(logfile, "%.1f Msamples/s\n", performance);
|
|
createShader(&programObject, VERTSHADERFILE, FRAGSHADERFILE_C2D);
|
|
activeshader++;
|
|
fprintf(logfile, "2D classic noise, ");
|
|
}
|
|
if((activeshader == 5) && (glfwGetTime() > benchmarktime * activeshader)) {
|
|
fprintf(logfile, "%.1f Msamples/s\n", performance);
|
|
createShader(&programObject, VERTSHADERFILE, FRAGSHADERFILE_C3D);
|
|
activeshader++;
|
|
fprintf(logfile, "3D classic noise, ");
|
|
}
|
|
if((activeshader == 6) && (glfwGetTime() > benchmarktime * activeshader)) {
|
|
fprintf(logfile, "%.1f Msamples/s\n", performance);
|
|
createShader(&programObject, VERTSHADERFILE, FRAGSHADERFILE_C4D);
|
|
activeshader++;
|
|
fprintf(logfile, "4D classic noise, ");
|
|
}
|
|
if((activeshader == 7) && (glfwGetTime() > benchmarktime * activeshader)) {
|
|
fprintf(logfile, "%.1f Msamples/s\n", performance);
|
|
running = GL_FALSE;
|
|
}
|
|
|
|
// Exit prematurely if the ESC key is pressed or the window is closed.
|
|
if(glfwGetKey(GLFW_KEY_ESC) || !glfwGetWindowParam(GLFW_OPENED)) {
|
|
running = GL_FALSE;
|
|
}
|
|
|
|
// Calculate and update the frames per second (FPS) display
|
|
performance = computeFPS();
|
|
|
|
// Do not clear the buffers - this is a raw shader benchmark.
|
|
//glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
|
|
|
// Set up the camera projection.
|
|
setupCamera();
|
|
|
|
// Draw the scene.
|
|
renderScene(displayList, programObject);
|
|
|
|
// Swap buffers, i.e. display the image and prepare for next frame.
|
|
glfwSwapBuffers();
|
|
}
|
|
|
|
// Close the OpenGL window and terminate GLFW.
|
|
glfwTerminate();
|
|
|
|
fclose(logfile);
|
|
|
|
return 0;
|
|
}
|