import cairo
import os
from PIL import Image

# Create a Cairo image surface:
imagesize = (256,32)
surface = cairo.ImageSurface(cairo.FORMAT_ARGB32, *imagesize) 
cr = cairo.Context(surface)
padding = 3

# Choose a font (look in /Library/Fonts) and set up the transforms.
cr.select_font_face("Apple Chancery", 
                    cairo.FONT_SLANT_NORMAL, 
                    cairo.FONT_WEIGHT_BOLD) 
cr.set_font_size(32)
cr.set_source_rgb(1,1,1)

# Create a string for appending the glyph metrics to the texture file:
glyphs = '''
struct GlyphPosition {
    int X;
    int Y;
};\n
struct GlyphMetrics {
    int XBearing;
    int YBearing;
    int Width;
    int Height;
    int XAdvance;
    int YAdvance;
};\n
struct Glyph {
    GlyphPosition Position;
    GlyphMetrics Metrics;
};\n
static const Glyph NumeralGlyphs[] = {\n'''

# Render glyphs '0' through '9' and write out their extents:
x, y = 0, 0 
for character in '0123456789': 
    extents = cr.text_extents(character) 
    x_bearing, y_bearing, width, height, x_advance, y_advance = extents
    glyphs += '    {{ %d, %d }, ' % (x, y) 
    glyphs += '{ %d, %d, %d, %d, %d, %d }},\n' % extents 
    cr.save()
    cr.translate(x, -y_bearing)
    cr.text_path(character)
    cr.fill() 
    cr.restore()
    x += width + padding 
glyphs += '};\n'

# Extract the alpha channel and open it up for a quick preview:
surface.write_to_png("NumeralsTexture.png") 
image = Image.open("NumeralsTexture.png") 
image.load()
image.split()[3].save("NumeralsTexture.png") 
os.system("open NumeralsTexture.png")

# Serialize the image data to a C header file:
os.system('PVRTexTool -h -yflip1 -fOGL8 -iNumeralsTexture.png') 

# Write to the header file:            
headerFile = open('NumeralsTexture.h', 'a') (16)
headerFile.write(glyphs)
headerFile.close()

#include <OpenGLES/ES1/gl.h>
#include <OpenGLES/ES1/glext.h>
#include <mach/mach.h>
#include <mach/mach_time.h>
#include "../Textures/NumeralsTexture.h"

typedef unsigned int PVRTuint32;

struct PVR_Texture_Header {
    // ...see PVRTTexture.h in the PowerVR SDK...
};

class FpsRenderer {
public:
    FpsRenderer(vec2 windowSize)
    {
        ...
    }
    void RenderFps()
    {
        ...
    }
    
private:

    static const int MaxNumDigits = 3;
    static const int VertsPerDigit = 6;
    static const int FloatsPerVert = 4;
    static const int FloatsPerDigit = VertsPerDigit * FloatsPerVert;
    static const int TexCoordOffset = sizeof(float) * 2;
    static const int BytesPerVert = sizeof(float) * FloatsPerVert;
    static const int BytesPerDigit = sizeof(float) * FloatsPerDigit;
    
    uint64_t GetElapsedNanoseconds()
    {
        uint64_t current = mach_absolute_time();
        uint64_t duration = current - m_previousTime;
        m_previousTime = current;
        mach_timebase_info_data_t info;
        mach_timebase_info(&info);
        duration *= info.numer;
        duration /= info.denom;
        return duration;
    }

    float* WriteGlyphVertex(const Glyph& glyph, vec2 pos, int corner, float* vertex)
    {
        ...
    }
    
    double m_filterConstant;
    double m_fps;
    uint64_t m_previousTime;
    vec2 m_windowSize;
    vec2 m_textureSize;
    GLuint m_textureHandle;
    GLuint m_vbo;
};

import os
import math
from PIL import Image

inside, outside = (0,0), (9999, 9999)

def invert(c):
    return 255 - c
    
def initCell(pixel):
    if pixel == 0: return inside
    return outside

def distSq(cell):
    return cell[0] * cell[0] + cell[1] * cell[1]

def getCell(grid, x, y):
    if y < 0 or y >= len(grid): return outside
    if x < 0 or x >= len(grid[y]): return outside
    return grid[y][x]

