Shader Demo: Support both GL 3 and 4

1 files changed, 426 insertions, 0 deletions

diff --git a/examples/pugl_shader_demo.c b/examples/pugl_shader_demo.c
new file mode 100644
index 0000000..ac5fe84
--- /dev/null
+++ b/examples/pugl_shader_demo.c
@@ -0,0 +1,426 @@
+/*
+  Copyright 2012-2020 David Robillard <http://drobilla.net>
+
+  Permission to use, copy, modify, and/or distribute this software for any
+  purpose with or without fee is hereby granted, provided that the above
+  copyright notice and this permission notice appear in all copies.
+
+  THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+*/
+
+/**
+   @file pugl_shader_demo.c An example of drawing with OpenGL 3/4.
+
+   This is an example of using OpenGL for pixel-perfect 2D drawing.  It uses
+   pixel coordinates for positions and sizes so that things work roughly like a
+   typical 2D graphics API.
+
+   The program draws a bunch of rectangles with borders, using instancing.
+   Each rectangle has origin, size, and fill color attributes, which are shared
+   for all four vertices.  On each frame, a single buffer with all the
+   rectangle data is sent to the GPU, and everything is drawn with a single
+   draw call.
+
+   This is not particularly realistic or optimal, but serves as a decent rough
+   benchmark for how much simple geometry you can draw.  The number of
+   rectangles can be given on the command line.  For reference, it begins to
+   struggle to maintain 60 FPS on my machine (1950x + Vega64) with more than
+   about 100000 rectangles.
+*/
+
+#include "demo_utils.h"
+#include "rects.h"
+#include "shader_utils.h"
+#include "test/test_utils.h"
+
+#include "glad/glad.h"
+
+#include "pugl/gl.h"
+#include "pugl/pugl.h"
+#include "pugl/pugl_gl.h"
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+static const int defaultWidth  = 512;
+static const int defaultHeight = 512;
+
+typedef struct
+{
+	mat4 projection;
+} RectUniforms;
+
+typedef struct
+{
+	PuglTestOptions opts;
+	PuglWorld*      world;
+	PuglView*       view;
+	size_t          numRects;
+	Rect*           rects;
+	Program         drawRect;
+	GLuint          vao;
+	GLuint          vbo;
+	GLuint          instanceVbo;
+	GLuint          ibo;
+	unsigned        framesDrawn;
+	int             glMajorVersion;
+	int             glMinorVersion;
+	int             quit;
+} PuglTestApp;
+
+static PuglStatus
+setupGl(PuglTestApp* app);
+
+static void
+teardownGl(PuglTestApp* app);
+
+static void
+onConfigure(PuglView* view, double width, double height)
+{
+	(void)view;
+
+	glEnable(GL_BLEND);
+	glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ZERO);
+	glBlendEquationSeparate(GL_FUNC_ADD, GL_FUNC_ADD);
+	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
+	glViewport(0, 0, (int)width, (int)height);
+}
+
+static void
+onExpose(PuglView* view)
+{
+	PuglTestApp*   app    = (PuglTestApp*)puglGetHandle(view);
+	const PuglRect frame  = puglGetFrame(view);
+	const float    width  = (float)frame.width;
+	const float    height = (float)frame.height;
+	const double   time   = puglGetTime(puglGetWorld(view));
+
+	// Construct projection matrix for 2D window surface (in pixels)
+	mat4 proj;
+	mat4Ortho(proj,
+	          0.0f,
+	          (float)frame.width,
+	          0.0f,
+	          (float)frame.height,
+	          -1.0f,
+	          1.0f);
+
+	// Clear and bind everything that is the same for every rect
+	glClear(GL_COLOR_BUFFER_BIT);
+	glUseProgram(app->drawRect.program);
+	glBindVertexArray(app->vao);
+
+	for (size_t i = 0; i < app->numRects; ++i) {
+		moveRect(&app->rects[i], i, app->numRects, width, height, time);
+	}
+
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(proj), &proj, GL_STREAM_DRAW);
+
+	glBufferSubData(GL_ARRAY_BUFFER,
+	                0,
+	                (GLsizeiptr)(app->numRects * sizeof(Rect)),
+	                app->rects);
+
+	glDrawElementsInstanced(GL_TRIANGLE_STRIP,
+	                        4,
+	                        GL_UNSIGNED_INT,
+	                        NULL,
+	                        (GLsizei)(app->numRects * 4));
+
+	++app->framesDrawn;
+}
+
+static PuglStatus
+onEvent(PuglView* view, const PuglEvent* event)
+{
+	PuglTestApp* app = (PuglTestApp*)puglGetHandle(view);
+
+	printEvent(event, "Event: ", app->opts.verbose);
+
+	switch (event->type) {
+	case PUGL_CREATE:
+		setupGl(app);
+		break;
+	case PUGL_DESTROY:
+		teardownGl(app);
+		break;
+	case PUGL_CONFIGURE:
+		onConfigure(view, event->configure.width, event->configure.height);
+		break;
+	case PUGL_UPDATE:
+		puglPostRedisplay(view);
+		break;
+	case PUGL_EXPOSE: onExpose(view); break;
+	case PUGL_CLOSE: app->quit = 1; break;
+	case PUGL_KEY_PRESS:
+		if (event->key.key == 'q' || event->key.key == PUGL_KEY_ESCAPE) {
+			app->quit = 1;
+		}
+		break;
+	default: break;
+	}
+
+	return PUGL_SUCCESS;
+}
+
+static Rect*
+makeRects(const size_t numRects)
+{
+	Rect* rects = (Rect*)calloc(numRects, sizeof(Rect));
+	for (size_t i = 0; i < numRects; ++i) {
+		rects[i] = makeRect(i, (float)defaultWidth);
+	}
+
+	return rects;
+}
+
+static char*
+loadShader(const char* const path)
+{
+	FILE* const file = fopen(path, "r");
+	if (!file) {
+		logError("Failed to open '%s'\n", path);
+		return NULL;
+	}
+
+	fseek(file, 0, SEEK_END);
+	const size_t fileSize = (size_t)ftell(file);
+
+	fseek(file, 0, SEEK_SET);
+	char* source = (char*)calloc(1, fileSize + 1u);
+
+	fread(source, 1, fileSize, file);
+	fclose(file);
+
+	return source;
+}
+
+static int
+parseOptions(PuglTestApp* app, int argc, char** argv)
+{
+	char* endptr = NULL;
+
+	// Parse command line options
+	app->numRects = 1024;
+	app->opts     = puglParseTestOptions(&argc, &argv);
+	if (app->opts.help) {
+		return 1;
+	}
+
+	// Parse number of rectangles argument, if given
+	if (argc >= 1) {
+		app->numRects = (size_t)strtol(argv[0], &endptr, 10);
+		if (endptr != argv[0] + strlen(argv[0])) {
+			logError("Invalid number of rectangles: %s\n", argv[0]);
+			return 1;
+		}
+	}
+
+	// Parse OpenGL major version argument, if given
+	if (argc >= 2) {
+		app->glMajorVersion = (int)strtol(argv[1], &endptr, 10);
+		if (endptr != argv[1] + strlen(argv[1])) {
+			logError("Invalid GL major version: %s\n", argv[1]);
+			return 1;
+		} else if (app->glMajorVersion == 4) {
+			app->glMinorVersion = 2;
+		} else if (app->glMajorVersion != 3) {
+			logError("Unsupported GL major version %d\n", app->glMajorVersion);
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static void
+setupPugl(PuglTestApp* app, const PuglRect frame)
+{
+	// Create world, view, and rect data
+	app->world = puglNewWorld(PUGL_PROGRAM, 0);
+	app->view  = puglNewView(app->world);
+	app->rects = makeRects(app->numRects);
+
+	// Set up world and view
+	puglSetClassName(app->world, "PuglGL3Demo");
+	puglSetWindowTitle(app->view, "Pugl OpenGL 3");
+	puglSetFrame(app->view, frame);
+	puglSetMinSize(app->view, defaultWidth / 4, defaultHeight / 4);
+	puglSetAspectRatio(app->view, 1, 1, 16, 9);
+	puglSetBackend(app->view, puglGlBackend());
+	puglSetViewHint(app->view, PUGL_USE_COMPAT_PROFILE, PUGL_FALSE);
+	puglSetViewHint(app->view, PUGL_USE_DEBUG_CONTEXT, app->opts.errorChecking);
+	puglSetViewHint(app->view, PUGL_CONTEXT_VERSION_MAJOR, app->glMajorVersion);
+	puglSetViewHint(app->view, PUGL_CONTEXT_VERSION_MINOR, app->glMinorVersion);
+	puglSetViewHint(app->view, PUGL_RESIZABLE, app->opts.resizable);
+	puglSetViewHint(app->view, PUGL_SAMPLES, app->opts.samples);
+	puglSetViewHint(app->view, PUGL_DOUBLE_BUFFER, app->opts.doubleBuffer);
+	puglSetViewHint(app->view, PUGL_SWAP_INTERVAL, app->opts.sync);
+	puglSetViewHint(app->view, PUGL_IGNORE_KEY_REPEAT, PUGL_TRUE);
+	puglSetHandle(app->view, app);
+	puglSetEventFunc(app->view, onEvent);
+}
+
+static PuglStatus
+setupGl(PuglTestApp* app)
+{
+	// Load GL functions via GLAD
+	if (!gladLoadGLLoader((GLADloadproc)&puglGetProcAddress)) {
+		logError("Failed to load GL\n");
+		return PUGL_FAILURE;
+	}
+
+	const char* const headerFile = (app->glMajorVersion == 3
+	                                ? "shaders/header_330.glsl"
+	                                : "shaders/header_420.glsl");
+
+	// Load shader sources
+	char* const headerSource   = loadShader(headerFile);
+	char* const vertexSource   = loadShader("shaders/rect.vert");
+	char* const fragmentSource = loadShader("shaders/rect.frag");
+	if (!vertexSource || !fragmentSource) {
+		logError("Failed to load shader sources\n");
+		return PUGL_FAILURE;
+	}
+
+	// Compile rectangle shaders and program
+	app->drawRect = compileProgram(headerSource, vertexSource, fragmentSource);
+	free(fragmentSource);
+	free(vertexSource);
+	free(headerSource);
+	if (!app->drawRect.program) {
+		return PUGL_FAILURE;
+	}
+
+	// Get location of rectangle shader uniform block
+	const GLuint globalsIndex = glGetUniformBlockIndex(app->drawRect.program,
+	                                                   "UniformBufferObject");
+
+	// Generate/bind a uniform buffer for setting rectangle properties
+	GLuint uboHandle;
+	glGenBuffers(1, &uboHandle);
+	glBindBuffer(GL_UNIFORM_BUFFER, uboHandle);
+	glBindBufferBase(GL_UNIFORM_BUFFER, globalsIndex, uboHandle);
+
+	// Generate/bind a VAO to track state
+	glGenVertexArrays(1, &app->vao);
+	glBindVertexArray(app->vao);
+
+	// Generate/bind a VBO to store vertex position data
+	glGenBuffers(1, &app->vbo);
+	glBindBuffer(GL_ARRAY_BUFFER, app->vbo);
+	glBufferData(GL_ARRAY_BUFFER,
+	             sizeof(rectVertices),
+	             rectVertices,
+	             GL_STATIC_DRAW);
+
+	// Attribute 0 is position, 2 floats from the VBO
+	glEnableVertexAttribArray(0);
+	glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), NULL);
+
+	// Generate/bind a VBO to store instance attribute data
+	glGenBuffers(1, &app->instanceVbo);
+	glBindBuffer(GL_ARRAY_BUFFER, app->instanceVbo);
+	glBufferData(GL_ARRAY_BUFFER,
+	             (GLsizeiptr)(app->numRects * sizeof(Rect)),
+	             app->rects,
+	             GL_STREAM_DRAW);
+
+	// Attribute 1 is Rect::position
+	glEnableVertexAttribArray(1);
+	glVertexAttribDivisor(1, 4);
+	glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(Rect), NULL);
+
+	// Attribute 2 is Rect::size
+	glEnableVertexAttribArray(2);
+	glVertexAttribDivisor(2, 4);
+	glVertexAttribPointer(2,
+	                      2,
+	                      GL_FLOAT,
+	                      GL_FALSE,
+	                      sizeof(Rect),
+	                      (const void*)offsetof(Rect, size));
+
+	// Attribute 3 is Rect::fillColor
+	glEnableVertexAttribArray(3);
+	glVertexAttribDivisor(3, 4);
+	glVertexAttribPointer(3,
+	                      4,
+	                      GL_FLOAT,
+	                      GL_FALSE,
+	                      sizeof(Rect),
+	                      (const void*)offsetof(Rect, fillColor));
+
+	// Set up the IBO to index into the VBO
+	glGenBuffers(1, &app->ibo);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, app->ibo);
+	glBufferData(GL_ELEMENT_ARRAY_BUFFER,
+	             sizeof(rectIndices),
+	             rectIndices,
+	             GL_STATIC_DRAW);
+
+	return PUGL_SUCCESS;
+}
+
+static void
+teardownGl(PuglTestApp* app)
+{
+	glDeleteBuffers(1, &app->ibo);
+	glDeleteBuffers(1, &app->vbo);
+	glDeleteBuffers(1, &app->instanceVbo);
+	glDeleteVertexArrays(1, &app->vao);
+	deleteProgram(app->drawRect);
+}
+
+int
+main(int argc, char** argv)
+{
+	PuglTestApp app = {0};
+
+	app.glMajorVersion = 3;
+	app.glMinorVersion = 3;
+
+	const PuglRect frame = {0, 0, defaultWidth, defaultHeight};
+
+	// Parse command line options
+	if (parseOptions(&app, argc, argv)) {
+		puglPrintTestUsage("pugl_shader_demo", "[NUM_RECTS] [GL_MAJOR]");
+		return 1;
+	}
+
+	// Create and configure world and view
+	setupPugl(&app, frame);
+
+	// Create window (which will send a PUGL_CREATE event)
+	const PuglStatus st = puglRealize(app.view);
+	if (st) {
+		return logError("Failed to create window (%s)\n", puglStrerror(st));
+	}
+
+	// Show window
+	puglShowWindow(app.view);
+
+	// Grind away, drawing continuously
+	PuglFpsPrinter fpsPrinter = {puglGetTime(app.world)};
+	while (!app.quit) {
+		puglUpdate(app.world, 0.0);
+		puglPrintFps(app.world, &fpsPrinter, &app.framesDrawn);
+	}
+
+	// Destroy window (which will send a PUGL_DESTROY event)
+	puglFreeView(app.view);
+
+	// Free everything else
+	puglFreeWorld(app.world);
+	free(app.rects);
+
+	return 0;
+}