pixo 0.1.0

data/ext/pixo/ext/glfw/examples/simple.c

@@ -0,0 +1,163 @@
+//========================================================================
+// Simple GLFW example
+// Copyright (c) Camilla Berglund <elmindreda@glfw.org>
+//
+// This software is provided 'as-is', without any express or implied
+// warranty. In no event will the authors be held liable for any damages
+// arising from the use of this software.
+//
+// Permission is granted to anyone to use this software for any purpose,
+// including commercial applications, and to alter it and redistribute it
+// freely, subject to the following restrictions:
+//
+// 1. The origin of this software must not be misrepresented; you must not
+//    claim that you wrote the original software. If you use this software
+//    in a product, an acknowledgment in the product documentation would
+//    be appreciated but is not required.
+//
+// 2. Altered source versions must be plainly marked as such, and must not
+//    be misrepresented as being the original software.
+//
+// 3. This notice may not be removed or altered from any source
+//    distribution.
+//
+//========================================================================
+//! [code]
+
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+#include "linmath.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+
+static const struct
+{
+    float x, y;
+    float r, g, b;
+} vertices[3] =
+{
+    { -0.6f, -0.4f, 1.f, 0.f, 0.f },
+    {  0.6f, -0.4f, 0.f, 1.f, 0.f },
+    {   0.f,  0.6f, 0.f, 0.f, 1.f }
+};
+
+static const char* vertex_shader_text =
+"uniform mat4 MVP;\n"
+"attribute vec3 vCol;\n"
+"attribute vec2 vPos;\n"
+"varying vec3 color;\n"
+"void main()\n"
+"{\n"
+"    gl_Position = MVP * vec4(vPos, 0.0, 1.0);\n"
+"    color = vCol;\n"
+"}\n";
+
+static const char* fragment_shader_text =
+"varying vec3 color;\n"
+"void main()\n"
+"{\n"
+"    gl_FragColor = vec4(color, 1.0);\n"
+"}\n";
+
+static void error_callback(int error, const char* description)
+{
+    fprintf(stderr, "Error: %s\n", description);
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+}
+
+int main(void)
+{
+    GLFWwindow* window;
+    GLuint vertex_buffer, vertex_shader, fragment_shader, program;
+    GLint mvp_location, vpos_location, vcol_location;
+
+    glfwSetErrorCallback(error_callback);
+
+    if (!glfwInit())
+        exit(EXIT_FAILURE);
+
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
+    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
+
+    window = glfwCreateWindow(640, 480, "Simple example", NULL, NULL);
+    if (!window)
+    {
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    glfwSetKeyCallback(window, key_callback);
+
+    glfwMakeContextCurrent(window);
+    gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
+    glfwSwapInterval(1);
+
+    // NOTE: OpenGL error checks have been omitted for brevity
+
+    glGenBuffers(1, &vertex_buffer);
+    glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
+    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
+
+    vertex_shader = glCreateShader(GL_VERTEX_SHADER);
+    glShaderSource(vertex_shader, 1, &vertex_shader_text, NULL);
+    glCompileShader(vertex_shader);
+
+    fragment_shader = glCreateShader(GL_FRAGMENT_SHADER);
+    glShaderSource(fragment_shader, 1, &fragment_shader_text, NULL);
+    glCompileShader(fragment_shader);
+
+    program = glCreateProgram();
+    glAttachShader(program, vertex_shader);
+    glAttachShader(program, fragment_shader);
+    glLinkProgram(program);
+
+    mvp_location = glGetUniformLocation(program, "MVP");
+    vpos_location = glGetAttribLocation(program, "vPos");
+    vcol_location = glGetAttribLocation(program, "vCol");
+
+    glEnableVertexAttribArray(vpos_location);
+    glVertexAttribPointer(vpos_location, 2, GL_FLOAT, GL_FALSE,
+                          sizeof(float) * 5, (void*) 0);
+    glEnableVertexAttribArray(vcol_location);
+    glVertexAttribPointer(vcol_location, 3, GL_FLOAT, GL_FALSE,
+                          sizeof(float) * 5, (void*) (sizeof(float) * 2));
+
+    while (!glfwWindowShouldClose(window))
+    {
+        float ratio;
+        int width, height;
+        mat4x4 m, p, mvp;
+
+        glfwGetFramebufferSize(window, &width, &height);
+        ratio = width / (float) height;
+
+        glViewport(0, 0, width, height);
+        glClear(GL_COLOR_BUFFER_BIT);
+
+        mat4x4_identity(m);
+        mat4x4_rotate_Z(m, m, (float) glfwGetTime());
+        mat4x4_ortho(p, -ratio, ratio, -1.f, 1.f, 1.f, -1.f);
+        mat4x4_mul(mvp, p, m);
+
+        glUseProgram(program);
+        glUniformMatrix4fv(mvp_location, 1, GL_FALSE, (const GLfloat*) mvp);
+        glDrawArrays(GL_TRIANGLES, 0, 3);
+
+        glfwSwapBuffers(window);
+        glfwPollEvents();
+    }
+
+    glfwDestroyWindow(window);
+
+    glfwTerminate();
+    exit(EXIT_SUCCESS);
+}
+
+//! [code]

data/ext/pixo/ext/glfw/examples/splitview.c

@@ -0,0 +1,545 @@
+//========================================================================
+// This is an example program for the GLFW library
+//
+// The program uses a "split window" view, rendering four views of the
+// same scene in one window (e.g. uesful for 3D modelling software). This
+// demo uses scissors to separete the four different rendering areas from
+// each other.
+//
+// (If the code seems a little bit strange here and there, it may be
+//  because I am not a friend of orthogonal projections)
+//========================================================================
+
+#include <glad/glad.h>
+#include <GLFW/glfw3.h>
+
+#if defined(_MSC_VER)
+ // Make MS math.h define M_PI
+ #define _USE_MATH_DEFINES
+#endif
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <linmath.h>
+
+
+//========================================================================
+// Global variables
+//========================================================================
+
+// Mouse position
+static double xpos = 0, ypos = 0;
+
+// Window size
+static int width, height;
+
+// Active view: 0 = none, 1 = upper left, 2 = upper right, 3 = lower left,
+// 4 = lower right
+static int active_view = 0;
+
+// Rotation around each axis
+static int rot_x = 0, rot_y = 0, rot_z = 0;
+
+// Do redraw?
+static int do_redraw = 1;
+
+
+//========================================================================
+// Draw a solid torus (use a display list for the model)
+//========================================================================
+
+#define TORUS_MAJOR     1.5
+#define TORUS_MINOR     0.5
+#define TORUS_MAJOR_RES 32
+#define TORUS_MINOR_RES 32
+
+static void drawTorus(void)
+{
+    static GLuint torus_list = 0;
+    int    i, j, k;
+    double s, t, x, y, z, nx, ny, nz, scale, twopi;
+
+    if (!torus_list)
+    {
+        // Start recording displaylist
+        torus_list = glGenLists(1);
+        glNewList(torus_list, GL_COMPILE_AND_EXECUTE);
+
+        // Draw torus
+        twopi = 2.0 * M_PI;
+        for (i = 0;  i < TORUS_MINOR_RES;  i++)
+        {
+            glBegin(GL_QUAD_STRIP);
+            for (j = 0;  j <= TORUS_MAJOR_RES;  j++)
+            {
+                for (k = 1;  k >= 0;  k--)
+                {
+                    s = (i + k) % TORUS_MINOR_RES + 0.5;
+                    t = j % TORUS_MAJOR_RES;
+
+                    // Calculate point on surface
+                    x = (TORUS_MAJOR + TORUS_MINOR * cos(s * twopi / TORUS_MINOR_RES)) * cos(t * twopi / TORUS_MAJOR_RES);
+                    y = TORUS_MINOR * sin(s * twopi / TORUS_MINOR_RES);
+                    z = (TORUS_MAJOR + TORUS_MINOR * cos(s * twopi / TORUS_MINOR_RES)) * sin(t * twopi / TORUS_MAJOR_RES);
+
+                    // Calculate surface normal
+                    nx = x - TORUS_MAJOR * cos(t * twopi / TORUS_MAJOR_RES);
+                    ny = y;
+                    nz = z - TORUS_MAJOR * sin(t * twopi / TORUS_MAJOR_RES);
+                    scale = 1.0 / sqrt(nx*nx + ny*ny + nz*nz);
+                    nx *= scale;
+                    ny *= scale;
+                    nz *= scale;
+
+                    glNormal3f((float) nx, (float) ny, (float) nz);
+                    glVertex3f((float) x, (float) y, (float) z);
+                }
+            }
+
+            glEnd();
+        }
+
+        // Stop recording displaylist
+        glEndList();
+    }
+    else
+    {
+        // Playback displaylist
+        glCallList(torus_list);
+    }
+}
+
+
+//========================================================================
+// Draw the scene (a rotating torus)
+//========================================================================
+
+static void drawScene(void)
+{
+    const GLfloat model_diffuse[4]  = {1.0f, 0.8f, 0.8f, 1.0f};
+    const GLfloat model_specular[4] = {0.6f, 0.6f, 0.6f, 1.0f};
+    const GLfloat model_shininess   = 20.0f;
+
+    glPushMatrix();
+
+    // Rotate the object
+    glRotatef((GLfloat) rot_x * 0.5f, 1.0f, 0.0f, 0.0f);
+    glRotatef((GLfloat) rot_y * 0.5f, 0.0f, 1.0f, 0.0f);
+    glRotatef((GLfloat) rot_z * 0.5f, 0.0f, 0.0f, 1.0f);
+
+    // Set model color (used for orthogonal views, lighting disabled)
+    glColor4fv(model_diffuse);
+
+    // Set model material (used for perspective view, lighting enabled)
+    glMaterialfv(GL_FRONT, GL_DIFFUSE, model_diffuse);
+    glMaterialfv(GL_FRONT, GL_SPECULAR, model_specular);
+    glMaterialf(GL_FRONT, GL_SHININESS, model_shininess);
+
+    // Draw torus
+    drawTorus();
+
+    glPopMatrix();
+}
+
+
+//========================================================================
+// Draw a 2D grid (used for orthogonal views)
+//========================================================================
+
+static void drawGrid(float scale, int steps)
+{
+    int i;
+    float x, y;
+    mat4x4 view;
+
+    glPushMatrix();
+
+    // Set background to some dark bluish grey
+    glClearColor(0.05f, 0.05f, 0.2f, 0.0f);
+    glClear(GL_COLOR_BUFFER_BIT);
+
+    // Setup modelview matrix (flat XY view)
+    {
+        vec3 eye = { 0.f, 0.f, 1.f };
+        vec3 center = { 0.f, 0.f, 0.f };
+        vec3 up = { 0.f, 1.f, 0.f };
+        mat4x4_look_at(view, eye, center, up);
+    }
+    glLoadMatrixf((const GLfloat*) view);
+
+    // We don't want to update the Z-buffer
+    glDepthMask(GL_FALSE);
+
+    // Set grid color
+    glColor3f(0.0f, 0.5f, 0.5f);
+
+    glBegin(GL_LINES);
+
+    // Horizontal lines
+    x = scale * 0.5f * (float) (steps - 1);
+    y = -scale * 0.5f * (float) (steps - 1);
+    for (i = 0;  i < steps;  i++)
+    {
+        glVertex3f(-x, y, 0.0f);
+        glVertex3f(x, y, 0.0f);
+        y += scale;
+    }
+
+    // Vertical lines
+    x = -scale * 0.5f * (float) (steps - 1);
+    y = scale * 0.5f * (float) (steps - 1);
+    for (i = 0;  i < steps;  i++)
+    {
+        glVertex3f(x, -y, 0.0f);
+        glVertex3f(x, y, 0.0f);
+        x += scale;
+    }
+
+    glEnd();
+
+    // Enable Z-buffer writing again
+    glDepthMask(GL_TRUE);
+
+    glPopMatrix();
+}
+
+
+//========================================================================
+// Draw all views
+//========================================================================
+
+static void drawAllViews(void)
+{
+    const GLfloat light_position[4] = {0.0f, 8.0f, 8.0f, 1.0f};
+    const GLfloat light_diffuse[4]  = {1.0f, 1.0f, 1.0f, 1.0f};
+    const GLfloat light_specular[4] = {1.0f, 1.0f, 1.0f, 1.0f};
+    const GLfloat light_ambient[4]  = {0.2f, 0.2f, 0.3f, 1.0f};
+    float aspect;
+    mat4x4 view, projection;
+
+    // Calculate aspect of window
+    if (height > 0)
+        aspect = (float) width / (float) height;
+    else
+        aspect = 1.f;
+
+    // Clear screen
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    // Enable scissor test
+    glEnable(GL_SCISSOR_TEST);
+
+    // Enable depth test
+    glEnable(GL_DEPTH_TEST);
+    glDepthFunc(GL_LEQUAL);
+
+    // ** ORTHOGONAL VIEWS **
+
+    // For orthogonal views, use wireframe rendering
+    glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
+
+    // Enable line anti-aliasing
+    glEnable(GL_LINE_SMOOTH);
+    glEnable(GL_BLEND);
+    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    // Setup orthogonal projection matrix
+    glMatrixMode(GL_PROJECTION);
+    glLoadIdentity();
+    glOrtho(-3.0 * aspect, 3.0 * aspect, -3.0, 3.0, 1.0, 50.0);
+
+    // Upper left view (TOP VIEW)
+    glViewport(0, height / 2, width / 2, height / 2);
+    glScissor(0, height / 2, width / 2, height / 2);
+    glMatrixMode(GL_MODELVIEW);
+    {
+        vec3 eye = { 0.f, 10.f, 1e-3f };
+        vec3 center = { 0.f, 0.f, 0.f };
+        vec3 up = { 0.f, 1.f, 0.f };
+        mat4x4_look_at( view, eye, center, up );
+    }
+    glLoadMatrixf((const GLfloat*) view);
+    drawGrid(0.5, 12);
+    drawScene();
+
+    // Lower left view (FRONT VIEW)
+    glViewport(0, 0, width / 2, height / 2);
+    glScissor(0, 0, width / 2, height / 2);
+    glMatrixMode(GL_MODELVIEW);
+    {
+        vec3 eye = { 0.f, 0.f, 10.f };
+        vec3 center = { 0.f, 0.f, 0.f };
+        vec3 up = { 0.f, 1.f, 0.f };
+        mat4x4_look_at( view, eye, center, up );
+    }
+    glLoadMatrixf((const GLfloat*) view);
+    drawGrid(0.5, 12);
+    drawScene();
+
+    // Lower right view (SIDE VIEW)
+    glViewport(width / 2, 0, width / 2, height / 2);
+    glScissor(width / 2, 0, width / 2, height / 2);
+    glMatrixMode(GL_MODELVIEW);
+    {
+        vec3 eye = { 10.f, 0.f, 0.f };
+        vec3 center = { 0.f, 0.f, 0.f };
+        vec3 up = { 0.f, 1.f, 0.f };
+        mat4x4_look_at( view, eye, center, up );
+    }
+    glLoadMatrixf((const GLfloat*) view);
+    drawGrid(0.5, 12);
+    drawScene();
+
+    // Disable line anti-aliasing
+    glDisable(GL_LINE_SMOOTH);
+    glDisable(GL_BLEND);
+
+    // ** PERSPECTIVE VIEW **
+
+    // For perspective view, use solid rendering
+    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
+
+    // Enable face culling (faster rendering)
+    glEnable(GL_CULL_FACE);
+    glCullFace(GL_BACK);
+    glFrontFace(GL_CW);
+
+    // Setup perspective projection matrix
+    glMatrixMode(GL_PROJECTION);
+    mat4x4_perspective(projection,
+                       65.f * (float) M_PI / 180.f,
+                       aspect,
+                       1.f, 50.f);
+    glLoadMatrixf((const GLfloat*) projection);
+
+    // Upper right view (PERSPECTIVE VIEW)
+    glViewport(width / 2, height / 2, width / 2, height / 2);
+    glScissor(width / 2, height / 2, width / 2, height / 2);
+    glMatrixMode(GL_MODELVIEW);
+    {
+        vec3 eye = { 3.f, 1.5f, 3.f };
+        vec3 center = { 0.f, 0.f, 0.f };
+        vec3 up = { 0.f, 1.f, 0.f };
+        mat4x4_look_at( view, eye, center, up );
+    }
+    glLoadMatrixf((const GLfloat*) view);
+
+    // Configure and enable light source 1
+    glLightfv(GL_LIGHT1, GL_POSITION, light_position);
+    glLightfv(GL_LIGHT1, GL_AMBIENT, light_ambient);
+    glLightfv(GL_LIGHT1, GL_DIFFUSE, light_diffuse);
+    glLightfv(GL_LIGHT1, GL_SPECULAR, light_specular);
+    glEnable(GL_LIGHT1);
+    glEnable(GL_LIGHTING);
+
+    // Draw scene
+    drawScene();
+
+    // Disable lighting
+    glDisable(GL_LIGHTING);
+
+    // Disable face culling
+    glDisable(GL_CULL_FACE);
+
+    // Disable depth test
+    glDisable(GL_DEPTH_TEST);
+
+    // Disable scissor test
+    glDisable(GL_SCISSOR_TEST);
+
+    // Draw a border around the active view
+    if (active_view > 0 && active_view != 2)
+    {
+        glViewport(0, 0, width, height);
+
+        glMatrixMode(GL_PROJECTION);
+        glLoadIdentity();
+        glOrtho(0.0, 2.0, 0.0, 2.0, 0.0, 1.0);
+
+        glMatrixMode(GL_MODELVIEW);
+        glLoadIdentity();
+        glTranslatef((GLfloat) ((active_view - 1) & 1), (GLfloat) (1 - (active_view - 1) / 2), 0.0f);
+
+        glColor3f(1.0f, 1.0f, 0.6f);
+
+        glBegin(GL_LINE_STRIP);
+        glVertex2i(0, 0);
+        glVertex2i(1, 0);
+        glVertex2i(1, 1);
+        glVertex2i(0, 1);
+        glVertex2i(0, 0);
+        glEnd();
+    }
+}
+
+
+//========================================================================
+// Framebuffer size callback function
+//========================================================================
+
+static void framebufferSizeFun(GLFWwindow* window, int w, int h)
+{
+    width  = w;
+    height = h > 0 ? h : 1;
+    do_redraw = 1;
+}
+
+
+//========================================================================
+// Window refresh callback function
+//========================================================================
+
+static void windowRefreshFun(GLFWwindow* window)
+{
+    drawAllViews();
+    glfwSwapBuffers(window);
+    do_redraw = 0;
+}
+
+
+//========================================================================
+// Mouse position callback function
+//========================================================================
+
+static void cursorPosFun(GLFWwindow* window, double x, double y)
+{
+    int wnd_width, wnd_height, fb_width, fb_height;
+    double scale;
+
+    glfwGetWindowSize(window, &wnd_width, &wnd_height);
+    glfwGetFramebufferSize(window, &fb_width, &fb_height);
+
+    scale = (double) fb_width / (double) wnd_width;
+
+    x *= scale;
+    y *= scale;
+
+    // Depending on which view was selected, rotate around different axes
+    switch (active_view)
+    {
+        case 1:
+            rot_x += (int) (y - ypos);
+            rot_z += (int) (x - xpos);
+            do_redraw = 1;
+            break;
+        case 3:
+            rot_x += (int) (y - ypos);
+            rot_y += (int) (x - xpos);
+            do_redraw = 1;
+            break;
+        case 4:
+            rot_y += (int) (x - xpos);
+            rot_z += (int) (y - ypos);
+            do_redraw = 1;
+            break;
+        default:
+            // Do nothing for perspective view, or if no view is selected
+            break;
+    }
+
+    // Remember cursor position
+    xpos = x;
+    ypos = y;
+}
+
+
+//========================================================================
+// Mouse button callback function
+//========================================================================
+
+static void mouseButtonFun(GLFWwindow* window, int button, int action, int mods)
+{
+    if ((button == GLFW_MOUSE_BUTTON_LEFT) && action == GLFW_PRESS)
+    {
+        // Detect which of the four views was clicked
+        active_view = 1;
+        if (xpos >= width / 2)
+            active_view += 1;
+        if (ypos >= height / 2)
+            active_view += 2;
+    }
+    else if (button == GLFW_MOUSE_BUTTON_LEFT)
+    {
+        // Deselect any previously selected view
+        active_view = 0;
+    }
+
+    do_redraw = 1;
+}
+
+static void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
+{
+    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
+        glfwSetWindowShouldClose(window, GLFW_TRUE);
+}
+
+
+//========================================================================
+// main
+//========================================================================
+
+int main(void)
+{
+    GLFWwindow* window;
+
+    // Initialise GLFW
+    if (!glfwInit())
+    {
+        fprintf(stderr, "Failed to initialize GLFW\n");
+        exit(EXIT_FAILURE);
+    }
+
+    glfwWindowHint(GLFW_SAMPLES, 4);
+
+    // Open OpenGL window
+    window = glfwCreateWindow(500, 500, "Split view demo", NULL, NULL);
+    if (!window)
+    {
+        fprintf(stderr, "Failed to open GLFW window\n");
+
+        glfwTerminate();
+        exit(EXIT_FAILURE);
+    }
+
+    // Set callback functions
+    glfwSetFramebufferSizeCallback(window, framebufferSizeFun);
+    glfwSetWindowRefreshCallback(window, windowRefreshFun);
+    glfwSetCursorPosCallback(window, cursorPosFun);
+    glfwSetMouseButtonCallback(window, mouseButtonFun);
+    glfwSetKeyCallback(window, key_callback);
+
+    // Enable vsync
+    glfwMakeContextCurrent(window);
+    gladLoadGLLoader((GLADloadproc) glfwGetProcAddress);
+    glfwSwapInterval(1);
+
+    if (GLAD_GL_ARB_multisample || GLAD_GL_VERSION_1_3)
+        glEnable(GL_MULTISAMPLE_ARB);
+
+    glfwGetFramebufferSize(window, &width, &height);
+    framebufferSizeFun(window, width, height);
+
+    // Main loop
+    for (;;)
+    {
+        // Only redraw if we need to
+        if (do_redraw)
+            windowRefreshFun(window);
+
+        // Wait for new events
+        glfwWaitEvents();
+
+        // Check if the window should be closed
+        if (glfwWindowShouldClose(window))
+            break;
+    }
+
+    // Close OpenGL window and terminate GLFW
+    glfwTerminate();
+
+    exit(EXIT_SUCCESS);
+}
+