def compare(grid, cell, x, y, ox, oy):
    other = getCell(grid, x + ox, y + oy)
    other = (other[0] + ox, other[1] + oy)
    if distSq(other) < distSq(cell): return other
    return cell

def propagate(grid):
    height = len(grid)
    width = len(grid[0])
    for y in xrange(0, height):
        for x in xrange(0, width):
            cell = grid[y][x]
            cell = compare(grid, cell, x, y, -1,  0)
            cell = compare(grid, cell, x, y,  0, -1)
            cell = compare(grid, cell, x, y, -1, -1)
            cell = compare(grid, cell, x, y, +1, -1)
            grid[y][x] = cell
        for x in xrange(width - 1, -1, -1):
            cell = grid[y][x]
            cell = compare(grid, cell, x, y, 1, 0)
            grid[y][x] = cell
    for y in xrange(height - 1, -1, -1):
        for x in xrange(width - 1, -1, -1):
            cell = grid[y][x]
            cell = compare(grid, cell, x, y, +1,  0)
            cell = compare(grid, cell, x, y,  0, +1)
            cell = compare(grid, cell, x, y, -1, +1)
            cell = compare(grid, cell, x, y, +1, +1)
            grid[y][x] = cell
        for x in xrange(0, width):
            cell = grid[y][x]
            cell = compare(grid, cell, x, y, -1,  0)
            grid[y][x] = cell

def GenerateDistanceField(inFile, outFile, spread):
    
    print "Allocating the destination image..."
    image = Image.open(inFile)
    image.load()
    channels = image.split()
    if len(channels) == 4: alphaChannel = channels[3]
    else: alphaChannel = channels[0]
    w = alphaChannel.size[0] + spread * 2
    h = alphaChannel.size[1] + spread * 2
    img = Image.new("L", (w, h), 0)
    img.paste(alphaChannel, (spread, spread))
    width, height = img.size

    print "Creating the two grids..."
    pixels = img.load()
    grid0 = [[initCell(pixels[x, y]) \
              for x in xrange(width)] \
              for y in xrange(height)] 
    grid1 = [[initCell(invert(pixels[x, y])) \
              for x in xrange(width)] \
              for y in xrange(height)] 

    print "Propagating grids..."
    propagate(grid0)
    propagate(grid1)

    print "Subtracting grids..."
    signedDistance = [[0 for x in xrange(width)] for y in xrange(height)]
    for y in xrange(height):
        for x in xrange(width):
            dist1 = math.sqrt(distSq(grid0[y][x]))
            dist0 = math.sqrt(distSq(grid1[y][x]))
            signedDistance[y][x] = dist0 - dist1

    print "Normalizing..."
    maxDist, minDist = spread, -spread
    for y in xrange(height):
        for x in xrange(width):
            dist = signedDistance[y][x]
            if dist < 0: dist = -128 * (dist - minDist) / minDist
            else: dist = 128 + 128 * dist / maxDist
            if dist < 0: dist = 0
            elif dist > 255: dist = 255
            signedDistance[y][x] = int(dist)
            pixels[x, y] = signedDistance[y][x]

    print "Saving %s..." % outFile
    img.save(outFile)

if __name__ == "__main__":
    inFile, outFile = 'Aum.png', 'DistanceFieldAum.png'
    GenerateDistanceField(inFile, outFile, spread = 15)

varying mediump vec2 TextureCoord;

uniform sampler2D DistanceField;
uniform mediump vec3 GlyphColor;

const mediump float SmoothCenter = 0.5;
const mediump float SmoothWidth = 0.04;

void main(void)
{
    mediump vec4 color = texture2D(DistanceField, TextureCoord);
    mediump float distance = color.a;
    mediump float alpha = smoothstep(SmoothCenter - SmoothWidth,
                                     SmoothCenter + SmoothWidth,
                                     distance);
    gl_FragColor = vec4(GlyphColor, alpha);
}

#extension GL_OES_standard_derivatives : enable

varying mediump vec2 TextureCoord;

uniform sampler2D DistanceField;
uniform mediump vec3 GlyphColor;

const mediump float SmoothCenter = 0.5;

