Changeset 803


Ignore:
Timestamp:
Aug 8, 2011, 11:55:39 AM (8 years ago)
Author:
sam
Message:

debug: some code cleanup in the quad tests.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/debug/quad.cpp

    r783 r803  
    2929 */
    3030
    31 #define NUM_ARRAYS 2
    32 #define NUM_BUFFERS 6
    33 #define NUM_ATTRS 6
    34 #define NUM_SHADERS 6
    35 #define NUM_TEXTURES 1
     31static int const NUM_ARRAYS = 2;
     32static int const NUM_BUFFERS = 6;
     33static int const NUM_ATTRS = 6;
     34static int const NUM_SHADERS = 6;
     35static int const NUM_TEXTURES = 1;
     36
     37static int const TEX_SIZE = 32;
    3638
    3739class DebugQuadData
     
    4951    GLuint attr[NUM_ATTRS];
    5052    GLuint texture[NUM_TEXTURES];
    51     uint8_t image[1][32 * 32 * 4];
     53    uint8_t image[1][TEX_SIZE * TEX_SIZE * 4];
    5254};
    5355
     
    8082        glGenVertexArrays(NUM_ARRAYS, data->array);
    8183        glGenBuffers(NUM_BUFFERS, data->buffer);
    82 #if 0
    83 
    84         static char const *vertexshader =
    85             "//#version 130\n"
    86             "varying vec2 in_Position;\n"
    87             "varying vec4 in_Color;\n"
    88             "varying vec2 in_TexCoord;\n"
    89             "varying vec4 pass_Color;\n"
    90             "void main()\n"
    91             "{\n"
    92             "gl_TexCoord[0] = gl_MultiTexCoord0;\n"
    93             "    gl_Position = vec4(in_Position, 0.0f, 1.0f);\n"
    94             "    gl_TexCoord[0] = vec4(in_TexCoord, 0.0, 0.0);\n"
    95             "    pass_Color = in_Color;\n"
    96             "}\n";
    97         static char const *fragmentshader =
    98             "//#version 130\n"
    99             "varying vec4 pass_Color;\n"
    100             "uniform sampler2D in_Texture;\n"
    101             "void main()\n"
    102             "{\n"
    103             "    vec4 col = pass_Color;\n"
    104             "    vec4 tex = texture2D(in_Texture, vec2(gl_TexCoord[0]));\n"
    105             "    gl_FragColor = col * tex;\n"
    106             "    gl_FragColor = vec4(1.0, 1.0, 1.0, 0.0);\n"
    107             "}\n";
    108         data->shader[0] = Shader::Create(vertexshader, fragmentshader);
    109         glGenTextures(1, data->texture);
    110 #endif
     84        glGenTextures(NUM_TEXTURES, data->texture);
     85        for (int i = 0; i < NUM_SHADERS; i++)
     86            data->shader[i] = NULL;
    11187
    11288        /* Checkerboard texture */
    11389        glEnable(GL_TEXTURE_2D);
    11490        glBindTexture(GL_TEXTURE_2D, data->texture[0]);
    115         for (int j = 0; j < 32; j++)
    116             for (int i = 0; i < 32; i++)
     91        for (int j = 0; j < TEX_SIZE; j++)
     92            for (int i = 0; i < TEX_SIZE; i++)
    11793            {
    11894                uint8_t wb = (((i / 2) ^ (j / 2)) & 1) * 0xff;
    119                 data->image[0][(j * 32 + i) * 4 + 0] = wb;
    120                 data->image[0][(j * 32 + i) * 4 + 1] = wb;
    121                 data->image[0][(j * 32 + i) * 4 + 2] = wb;
    122                 data->image[0][(j * 32 + i) * 4 + 3] = 0xff;
     95                data->image[0][(j * TEX_SIZE + i) * 4 + 0] = wb;
     96                data->image[0][(j * TEX_SIZE + i) * 4 + 1] = wb;
     97                data->image[0][(j * TEX_SIZE + i) * 4 + 2] = wb;
     98                data->image[0][(j * TEX_SIZE + i) * 4 + 3] = 0xff;
    12399            }
    124100        /* Use GL_RGBA instead of 4 for the internal format (Android) */
    125         glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0,
     101        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 0,
    126102                     GL_RGBA, GL_UNSIGNED_BYTE, data->image[0]);
    127103        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    128104        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
    129105
    130         /* Quad #4: create texture in 1.10 fragment shader */
     106        data->initialised = 1;
     107    }
     108    else if (data->initialised && IsDestroying())
     109    {
     110        glDeleteVertexArrays(NUM_ARRAYS, data->array);
     111        glDeleteBuffers(NUM_BUFFERS, data->buffer);
     112        glDeleteTextures(NUM_TEXTURES, data->texture);
     113
     114        for (int i = 0; i < NUM_SHADERS; i++)
     115            if (data->shader[i])
     116                Shader::Destroy(data->shader[i]);
     117
     118        data->initialised = 0;
     119    }
     120
     121    /* Reset GL states to something reasonably safe */
     122    glMatrixMode(GL_PROJECTION);
     123    glLoadIdentity();
     124    glMatrixMode(GL_MODELVIEW);
     125    glLoadIdentity();
     126    glDisable(GL_TEXTURE_2D);
     127    glBindBuffer(GL_ARRAY_BUFFER, 0);
     128    glUseProgram(0);
     129
     130    /* Prepare our quad coordinates */
     131    vec2i const layout(4, 3);
     132    data->step = vec2(2.0f, -2.0f) / (3 * layout + vec2i(1));
     133    data->orig = vec2(-1.0f, 1.0f) + data->step;
     134    data->aa = data->orig;
     135    data->bb = data->orig + 2.0f * data->step;
     136
     137    /* Generate a few random numbers */
     138    float f1 = 0.5f + 0.5f * sinf(0.00034f * data->time);
     139    float f2 = 0.5f + 0.5f * sinf(0.00053f * data->time + 1.0f);
     140    float f3 = 0.5f + 0.5f * sinf(0.00072f * data->time + 4.0f);
     141    float f4 = 0.5f + 0.5f * sinf(0.00091f * data->time + 8.0f);
     142
     143    GLfloat const colors[] = { f1, f2, f3, f4, f2, f1, f3, f1, f4,
     144                               f3, f1, f4, f4, f3, f2, f1, f2, f3 };
     145    GLfloat const texcoords[] = { f1, f3, f3, f2, f2, f4,
     146                                  f2, f4, f4, f1, f1, f3 };
     147
     148#if defined HAVE_GLBEGIN || defined USE_GLEW
     149    /*
     150     * Test #1: simple glBegin code
     151     * Renders an orange square.
     152     */
     153    glColor3f(0.8f, 0.5f, 0.2f);
     154    glBegin(GL_TRIANGLES);
     155        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     156        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     157        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     158
     159        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     160        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     161        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     162    glEnd();
     163
     164    Advance();
     165
     166    /*
     167     * Test #2: glBegin + per-vertex coloring
     168     * Renders a multicolored square with varying colors.
     169     */
     170    glBegin(GL_TRIANGLES);
     171        glColor3f(f1, f2, f3);
     172        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     173        glColor3f(f4, f2, f1);
     174        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     175        glColor3f(f3, f1, f4);
     176        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     177
     178        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     179        glColor3f(f4, f3, f2);
     180        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     181        glColor3f(f1, f2, f3);
     182        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     183    glEnd();
     184
     185    Advance();
     186
     187    /*
     188     * Test #3: glBegin + texture
     189     * Renders an animated black-and-white distorted checkerboard.
     190     */
     191    glEnable(GL_TEXTURE_2D);
     192    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     193    glColor3f(1.0f, 1.0f, 1.0f);
     194    glBegin(GL_TRIANGLES);
     195        glTexCoord2f(f1, f3);
     196        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     197        glTexCoord2f(f3, f2);
     198        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     199        glTexCoord2f(f2, f4);
     200        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     201
     202        glTexCoord2f(f2, f4);
     203        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     204        glTexCoord2f(f4, f1);
     205        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     206        glTexCoord2f(f1, f3);
     207        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     208    glEnd();
     209    glDisable(GL_TEXTURE_2D);
     210
     211    Advance();
     212
     213    /*
     214     * Test #4: glBegin + color in fragment shader
     215     * Renders a static, coloured and tiled pattern.
     216     */
     217    if (!data->shader[0])
    131218        data->shader[0] = Shader::Create(
    132219            "#version 110\n"
     
    144231            "    gl_FragColor = vec4(dx, dy, dz, 1.0);"
    145232            "}");
    146 
    147         /* Quad #5: pass color from 1.10 vertex shader to fragment shader */
     233    data->shader[0]->Bind();
     234    glColor3f(0.0f, 1.0f, 1.0f);
     235    glBegin(GL_TRIANGLES);
     236        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     237        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     238        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     239
     240        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     241        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     242        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     243    glEnd();
     244    glUseProgram(0);
     245
     246    Advance();
     247
     248    /*
     249     * Test #5: glBegin + pass color from vertex shader to fragment shader
     250     * Renders a multicolored square with varying colors.
     251     */
     252    if (!data->shader[1])
    148253        data->shader[1] = Shader::Create(
    149254            "#version 110\n"
     
    163268            "    gl_FragColor = pass_Color;"
    164269            "}");
    165 
    166         /* Quad #6: apply texture in 1.10 fragment shader */
     270    data->shader[1]->Bind();
     271    glColor3f(0.0f, 1.0f, 1.0f);
     272    glBegin(GL_TRIANGLES);
     273        glTexCoord2f(f1, f3);
     274        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     275        glTexCoord2f(f3, f2);
     276        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     277        glTexCoord2f(f2, f4);
     278        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     279
     280        glTexCoord2f(f2, f4);
     281        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     282        glTexCoord2f(f4, f1);
     283        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     284        glTexCoord2f(f1, f3);
     285        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     286    glEnd();
     287    glUseProgram(0);
     288
     289    Advance();
     290
     291    /*
     292     * Test #6: glBegin + apply texture in fragment shader
     293     * Renders an animated black-and-white distorted checkerboard with a
     294     * zoom ratio twice the one in test #3.
     295     */
     296    if (!data->shader[2])
    167297        data->shader[2] = Shader::Create(
    168298            "#version 110\n"
     
    179309            "    gl_FragColor = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
    180310            "}");
    181 
    182         /* Quad #8: vertex buffer, apply texture in 1.10 fragment shader */
     311    data->shader[2]->Bind();
     312    glColor3f(0.0f, 1.0f, 1.0f);
     313    glEnable(GL_TEXTURE_2D);
     314    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
     315    glBegin(GL_TRIANGLES);
     316        glTexCoord2f(f1, f3);
     317        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     318        glTexCoord2f(f3, f2);
     319        glVertex3f(data->bb.x, data->bb.y, 0.0f);
     320        glTexCoord2f(f2, f4);
     321        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     322
     323        glTexCoord2f(f2, f4);
     324        glVertex3f(data->bb.x, data->aa.y, 0.0f);
     325        glTexCoord2f(f4, f1);
     326        glVertex3f(data->aa.x, data->aa.y, 0.0f);
     327        glTexCoord2f(f1, f3);
     328        glVertex3f(data->aa.x, data->bb.y, 0.0f);
     329    glEnd();
     330    glUseProgram(0);
     331    glDisable(GL_TEXTURE_2D);
     332
     333    Advance();
     334#endif
     335
     336    /*
     337     * Test #7: vertex buffer
     338     * Renders a multicolored square with varying colors.
     339     */
     340    GLfloat const vertices1[] = { data->aa.x, data->bb.y, 0.0f,
     341                                  data->bb.x, data->bb.y, 0.0f,
     342                                  data->bb.x, data->aa.y, 0.0f,
     343                                  data->bb.x, data->aa.y, 0.0f,
     344                                  data->aa.x, data->aa.y, 0.0f,
     345                                  data->aa.x, data->bb.y, 0.0f };
     346
     347    glEnableClientState(GL_COLOR_ARRAY);
     348    glEnableClientState(GL_VERTEX_ARRAY);
     349
     350    glColorPointer(3, GL_FLOAT, 0, colors);
     351    glVertexPointer(3, GL_FLOAT, 0, vertices1);
     352    glDrawArrays(GL_TRIANGLES, 0, 6);
     353
     354    glDisableClientState(GL_VERTEX_ARRAY);
     355    glDisableClientState(GL_COLOR_ARRAY);
     356    glUseProgram(0);
     357
     358    Advance();
     359
     360    /*
     361     * Test #8: vertex buffer + texture & color in 1.10 fragment shader
     362     * Renders a multicolored square with varying colors xored with an
     363     * animated distorted checkerboard.
     364     */
     365    if (!data->shader[3])
    183366        data->shader[3] = Shader::Create(
    184367            "#version 110\n"
     
    200383            "}");
    201384
    202         /* Quad #9: vertex buffer, apply texture and color in 1.20 shader */
     385    data->shader[3]->Bind();
     386    GLfloat const vertices2[] = { data->aa.x, data->bb.y, 0.0f,
     387                                  data->bb.x, data->bb.y, 0.0f,
     388                                  data->bb.x, data->aa.y, 0.0f,
     389                                  data->bb.x, data->aa.y, 0.0f,
     390                                  data->aa.x, data->aa.y, 0.0f,
     391                                  data->aa.x, data->bb.y, 0.0f };
     392
     393    glEnableClientState(GL_VERTEX_ARRAY);
     394    glEnableClientState(GL_COLOR_ARRAY);
     395    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
     396
     397    glVertexPointer(3, GL_FLOAT, 0, vertices2);
     398    glColorPointer(3, GL_FLOAT, 0, colors);
     399    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
     400    glDrawArrays(GL_TRIANGLES, 0, 6);
     401
     402    glDisableClientState(GL_VERTEX_ARRAY);
     403    glDisableClientState(GL_COLOR_ARRAY);
     404    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
     405    glUseProgram(0);
     406
     407    Advance();
     408
     409    /*
     410     * Test #8: vertex buffer + texture & color in 1.20 fragment shader
     411     * Renders a multicolored square with varying colors xored with an
     412     * animated distorted checkerboard.
     413     */
     414    if (!data->shader[4])
     415    {
    203416        data->shader[4] = Shader::Create(
    204417            "#version 120\n"
     
    225438        data->attr[1] = data->shader[4]->GetAttribLocation("in_Color");
    226439        data->attr[2] = data->shader[4]->GetAttribLocation("in_MultiTexCoord0");
    227 
    228         /* Quad #10: vertex buffer, apply texture and color in 1.30 shader */
     440    }
     441    data->shader[4]->Bind();
     442    GLfloat const vertices3[] = { data->aa.x, data->bb.y, 0.0f,
     443                                  data->bb.x, data->bb.y, 0.0f,
     444                                  data->bb.x, data->aa.y, 0.0f,
     445                                  data->bb.x, data->aa.y, 0.0f,
     446                                  data->aa.x, data->aa.y, 0.0f,
     447                                  data->aa.x, data->bb.y, 0.0f };
     448
     449    glBindVertexArray(data->array[0]);
     450
     451    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[0]);
     452    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices3), vertices3,
     453                 GL_DYNAMIC_DRAW);
     454    glVertexAttribPointer(data->attr[0], 3, GL_FLOAT, GL_FALSE, 0, 0);
     455    glEnableVertexAttribArray(data->attr[0]);
     456
     457    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[1]);
     458    glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors,
     459                 GL_DYNAMIC_DRAW);
     460    glVertexAttribPointer(data->attr[1], 3, GL_FLOAT, GL_FALSE, 0, 0);
     461    glEnableVertexAttribArray(data->attr[1]);
     462
     463    glBindBuffer(GL_ARRAY_BUFFER, data->buffer[2]);
     464    glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
     465                 GL_DYNAMIC_DRAW);
     466    glVertexAttribPointer(data->attr[2], 2, GL_FLOAT, GL_FALSE, 0, 0);
     467    glEnableVertexAttribArray(data->attr[2]);
     468
     469    glDrawArrays(GL_TRIANGLES, 0, 6);
     470    glBindVertexArray(0);
     471
     472    glDisableVertexAttribArray(data->attr[0]);
     473    glDisableVertexAttribArray(data->attr[1]);
     474    glDisableVertexAttribArray(data->attr[2]);
     475    glUseProgram(0);
     476
     477    Advance();
     478
     479    /*
     480     * Test #8: vertex buffer + texture & color in 1.30 fragment shader
     481     * Renders a multicolored square with varying colors xored with an
     482     * animated distorted checkerboard.
     483     */
     484    if (!data->shader[5])
     485    {
    229486        data->shader[5] = Shader::Create(
    230487            "#version 130\n"
     
    251508        data->attr[4] = data->shader[4]->GetAttribLocation("in_Color");
    252509        data->attr[5] = data->shader[4]->GetAttribLocation("in_MultiTexCoord0");
    253 
    254         data->initialised = 1;
    255510    }
    256     else if (data->initialised && IsDestroying())
    257     {
    258         glDeleteVertexArrays(NUM_ARRAYS, data->array);
    259         glDeleteBuffers(NUM_BUFFERS, data->buffer);
    260         Shader::Destroy(data->shader[0]);
    261         Shader::Destroy(data->shader[1]);
    262         Shader::Destroy(data->shader[2]);
    263         Shader::Destroy(data->shader[3]);
    264         glDeleteTextures(NUM_TEXTURES, data->texture);
    265 
    266         data->initialised = 0;
    267     }
    268 
    269 #if 0
    270     float const st = sinf(0.0005f * data->time);
    271     float const ct = cosf(0.0005f * data->time);
    272 
    273     GLfloat const verts[6][2] =
    274     {
    275         { -0.7f * (st + ct),  0.7f * (st - ct) },
    276         {  0.7f * (st - ct),  0.7f * (st + ct) },
    277         { -0.7f * (st - ct), -0.7f * (st + ct) },
    278 
    279         { -0.7f * (st - ct), -0.7f * (st + ct) },
    280         {  0.7f * (st - ct),  0.7f * (st + ct) },
    281         {  0.7f * (st + ct), -0.7f * (st - ct) },
    282     };
    283 
    284     /* Using only 3 components breaks on Android for some reason. */
    285     static GLfloat const cols[6][4] =
    286     {
    287         { 1.0f, 0.2f, 0.2f, 1.0f },
    288         { 0.2f, 0.2f, 1.0f, 1.0f },
    289         { 1.0f, 1.0f, 0.2f, 1.0f },
    290 
    291         { 1.0f, 1.0f, 0.2f, 1.0f },
    292         { 0.2f, 0.2f, 1.0f, 1.0f },
    293         { 0.2f, 1.0f, 0.2f, 1.0f },
    294     };
    295 
    296     static GLfloat const tcs[6][2] =
    297     {
    298         { 0.0f, 1.0f }, { 1.0f, 1.0f }, { 0.0f, 0.0f },
    299         { 0.0f, 0.0f }, { 1.0f, 1.0f }, { 1.0f, 0.0f },
    300     };
    301 
    302 #if defined __CELLOS_LV2__
    303     glEnableClientState(GL_VERTEX_ARRAY);
    304     glEnableClientState(GL_COLOR_ARRAY);
    305     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    306 
    307     glActiveTexture(GL_TEXTURE0);
    308     glBindTexture(GL_TEXTURE_2D, data->texture[0]);
    309 
    310     glBindBuffer(GL_ARRAY_BUFFER, data->buflist[0]);
    311     glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), verts, GL_STATIC_DRAW);
    312     glVertexPointer(2, GL_FLOAT, GL_FALSE, 0);
    313 
    314     glBindBuffer(GL_ARRAY_BUFFER, data->buflist[1]);
    315     glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), cols, GL_STATIC_DRAW);
    316     glColorPointer(4, GL_FLOAT, GL_FALSE, 0);
    317 
    318     glBindBuffer(GL_ARRAY_BUFFER, data->buflist[2]);
    319     glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), tcs, GL_STATIC_DRAW);
    320     glTexCoordPointer(2, GL_FLOAT, GL_FALSE, 0);
    321 
    322     glDrawArrays(GL_TRIANGLES, 0, 6);
    323 
    324     glDisableClientState(GL_VERTEX_ARRAY);
    325     glDisableClientState(GL_COLOR_ARRAY);
    326     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    327 #else
    328     data->shader[0]->Bind();
    329     GLuint attr_pos, attr_col, attr_tex;
    330     attr_pos = data->shader[0]->GetAttribLocation("in_Position");
    331     attr_col = data->shader[0]->GetAttribLocation("in_Color");
    332     attr_tex = data->shader[0]->GetAttribLocation("in_TexCoord");
    333 
    334     glEnableVertexAttribArray(attr_pos);
    335     glEnableVertexAttribArray(attr_col);
    336     glEnableVertexAttribArray(attr_tex);
    337 
    338     /* Bind texture */
    339     glActiveTexture(GL_TEXTURE0);
    340     glBindTexture(GL_TEXTURE_2D, data->texture[0]);
    341 
    342     glBindBuffer(GL_ARRAY_BUFFER, data->buflist[0]);
    343     glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), verts, GL_STATIC_DRAW);
    344     glVertexAttribPointer(attr_pos, 2, GL_FLOAT, GL_FALSE, 0, 0);
    345 
    346     glBindBuffer(GL_ARRAY_BUFFER, data->buflist[1]);
    347     glBufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), cols, GL_STATIC_DRAW);
    348     glVertexAttribPointer(attr_col, 4, GL_FLOAT, GL_FALSE, 0, 0);
    349 
    350     glBindBuffer(GL_ARRAY_BUFFER, data->buflist[2]);
    351     glBufferData(GL_ARRAY_BUFFER, 12 * sizeof(GLfloat), tcs, GL_STATIC_DRAW);
    352     glVertexAttribPointer(attr_tex, 2, GL_FLOAT, GL_FALSE, 0, 0);
    353 
    354     glBindBuffer(GL_ARRAY_BUFFER, 0);
    355 
    356     glDrawArrays(GL_TRIANGLES, 0, 6);
    357 
    358     glDisableVertexAttribArray(attr_pos);
    359     glDisableVertexAttribArray(attr_col);
    360     glDisableVertexAttribArray(attr_tex);
    361 #endif
    362 #endif
    363 
    364     /* Reset GL states */
    365     glMatrixMode(GL_PROJECTION);
    366     glLoadIdentity();
    367     glMatrixMode(GL_MODELVIEW);
    368     glLoadIdentity();
    369     glDisable(GL_TEXTURE_2D);
    370     glBindBuffer(GL_ARRAY_BUFFER, 0);
    371     glUseProgram(0);
    372 
    373     /* Prepare our quad coordinates */
    374     vec2i const layout(4, 3);
    375     data->step = vec2(2.0f, -2.0f) / (3 * layout + vec2i(1));
    376     data->orig = vec2(-1.0f, 1.0f) + data->step;
    377     data->aa = data->orig;
    378     data->bb = data->orig + 2.0f * data->step;
    379 
    380     /* Generate a few random numbers */
    381     float f1 = 0.5f + 0.5f * sinf(0.00034f * data->time);
    382     float f2 = 0.5f + 0.5f * sinf(0.00053f * data->time + 1.0f);
    383     float f3 = 0.5f + 0.5f * sinf(0.00072f * data->time + 4.0f);
    384     float f4 = 0.5f + 0.5f * sinf(0.00091f * data->time + 8.0f);
    385 
    386     GLfloat const colors[] = { f1, f2, f3, f4, f2, f1, f3, f1, f4,
    387                                f3, f1, f4, f4, f3, f2, f1, f2, f3 };
    388     GLfloat const texcoords[] = { f1, f3, f3, f2, f2, f4,
    389                                   f2, f4, f4, f1, f1, f3 };
    390 
    391 #if defined HAVE_GLBEGIN
    392     /* Quad #1: simple glBegin program */
    393     glColor3f(0.8f, 0.5f, 0.2f);
    394     glBegin(GL_TRIANGLES);
    395         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    396         glVertex3f(data->bb.x, data->bb.y, 0.0f);
    397         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    398 
    399         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    400         glVertex3f(data->aa.x, data->aa.y, 0.0f);
    401         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    402     glEnd();
    403 
    404     Advance();
    405 
    406     /* Quad #2: glBegin program with varying color */
    407     glBegin(GL_TRIANGLES);
    408         glColor3f(f1, f2, f3);
    409         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    410         glColor3f(f4, f2, f1);
    411         glVertex3f(data->bb.x, data->bb.y, 0.0f);
    412         glColor3f(f3, f1, f4);
    413         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    414 
    415         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    416         glColor3f(f4, f3, f2);
    417         glVertex3f(data->aa.x, data->aa.y, 0.0f);
    418         glColor3f(f1, f2, f3);
    419         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    420     glEnd();
    421 
    422     Advance();
    423 
    424     /* Quad #3: textured quad */
    425     glEnable(GL_TEXTURE_2D);
    426     glBindTexture(GL_TEXTURE_2D, data->texture[0]);
    427     glColor3f(1.0f, 1.0f, 1.0f);
    428     glBegin(GL_TRIANGLES);
    429         glTexCoord2f(f1, f3);
    430         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    431         glTexCoord2f(f3, f2);
    432         glVertex3f(data->bb.x, data->bb.y, 0.0f);
    433         glTexCoord2f(f2, f4);
    434         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    435 
    436         glTexCoord2f(f2, f4);
    437         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    438         glTexCoord2f(f4, f1);
    439         glVertex3f(data->aa.x, data->aa.y, 0.0f);
    440         glTexCoord2f(f1, f3);
    441         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    442     glEnd();
    443     glDisable(GL_TEXTURE_2D);
    444 
    445     Advance();
    446 
    447     /* Quad #4: set color in fragment shader */
    448     data->shader[0]->Bind();
    449     glColor3f(0.0f, 1.0f, 1.0f);
    450     glBegin(GL_TRIANGLES);
    451         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    452         glVertex3f(data->bb.x, data->bb.y, 0.0f);
    453         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    454 
    455         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    456         glVertex3f(data->aa.x, data->aa.y, 0.0f);
    457         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    458     glEnd();
    459     glUseProgram(0);
    460 
    461     Advance();
    462 
    463     /* Quad #5: pass color from vertex shader to fragment shader */
    464     data->shader[1]->Bind();
    465     glColor3f(0.0f, 1.0f, 1.0f);
    466     glBegin(GL_TRIANGLES);
    467         glTexCoord2f(f1, f3);
    468         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    469         glTexCoord2f(f3, f2);
    470         glVertex3f(data->bb.x, data->bb.y, 0.0f);
    471         glTexCoord2f(f2, f4);
    472         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    473 
    474         glTexCoord2f(f2, f4);
    475         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    476         glTexCoord2f(f4, f1);
    477         glVertex3f(data->aa.x, data->aa.y, 0.0f);
    478         glTexCoord2f(f1, f3);
    479         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    480     glEnd();
    481     glUseProgram(0);
    482 
    483     Advance();
    484 
    485     /* Quad #6: apply texture in fragment shader */
    486     data->shader[2]->Bind();
    487     glColor3f(0.0f, 1.0f, 1.0f);
    488     glEnable(GL_TEXTURE_2D);
    489     glBindTexture(GL_TEXTURE_2D, data->texture[0]);
    490     glBegin(GL_TRIANGLES);
    491         glTexCoord2f(f1, f3);
    492         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    493         glTexCoord2f(f3, f2);
    494         glVertex3f(data->bb.x, data->bb.y, 0.0f);
    495         glTexCoord2f(f2, f4);
    496         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    497 
    498         glTexCoord2f(f2, f4);
    499         glVertex3f(data->bb.x, data->aa.y, 0.0f);
    500         glTexCoord2f(f4, f1);
    501         glVertex3f(data->aa.x, data->aa.y, 0.0f);
    502         glTexCoord2f(f1, f3);
    503         glVertex3f(data->aa.x, data->bb.y, 0.0f);
    504     glEnd();
    505     glUseProgram(0);
    506     glDisable(GL_TEXTURE_2D);
    507 
    508     Advance();
    509 #endif
    510 
    511     /* Quad #7: simple vertex buffer, no shader */
    512     GLfloat const vertices1[] = { data->aa.x, data->bb.y, 0.0f,
    513                                   data->bb.x, data->bb.y, 0.0f,
    514                                   data->bb.x, data->aa.y, 0.0f,
    515                                   data->bb.x, data->aa.y, 0.0f,
    516                                   data->aa.x, data->aa.y, 0.0f,
    517                                   data->aa.x, data->bb.y, 0.0f };
    518 
    519     glEnableClientState(GL_COLOR_ARRAY);
    520     glEnableClientState(GL_VERTEX_ARRAY);
    521 
    522     glColorPointer(3, GL_FLOAT, 0, colors);
    523     glVertexPointer(3, GL_FLOAT, 0, vertices1);
    524     glDrawArrays(GL_TRIANGLES, 0, 6);
    525 
    526     glDisableClientState(GL_VERTEX_ARRAY);
    527     glDisableClientState(GL_COLOR_ARRAY);
    528     glUseProgram(0);
    529 
    530     Advance();
    531 
    532     /* Quad #8: vertex buffer, apply texture and color in fragment shader */
    533     data->shader[3]->Bind();
    534     GLfloat const vertices2[] = { data->aa.x, data->bb.y, 0.0f,
    535                                   data->bb.x, data->bb.y, 0.0f,
    536                                   data->bb.x, data->aa.y, 0.0f,
    537                                   data->bb.x, data->aa.y, 0.0f,
    538                                   data->aa.x, data->aa.y, 0.0f,
    539                                   data->aa.x, data->bb.y, 0.0f };
    540 
    541     glEnableClientState(GL_VERTEX_ARRAY);
    542     glEnableClientState(GL_COLOR_ARRAY);
    543     glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    544 
    545     glVertexPointer(3, GL_FLOAT, 0, vertices2);
    546     glColorPointer(3, GL_FLOAT, 0, colors);
    547     glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
    548     glDrawArrays(GL_TRIANGLES, 0, 6);
    549 
    550     glDisableClientState(GL_VERTEX_ARRAY);
    551     glDisableClientState(GL_COLOR_ARRAY);
    552     glDisableClientState(GL_TEXTURE_COORD_ARRAY);
    553     glUseProgram(0);
    554 
    555     Advance();
    556 
    557     /* Quad #9: vertex buffer, apply texture and color in 1.20 shader */
    558     data->shader[4]->Bind();
    559     GLfloat const vertices3[] = { data->aa.x, data->bb.y, 0.0f,
    560                                   data->bb.x, data->bb.y, 0.0f,
    561                                   data->bb.x, data->aa.y, 0.0f,
    562                                   data->bb.x, data->aa.y, 0.0f,
    563                                   data->aa.x, data->aa.y, 0.0f,
    564                                   data->aa.x, data->bb.y, 0.0f };
    565 
    566     glBindVertexArray(data->array[0]);
    567 
    568     glBindBuffer(GL_ARRAY_BUFFER, data->buffer[0]);
    569     glBufferData(GL_ARRAY_BUFFER, sizeof(vertices3), vertices3,
    570                  GL_DYNAMIC_DRAW);
    571     glVertexAttribPointer(data->attr[0], 3, GL_FLOAT, GL_FALSE, 0, 0);
    572     glEnableVertexAttribArray(data->attr[0]);
    573 
    574     glBindBuffer(GL_ARRAY_BUFFER, data->buffer[1]);
    575     glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors,
    576                  GL_DYNAMIC_DRAW);
    577     glVertexAttribPointer(data->attr[1], 3, GL_FLOAT, GL_FALSE, 0, 0);
    578     glEnableVertexAttribArray(data->attr[1]);
    579 
    580     glBindBuffer(GL_ARRAY_BUFFER, data->buffer[2]);
    581     glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
    582                  GL_DYNAMIC_DRAW);
    583     glVertexAttribPointer(data->attr[2], 2, GL_FLOAT, GL_FALSE, 0, 0);
    584     glEnableVertexAttribArray(data->attr[2]);
    585 
    586     glDrawArrays(GL_TRIANGLES, 0, 6);
    587     glBindVertexArray(0);
    588 
    589     glDisableVertexAttribArray(data->attr[0]);
    590     glDisableVertexAttribArray(data->attr[1]);
    591     glDisableVertexAttribArray(data->attr[2]);
    592     glUseProgram(0);
    593 
    594     Advance();
    595 
    596     /* Quad #10: vertex buffer, apply texture and color in 1.30 shader */
    597511    data->shader[5]->Bind();
    598512    GLfloat const vertices4[] = { data->aa.x, data->bb.y, 0.0f,
Note: See TracChangeset for help on using the changeset viewer.