Changes between Initial Version and Version 1 of pub/trash/pour-guite


Ignore:
Timestamp:
Aug 8, 2011, 12:07:56 PM (9 years ago)
Author:
sam
Comment:

--

Legend:

Unmodified
Added
Removed
Modified
  • pub/trash/pour-guite

    v1 v1  
     1{{{
     2#!cpp
     3//
     4// Lol Engine
     5//
     6// Copyright: (c) 2010-2011 Sam Hocevar <sam@hocevar.net>
     7//   This program is free software; you can redistribute it and/or
     8//   modify it under the terms of the Do What The Fuck You Want To
     9//   Public License, Version 2, as published by Sam Hocevar. See
     10//   http://sam.zoy.org/projects/COPYING.WTFPL for more details.
     11//
     12
     13#if defined HAVE_CONFIG_H
     14#   include "config.h"
     15#endif
     16
     17#include <cmath>
     18#include <cstdio>
     19
     20#include "core.h"
     21#include "lolgl.h"
     22#include "loldebug.h"
     23
     24using namespace std;
     25
     26namespace lol
     27{
     28
     29/*
     30 * DebugQuad implementation class
     31 */
     32
     33static int const NUM_ARRAYS = 2;
     34static int const NUM_BUFFERS = 6;
     35static int const NUM_ATTRS = 6;
     36static int const NUM_SHADERS = 6;
     37static int const NUM_TEXTURES = 1;
     38
     39static int const TEX_SIZE = 32;
     40
     41class DebugQuadData
     42{
     43    friend class DebugQuad;
     44
     45private:
     46    vec2 orig, step, aa, bb;
     47
     48    int initialised;
     49    float time;
     50    GLuint array[NUM_ARRAYS];
     51    GLuint buffer[NUM_BUFFERS];
     52    Shader *shader[NUM_SHADERS];
     53    GLuint attr[NUM_ATTRS];
     54    GLuint texture[NUM_TEXTURES];
     55    uint8_t image[1][TEX_SIZE * TEX_SIZE * 4];
     56};
     57
     58/*
     59 * Public DebugQuad class
     60 */
     61
     62DebugQuad::DebugQuad()
     63  : data(new DebugQuadData())
     64{
     65    data->initialised = 0;
     66    data->time = RandF(10000.0f);
     67
     68    drawgroup = DRAWGROUP_HUD;
     69}
     70
     71void DebugQuad::TickGame(float deltams)
     72{
     73    Entity::TickGame(deltams);
     74
     75    data->time += deltams;
     76}
     77
     78void DebugQuad::TickDraw(float deltams)
     79{
     80    Entity::TickDraw(deltams);
     81
     82    if (!data->initialised && !IsDestroying())
     83    {
     84        glGenVertexArrays(NUM_ARRAYS, data->array);
     85        glGenBuffers(NUM_BUFFERS, data->buffer);
     86        glGenTextures(NUM_TEXTURES, data->texture);
     87        for (int i = 0; i < NUM_SHADERS; i++)
     88            data->shader[i] = NULL;
     89
     90        /* Checkerboard texture */
     91        glEnable(GL_TEXTURE_2D);
     92        glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     93        for (int j = 0; j < TEX_SIZE; j++)
     94            for (int i = 0; i < TEX_SIZE; i++)
     95            {
     96                uint8_t wb = (((i / 2) ^ (j / 2)) & 1) * 0xff;
     97                data->image[0][(j * TEX_SIZE + i) * 4 + 0] = wb;
     98                data->image[0][(j * TEX_SIZE + i) * 4 + 1] = wb;
     99                data->image[0][(j * TEX_SIZE + i) * 4 + 2] = wb;
     100                data->image[0][(j * TEX_SIZE + i) * 4 + 3] = 0xff;
     101            }
     102        /* Use GL_RGBA instead of 4 for the internal format (Android) */
     103        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 0,
     104                     GL_RGBA, GL_UNSIGNED_BYTE, data->image[0]);
     105        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     106        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     107
     108        data->initialised = 1;
     109    }
     110    else if (data->initialised && IsDestroying())
     111    {
     112        glDeleteVertexArrays(NUM_ARRAYS, data->array);
     113        glDeleteBuffers(NUM_BUFFERS, data->buffer);
     114        glDeleteTextures(NUM_TEXTURES, data->texture);
     115
     116        for (int i = 0; i < NUM_SHADERS; i++)
     117            if (data->shader[i])
     118                Shader::Destroy(data->shader[i]);
     119
     120        data->initialised = 0;
     121    }
     122
     123    /* Reset GL states to something reasonably safe */
     124    glMatrixMode(GL_PROJECTION);
     125    glLoadIdentity();
     126    glMatrixMode(GL_MODELVIEW);
     127    glLoadIdentity();
     128    glDisable(GL_TEXTURE_2D);
     129    glBindBuffer(GL_ARRAY_BUFFER, 0);
     130    glUseProgram(0);
     131
     132    /* Prepare our quad coordinates */
     133    vec2i const layout(4, 3);
     134    data->step = vec2(2.0f, -2.0f) / (3 * layout + vec2i(1));
     135    data->orig = vec2(-1.0f, 1.0f) + data->step;
     136    data->aa = data->orig;
     137    data->bb = data->orig + 2.0f * data->step;
     138
     139    /* Generate a few random numbers */
     140    float f1 = 0.5f + 0.5f * sinf(0.00034f * data->time);
     141    float f2 = 0.5f + 0.5f * sinf(0.00053f * data->time + 1.0f);
     142    float f3 = 0.5f + 0.5f * sinf(0.00072f * data->time + 4.0f);
     143    float f4 = 0.5f + 0.5f * sinf(0.00091f * data->time + 8.0f);
     144
     145    GLfloat const colors[] = { f1, f2, f3, f4, f2, f1, f3, f1, f4,
     146                               f3, f1, f4, f4, f3, f2, f1, f2, f3 };
     147    GLfloat const texcoords[] = { f1, f3, f3, f2, f2, f4,
     148                                  f2, f4, f4, f1, f1, f3 };
     149
     150#if defined HAVE_GLBEGIN || defined USE_GLEW
     151    /*
     152     * Test #1: simple glBegin code
     153     * Renders an orange square.
     154     */
     155    glColor3f(0.8f, 0.5f, 0.2f);
     156    glBegin(GL_TRIANGLES);
     157        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     158        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     159        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     160
     161        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     162        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     163        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     164    glEnd();
     165
     166    Advance();
     167
     168    /*
     169     * Test #2: glBegin + per-vertex coloring
     170     * Renders a multicolored square with varying colors.
     171     */
     172    glBegin(GL_TRIANGLES);
     173        glColor3f(f1, f2, f3);
     174        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     175        glColor3f(f4, f2, f1);
     176        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     177        glColor3f(f3, f1, f4);
     178        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     179
     180        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     181        glColor3f(f4, f3, f2);
     182        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     183        glColor3f(f1, f2, f3);
     184        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     185    glEnd();
     186
     187    Advance();
     188
     189    /*
     190     * Test #3: glBegin + texture
     191     * Renders an animated black-and-white distorted checkerboard.
     192     */
     193    glEnable(GL_TEXTURE_2D);
     194    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     195    glColor3f(1.0f, 1.0f, 1.0f);
     196    glBegin(GL_TRIANGLES);
     197        glTexCoord2f(f1, f3);
     198        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     199        glTexCoord2f(f3, f2);
     200        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     201        glTexCoord2f(f2, f4);
     202        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     203
     204        glTexCoord2f(f2, f4);
     205        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     206        glTexCoord2f(f4, f1);
     207        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     208        glTexCoord2f(f1, f3);
     209        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     210    glEnd();
     211    glDisable(GL_TEXTURE_2D);
     212
     213    Advance();
     214
     215    /*
     216     * Test #4: glBegin + color in fragment shader
     217     * Renders a static, coloured and tiled pattern.
     218     */
     219    if (!data->shader[0])
     220        data->shader[0] = Shader::Create(
     221            "#version 110\n"
     222            "void main()"
     223            "{"
     224            "    gl_Position = gl_Vertex;"
     225            "}",
     226
     227            "#version 110\n"
     228            "void main()"
     229            "{"
     230            "    float dx = mod(gl_FragCoord.x * gl_FragCoord.y, 2.0);"
     231            "    float dy = mod(gl_FragCoord.x * 0.125, 1.0);"
     232            "    float dz = mod(gl_FragCoord.y * 0.125, 1.0);"
     233            "    gl_FragColor = vec4(dx, dy, dz, 1.0);"
     234            "}");
     235    data->shader[0]->Bind();
     236    glColor3f(0.0f, 1.0f, 1.0f);
     237    glBegin(GL_TRIANGLES);
     238        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     239        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     240        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     241
     242        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     243        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     244        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     245    glEnd();
     246    glUseProgram(0);
     247
     248    Advance();
     249
     250    /*
     251     * Test #5: glBegin + pass color from vertex shader to fragment shader
     252     * Renders a multicolored square with varying colors.
     253     */
     254    if (!data->shader[1])
     255        data->shader[1] = Shader::Create(
     256            "#version 110\n"
     257            "varying vec4 pass_Color;"
     258            "void main()"
     259            "{"
     260            "    float r = gl_MultiTexCoord0.x;"
     261            "    float g = gl_MultiTexCoord0.y;"
     262            "    pass_Color = vec4(1.0 - r, 1.0 - g, r, 1.0);"
     263            "    gl_Position = gl_Vertex;"
     264            "}",
     265
     266            "#version 110\n"
     267            "varying vec4 pass_Color;"
     268            "void main()"
     269            "{"
     270            "    gl_FragColor = pass_Color;"
     271            "}");
     272    data->shader[1]->Bind();
     273    glColor3f(0.0f, 1.0f, 1.0f);
     274    glBegin(GL_TRIANGLES);
     275        glTexCoord2f(f1, f3);
     276        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     277        glTexCoord2f(f3, f2);
     278        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     279        glTexCoord2f(f2, f4);
     280        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     281
     282        glTexCoord2f(f2, f4);
     283        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     284        glTexCoord2f(f4, f1);
     285        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     286        glTexCoord2f(f1, f3);
     287        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     288    glEnd();
     289    glUseProgram(0);
     290
     291    Advance();
     292
     293    /*
     294     * Test #6: glBegin + apply texture in fragment shader
     295     * Renders an animated black-and-white distorted checkerboard with a
     296     * zoom ratio twice the one in test #3.
     297     */
     298    if (!data->shader[2])
     299        data->shader[2] = Shader::Create(
     300            "#version 110\n"
     301            "void main()"
     302            "{"
     303            "    gl_TexCoord[0] = gl_MultiTexCoord0;"
     304            "    gl_Position = gl_Vertex;"
     305            "}",
     306
     307            "#version 110\n"
     308            "uniform sampler2D tex;"
     309            "void main()"
     310            "{"
     311            "    gl_FragColor = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
     312            "}");
     313    data->shader[2]->Bind();
     314    glColor3f(0.0f, 1.0f, 1.0f);
     315    glEnable(GL_TEXTURE_2D);
     316    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     317    glBegin(GL_TRIANGLES);
     318        glTexCoord2f(f1, f3);
     319        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     320        glTexCoord2f(f3, f2);
     321        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     322        glTexCoord2f(f2, f4);
     323        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     324
     325        glTexCoord2f(f2, f4);
     326        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     327        glTexCoord2f(f4, f1);
     328        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     329        glTexCoord2f(f1, f3);
     330        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     331    glEnd();
     332    glUseProgram(0);
     333    glDisable(GL_TEXTURE_2D);
     334
     335    Advance();
     336#endif
     337
     338    /*
     339     * Test #7: vertex buffer
     340     * Renders a multicolored square with varying colors.
     341     */
     342    GLfloat const vertices1[] = { data->aa.x, data->bb.y, 0.0f,
     343                                  data->bb.x, data->bb.y, 0.0f,
     344                                  data->bb.x, data->aa.y, 0.0f,
     345                                  data->bb.x, data->aa.y, 0.0f,
     346                                  data->aa.x, data->aa.y, 0.0f,
     347                                  data->aa.x, data->bb.y, 0.0f };
     348
     349    glEnableClientState(GL_COLOR_ARRAY);
     350    glEnableClientState(GL_VERTEX_ARRAY);
     351
     352    glColorPointer(3, GL_FLOAT, 0, colors);
     353    glVertexPointer(3, GL_FLOAT, 0, vertices1);
     354    glDrawArrays(GL_TRIANGLES, 0, 6);
     355
     356    glDisableClientState(GL_VERTEX_ARRAY);
     357    glDisableClientState(GL_COLOR_ARRAY);
     358    glUseProgram(0);
     359
     360    Advance();
     361
     362    /*
     363     * Test #8: vertex buffer + texture & color in 1.10 fragment shader
     364     * Renders a multicolored square with varying colors xored with an
     365     * animated distorted checkerboard.
     366     */
     367    if (!data->shader[3])
     368        data->shader[3] = Shader::Create(
     369            "#version 110\n"
     370            "varying vec4 pass_Color;"
     371            "void main()"
     372            "{"
     373            "    gl_TexCoord[0] = gl_MultiTexCoord0;"
     374            "    pass_Color = gl_Color;"
     375            "    gl_Position = gl_Vertex;"
     376            "}",
     377
     378            "#version 110\n"
     379            "varying vec4 pass_Color;"
     380            "uniform sampler2D tex;"
     381            "void main()"
     382            "{"
     383            "    vec4 tmp = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
     384            "    gl_FragColor = vec4(abs(tmp.xyz - pass_Color.xyz), 1.0);"
     385            "}");
     386
     387    data->shader[3]->Bind();
     388    GLfloat const vertices2[] = { data->aa.x, data->bb.y, 0.0f,
     389                                  data->bb.x, data->bb.y, 0.0f,
     390                                  data->bb.x, data->aa.y, 0.0f,
     391                                  data->bb.x, data->aa.y, 0.0f,
     392                                  data->aa.x, data->aa.y, 0.0f,
     393                                  data->aa.x, data->bb.y, 0.0f };
     394
     395    glEnableClientState(GL_VERTEX_ARRAY);
     396    glEnableClientState(GL_COLOR_ARRAY);
     397    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
     398
     399    glVertexPointer(3, GL_FLOAT, 0, vertices2);
     400    glColorPointer(3, GL_FLOAT, 0, colors);
     401    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
     402    glDrawArrays(GL_TRIANGLES, 0, 6);
     403
     404    glDisableClientState(GL_VERTEX_ARRAY);
     405    glDisableClientState(GL_COLOR_ARRAY);
     406    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     407    glUseProgram(0);
     408
     409    Advance();
     410
     411    /*
     412     * Test #8: vertex buffer + texture & color in 1.20 fragment shader
     413     * Renders a multicolored square with varying colors xored with an
     414     * animated distorted checkerboard.
     415     */
     416    if (!data->shader[4])
     417    {
     418        data->shader[4] = Shader::Create(
     419            "#version 120\n"
     420            "attribute vec3 in_Vertex;"
     421            "attribute vec3 in_Color;"
     422            "attribute vec2 in_MultiTexCoord0;"
     423            "varying vec4 pass_Color;"
     424            "void main()"
     425            "{"
     426            "    gl_TexCoord[0] = vec4(in_MultiTexCoord0, 0.0, 0.0);"
     427            "    pass_Color = vec4(in_Color, 1.0);"
     428            "    gl_Position = vec4(in_Vertex, 1.0);"
     429            "}",
     430
     431            "#version 120\n"
     432            "varying vec4 pass_Color;"
     433            "uniform sampler2D tex;"
     434            "void main()"
     435            "{"
     436            "    vec4 tmp = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
     437            "    gl_FragColor = vec4(abs(tmp.xyz - pass_Color.xyz), 1.0);"
     438            "}");
     439        data->attr[0] = data->shader[4]->GetAttribLocation("in_Vertex");
     440        data->attr[1] = data->shader[4]->GetAttribLocation("in_Color");
     441        data->attr[2] = data->shader[4]->GetAttribLocation("in_MultiTexCoord0");
     442    }
     443    data->shader[4]->Bind();
     444    GLfloat const vertices3[] = { data->aa.x, data->bb.y, 0.0f,
     445                                  data->bb.x, data->bb.y, 0.0f,
     446                                  data->bb.x, data->aa.y, 0.0f,
     447                                  data->bb.x, data->aa.y, 0.0f,
     448                                  data->aa.x, data->aa.y, 0.0f,
     449                                  data->aa.x, data->bb.y, 0.0f };
     450
     451    glBindVertexArray(data->array[0]);
     452
     453    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[0]);
     454    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices3), vertices3,
     455                 GL_DYNAMIC_DRAW);
     456    glVertexAttribPointer(data->attr[0], 3, GL_FLOAT, GL_FALSE, 0, 0);
     457    glEnableVertexAttribArray(data->attr[0]);
     458
     459    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[1]);
     460    glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors,
     461                 GL_DYNAMIC_DRAW);
     462    glVertexAttribPointer(data->attr[1], 3, GL_FLOAT, GL_FALSE, 0, 0);
     463    glEnableVertexAttribArray(data->attr[1]);
     464
     465    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[2]);
     466    glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
     467                 GL_DYNAMIC_DRAW);
     468    glVertexAttribPointer(data->attr[2], 2, GL_FLOAT, GL_FALSE, 0, 0);
     469    glEnableVertexAttribArray(data->attr[2]);
     470
     471    glDrawArrays(GL_TRIANGLES, 0, 6);
     472    glBindVertexArray(0);
     473
     474    glDisableVertexAttribArray(data->attr[0]);
     475    glDisableVertexAttribArray(data->attr[1]);
     476    glDisableVertexAttribArray(data->attr[2]);
     477    glUseProgram(0);
     478
     479    Advance();
     480
     481    /*
     482     * Test #8: vertex buffer + texture & color in 1.30 fragment shader
     483     * Renders a multicolored square with varying colors xored with an
     484     * animated distorted checkerboard.
     485     */
     486    if (!data->shader[5])
     487    {
     488        data->shader[5] = Shader::Create(
     489            "#version 130\n"
     490            "in vec3 in_Vertex;"
     491            "in vec3 in_Color;"
     492            "in vec2 in_MultiTexCoord0;"
     493            "out vec4 pass_Color;"
     494            "void main()"
     495            "{"
     496            "    gl_TexCoord[0] = vec4(in_MultiTexCoord0, 0.0, 0.0);"
     497            "    pass_Color = vec4(in_Color, 1.0);"
     498            "    gl_Position = vec4(in_Vertex, 1.0);"
     499            "}",
     500
     501            "#version 130\n"
     502            "in vec4 pass_Color;"
     503            "uniform sampler2D tex;"
     504            "void main()"
     505            "{"
     506            "    vec4 tmp = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
     507            "    gl_FragColor = vec4(abs(tmp.xyz - pass_Color.xyz), 1.0);"
     508            "}");
     509        data->attr[3] = data->shader[4]->GetAttribLocation("in_Vertex");
     510        data->attr[4] = data->shader[4]->GetAttribLocation("in_Color");
     511        data->attr[5] = data->shader[4]->GetAttribLocation("in_MultiTexCoord0");
     512    }
     513    data->shader[5]->Bind();
     514    GLfloat const vertices4[] = { data->aa.x, data->bb.y, 0.0f,
     515                                  data->bb.x, data->bb.y, 0.0f,
     516                                  data->bb.x, data->aa.y, 0.0f,
     517                                  data->bb.x, data->aa.y, 0.0f,
     518                                  data->aa.x, data->aa.y, 0.0f,
     519                                  data->aa.x, data->bb.y, 0.0f };
     520
     521    glBindVertexArray(data->array[1]);
     522
     523    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[3]);
     524    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices4), vertices4,
     525                 GL_DYNAMIC_DRAW);
     526    glVertexAttribPointer(data->attr[3], 3, GL_FLOAT, GL_FALSE, 0, 0);
     527    glEnableVertexAttribArray(data->attr[3]);
     528
     529    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[4]);
     530    glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors,
     531                 GL_DYNAMIC_DRAW);
     532    glVertexAttribPointer(data->attr[4], 3, GL_FLOAT, GL_FALSE, 0, 0);
     533    glEnableVertexAttribArray(data->attr[4]);
     534
     535    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[5]);
     536    glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
     537                 GL_DYNAMIC_DRAW);
     538    glVertexAttribPointer(data->attr[5], 2, GL_FLOAT, GL_FALSE, 0, 0);
     539    glEnableVertexAttribArray(data->attr[5]);
     540
     541    glDrawArrays(GL_TRIANGLES, 0, 6);
     542    glBindVertexArray(0);
     543
     544    glDisableVertexAttribArray(data->attr[3]);
     545    glDisableVertexAttribArray(data->attr[4]);
     546    glDisableVertexAttribArray(data->attr[5]);
     547    glUseProgram(0);
     548
     549    Advance();
     550}
     551
     552void DebugQuad::Advance()
     553{
     554    data->aa.x += 3.0f * data->step.x;
     555    data->bb.x += 3.0f * data->step.x;
     556    if (data->bb.x > 1.0f)
     557    {
     558        data->aa.x = data->orig.x;
     559        data->bb.x = data->orig.x + 2.0f * data->step.x;
     560        data->aa.y += 3.0f * data->step.y;
     561        data->bb.y += 3.0f * data->step.y;
     562    }
     563}
     564
     565DebugQuad::~DebugQuad()
     566{
     567    delete data;
     568}
     569
     570} /* namespace lol */
     571}}}