void main(void)
{
    mediump vec4 color = texture2D(DistanceField, TextureCoord);
    mediump float distance = color.a;
    mediump float smoothWidth = fwidth(distance);
    mediump float alpha = smoothstep(SmoothCenter - smoothWidth,
                                     SmoothCenter + smoothWidth, distance);
    gl_FragColor = vec4(GlyphColor, alpha);
}

#extension GL_OES_standard_derivatives : enable

varying mediump vec2 TextureCoord;

uniform sampler2D DistanceField;
uniform mediump vec3 OutlineColor;
uniform mediump vec3 GlyphColor;
uniform mediump vec3 GlowColor;

uniform bool Outline;
uniform bool Glow;
uniform bool Shadow;

const mediump vec2 ShadowOffset = vec2(0.005, 0.01);
const mediump vec3 ShadowColor = vec3(0.0, 0.0, 0.125);
const mediump float SmoothCenter = 0.5;
const mediump float OutlineCenter = 0.4;
const mediump float GlowBoundary = 1.0;

void main(void)
{
    mediump vec4 color = texture2D(DistanceField, TextureCoord);
    mediump float distance = color.a;
    mediump float smoothWidth = fwidth(distance);
    mediump float alpha;
    mediump vec3 rgb;

    if (Outline) {
        mediump float mu = smoothstep(OutlineCenter - smoothWidth,
                                      OutlineCenter + smoothWidth,
                                      distance);
        alpha = smoothstep(SmoothCenter - smoothWidth,
                           SmoothCenter + smoothWidth, distance)
        rgb = mix(GlyphColor, OutlineColor, mu);
    }

    if (Glow) {
        mediump float mu = smoothstep(SmoothCenter - smoothWidth,
                                      SmoothCenter + smoothWidth, 
                                      distance);
        rgb = mix(GlyphColor, GlowColor, mu);
        alpha = smoothstep(SmoothCenter, GlowBoundary, sqrt(distance));
    }

    if (Shadow) {
        mediump float distance2 = texture2D(DistanceField, 
                                            TextureCoord + ShadowOffset).a;
        mediump float s = smoothstep(SmoothCenter - smoothWidth,
                                     SmoothCenter + smoothWidth, 
                                     distance2);
        mediump float v = smoothstep(SmoothCenter - smoothWidth,
                                     SmoothCenter + smoothWidth, 
                                     distance);
        
        // If s is 0 then we're inside the shadow; 
        // if it's 1 then we're outside the shadow.
        //
        // If v is 0 then we're inside the vector; 
        // if it's 1 then we're outside the vector.
        
        // Totally inside the vector (i.e., inside the glyph):
        if (v == 0.0) {
            rgb = GlyphColor;
            alpha = 0.0;
        }
        
        // On a non-shadowed vector edge:
        else if (s == 1.0 && v != 1.0) {
            rgb = GlyphColor;
            alpha = v;
        }

        // Totally inside the shadow:
        else if (s == 0.0 && v == 1.0) {
            rgb = ShadowColor;
            alpha = 0.0;
        }

        // On a shadowed vector edge:
        else if (s == 0.0) {
            rgb = mix(GlyphColor, ShadowColor, v);
            alpha = 0.0;
        }

        // On the shadow's outside edge:
        else {
            rgb = mix(GlyphColor, ShadowColor, v);
            alpha = s;
        }
    }

    gl_FragColor = vec4(rgb, alpha);
}

#include <list>

class SpringNode;

typedef std::list<SpringNode*> NeighborList;

class SpringNode {
public:
    SpringNode()
    {
        m_position = vec2(0, 0);
        m_velocity = vec2(0, 0);
        m_mass = 1;
        m_pinned = false;
    }
    void Pin()
    {
        m_pinned = true;
    }
    void SetPosition(const vec2& p)
    {
        m_position = p;
    }
    vec2 GetPosition() const
    {
        return m_position;
    }
    void AddNeighbor(SpringNode* node)
    {
        m_neighbors.push_back(node);
    }
    void ResetForce(vec2 force)
    {
        m_force = force;
    }
    void ComputeForce()
    {
        const float StiffnessContant = 3.0f;
        const float RestLength = 0.075f;
        const float DampingConstant = 2.0f;
        
        NeighborList::const_iterator n = m_neighbors.begin();
        for (; n != m_neighbors.end(); ++n) {

            // Compute the spring force:
            vec2 v = (*n)->m_position - m_position;
            float length = v.Length();
            vec2 direction = v.Normalized();
            vec2 restoringForce = direction * StiffnessContant 
              * (length - RestLength);

            // Compute the damping force:
            vec2 relativeVelocity = (*n)->m_velocity - m_velocity;
            vec2 dampingForce = relativeVelocity * DampingConstant;
            
            // Add the two forces to this node and subtract them 
            // from the neighbor:
            vec2 totalForce = restoringForce + dampingForce;
            m_force += totalForce;
            (*n)->m_force -= totalForce;
        }
    }
    void Update(float dt)
    {
        if (m_pinned)
            return;
        
        vec2 acceleration = m_force / m_mass;
        m_velocity += acceleration * dt;
        m_position += m_velocity * dt;
    }
private:
    vec2 m_force;
    vec2 m_position;
    vec2 m_velocity;
    float m_mass;
    bool m_pinned;
    NeighborList m_neighbors;
};

void UpdateSimulation(float timeStep, vec2 gravityVector)
{
    for each node:
        node->ResetForce(gravityVector)

    for each node:
        node->AddSpringForces()

    for each node:
        node->Update(timeStep)
}

#pragma once
#include "Vector.hpp"
#include <vector>

typedef std::vector<vec2> PositionList;

struct IApplicationEngine {
    virtual void Initialize(int width, int height) = 0;
    virtual void Render() const = 0;
    virtual void UpdateAnimation(float timeStep) = 0;
    virtual void SetGravityDirection(vec2 direction) = 0;
    virtual ~IApplicationEngine() {}
};

struct IRenderingEngine {
    virtual void Initialize() = 0;
    virtual void Render(const PositionList& positions) const = 0;
    virtual ~IRenderingEngine() {}
};

IApplicationEngine* CreateApplicationEngine(IRenderingEngine*);

namespace ES1 { IRenderingEngine* CreateRenderingEngine(); }
namespace ES2 { IRenderingEngine* CreateRenderingEngine(); }

The GLView class looks much like all the other samples in this book, except that it needs to pass in a gravity vector. See Example 7.22. For more information about setting up the accelerometer, flip back to the section called “Replacing Buttons with Orientation Sensors”.

- (void) accelerometer: (UIAccelerometer*) accelerometer
         didAccelerate: (UIAcceleration*) acceleration
{
    [m_filter addAcceleration:acceleration];
    
    vec2 direction(m_filter.x, m_filter.y);
    m_applicationEngine->SetGravityDirection(direction);
}

#include "Interfaces.hpp"
#include "SpringNode.hpp"

using namespace std;

class ApplicationEngine : public IApplicationEngine {
public:
    ApplicationEngine(IRenderingEngine* renderingEngine);
    ~ApplicationEngine();
    void Initialize(int width, int height);
    void SetGravityDirection(vec2 direction);
    void Render() const;
    void UpdateAnimation(float dt);
private:
    vec2 m_gravityDirection;
    vector<SpringNode> m_springNodes;
    PositionList m_positions;
    IRenderingEngine* m_renderingEngine;
};
    
IApplicationEngine* CreateApplicationEngine
  (IRenderingEngine* renderingEngine)
{
    return new ApplicationEngine(renderingEngine);
}

ApplicationEngine::~ApplicationEngine()
{
    delete m_renderingEngine;
}

void ApplicationEngine::Initialize(int width, int height)
{
    m_renderingEngine->Initialize();
}

void ApplicationEngine::SetGravityDirection(vec2 direction)
{
    m_gravityDirection = direction;
}

void ApplicationEngine::Render() const
{
    m_renderingEngine->Render(m_positions);
}

ApplicationEngine::ApplicationEngine(IRenderingEngine* renderingEngine) :
    m_renderingEngine(renderingEngine),
    m_gravityDirection(vec2(0, -1))
{
    const int NumColumns = 10;
    const int NumRows = 14;
    const float SpreadFactor = 0.125f;
    
    m_springNodes.resize(NumColumns * NumRows);
    m_positions.resize(m_springNodes.size());
    
    vector<SpringNode>::iterator node = m_springNodes.begin();
    for (int r = 0; r < NumRows; ++r) {
        for (int c = 0; c < NumColumns; ++c) {
            
            vec2 position;
            position.x = c - (NumColumns - 1) / 2.0f;
            position.y = r - (NumRows - 1) / 2.0f;
            node->SetPosition(position * SpreadFactor);
            
            if (c > 0)
                node->AddNeighbor(&*node - 1);
            
            if (r > 0)
                node->AddNeighbor(&*node - NumColumns);
            
            ++node;
        }
    }
    
    m_springNodes[0].Pin();
    m_springNodes[NumColumns - 1].Pin();
    m_springNodes[NumColumns * NumRows - 1].Pin();
    m_springNodes[NumColumns * (NumRows - 1)].Pin();
    
    UpdateAnimation(0);
}

void ApplicationEngine::UpdateAnimation(float dt)
{
    const float GravityStrength = 0.01f;
    const int SimulationIterations = 10;
    
    vector<SpringNode>::iterator node;
    vec2 force = m_gravityDirection * GravityStrength;
    
    for (int i = 0; i < SimulationIterations; ++i) {
        for (node = m_springNodes.begin(); 
             node != m_springNodes.end(); 
             ++node)
            node->ResetForce(force);

        for (node = m_springNodes.begin(); 
             node != m_springNodes.end(); 
             ++node)
            node->ComputeForce();

        PositionList::iterator position = m_positions.begin();
        for (node = m_springNodes.begin(); 
             node != m_springNodes.end(); 
             ++node) 
        {
            node->Update(dt);
            *position++ = node->GetPosition();
        }
    }
}

void RenderingEngine::Initialize()
{
    // Load up some textures:
    m_textures.Star = CreateTexture(Star);
    m_textures.Background = CreateTexture(_Background_pvrtc);
    
    // Extract width and height from the color buffer:
    ivec2 screenSize;
    glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
                                    GL_RENDERBUFFER_WIDTH_OES, 
                                    &screenSize.x);
    glGetRenderbufferParameterivOES(GL_RENDERBUFFER_OES,
                                    GL_RENDERBUFFER_HEIGHT_OES, 
                                    &screenSize.y);
    
    // Create the on-screen FBO:
    glGenFramebuffersOES(1, &m_framebuffers.Screen);
    glBindFramebufferOES(GL_FRAMEBUFFER_OES, m_framebuffers.Screen);
    glFramebufferRenderbufferOES(GL_FRAMEBUFFER_OES, 
                                 GL_COLOR_ATTACHMENT0_OES,
                                 GL_RENDERBUFFER_OES, 
                                 m_renderbuffers.Screen);
    
    // Set up various OpenGL state:
    glViewport(0, 0, screenSize.x, screenSize.y);
    glEnable(GL_TEXTURE_2D);
    glPointSize(15);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    
    // Set up the transforms:
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    
    const float NearPlane = 5, FarPlane = 100;
    const float Scale = 0.0005;
    glFrustumf(-Scale * screenSize.x / 2, Scale * screenSize.x / 2,
               -Scale * screenSize.y / 2, Scale * screenSize.y / 2,
               NearPlane, FarPlane);
    
    glMatrixMode(GL_MODELVIEW);
    
    vec3 eye(0, 0, 40);
    vec3 target(0, 0, 0);
    vec3 up(0, 1, 0);
    mat4 modelview = mat4::LookAt(eye, target, up);
    glLoadMatrixf(modelview.Pointer());
}

void RenderingEngine::Render(const PositionList& positions) const
{
    // Render the background:
    int backgroundRectangle[] = { 0, 0, 480, 320 };
    glTexParameteriv(GL_TEXTURE_2D, 
                     GL_TEXTURE_CROP_RECT_OES, 
                     backgroundRectangle);
    glBindTexture(GL_TEXTURE_2D, m_textures.Background);
    glColor4f(0.75, 0.75, 0.75, 1);
    glDrawTexfOES(0, 0, 0, 320, 480);

    // Set the state for point rendering:
    glEnable(GL_BLEND);
    glEnable(GL_POINT_SPRITE_OES);
    glTexEnvi(GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_TRUE);

    // Set up the vertex array:
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(2, GL_FLOAT, sizeof(vec2), &positions[0].x);

    // Render the point sprites:
    glBindTexture(GL_TEXTURE_2D, m_textures.Star);
    glColor4f(1, 1, 1, 1);
    glDrawArrays(GL_POINTS, 0, positions.size());
    
    // Restore the OpenGL state:
    glDisable(GL_BLEND);
    glDisable(GL_POINT_SPRITE_OES);
    glTexEnvi(GL_POINT_SPRITE_OES, GL_COORD_REPLACE_OES, GL_FALSE);
}

attribute vec4 Position;
attribute vec2 TextureCoord;

uniform mat4 Projection;
uniform mat4 Modelview;

varying vec2 TextureCoordOut;

void main(void)
{
    gl_Position = Projection * Modelview * Position;
    TextureCoordOut = TextureCoord;
    gl_PointSize = 15.0;
}

varying mediump vec2 TextureCoordOut;

uniform sampler2D Sampler;
uniform bool IsSprite;

void main(void)
{
    gl_FragColor = texture2D(Sampler, 
                             IsSprite ? gl_PointCoord : TextureCoordOut);
}

void RenderingEngine::Initialize()
{
    // Load up some textures:
    m_textures.Star = CreateTexture(Star);
    m_textures.Background = CreateTexture(_Background_pvrtc);
    
    // Extract width and height from the color buffer.
    glGetRenderbufferParameteriv(GL_RENDERBUFFER,
                                 GL_RENDERBUFFER_WIDTH, &m_screenSize.x);
    glGetRenderbufferParameteriv(GL_RENDERBUFFER,
                                 GL_RENDERBUFFER_HEIGHT, &m_screenSize.y);
    
    // Create the on-screen FBO.
    glGenFramebuffers(1, &m_framebuffers.Screen);
    glBindFramebuffer(GL_FRAMEBUFFER, m_framebuffers.Screen);
    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                              GL_RENDERBUFFER, m_renderbuffers.Screen);
    
    // Create the GLSL program.
    GLuint program = BuildProgram(SimpleVertexShader, SimpleFragmentShader);
    glUseProgram(program);
    
    // Extract the handles to attributes and uniforms.
    m_attributes.Position = glGetAttribLocation(program, "Position");
    m_attributes.TextureCoord = glGetAttribLocation(program, "TextureCoord");
    m_uniforms.Projection = glGetUniformLocation(program, "Projection");
    m_uniforms.Modelview = glGetUniformLocation(program, "Modelview");
    m_uniforms.Sampler = glGetUniformLocation(program, "Sampler");
    m_uniforms.IsSprite = glGetUniformLocation(program, "IsSprite");
    
    // Set up various GL state.
    glViewport(0, 0, m_screenSize.x, m_screenSize.y);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    
    // Set up the transforms.
    const float NearPlane = 5, FarPlane = 100;
    const float Scale = 0.0005;
    const float HalfWidth = Scale * m_screenSize.x / 2;
    const float HalfHeight = Scale * m_screenSize.y / 2;
    
    mat4 projection = mat4::Frustum(-HalfWidth, HalfWidth, 
                                    -HalfHeight, HalfHeight,
                                    NearPlane, FarPlane);
    glUniformMatrix4fv(m_uniforms.Projection, 1, 0, projection.Pointer());

    vec3 eye(0, 0, 40);
    vec3 target(0, 0, 0);
    vec3 up(0, 1, 0);
    mat4 modelview = mat4::LookAt(eye, target, up);
    glUniformMatrix4fv(m_uniforms.Modelview, 1, 0, modelview.Pointer());
}

void RenderingEngine::Render(const PositionList& positions) const
{

    RenderBackground();
    
    glBindTexture(GL_TEXTURE_2D, m_textures.Star);
    glEnableVertexAttribArray(m_attributes.Position);
    glDisableVertexAttribArray(m_attributes.TextureCoord);
    glUniform1i(m_uniforms.IsSprite, GL_TRUE);
    
    glVertexAttribPointer(m_attributes.Position,
                          2,
                          GL_FLOAT,
                          GL_FALSE,
                          sizeof(vec2),
                          &positions[0].x);
    
    glEnable(GL_BLEND);
    glDrawArrays(GL_POINTS, 0, positions.size());
    glDisable(GL_BLEND);
}