source: trunk/src/debug/quad.cpp @ 822

Last change on this file since 822 was 822, checked in by sam, 10 years ago

debug: refactor quad test.

  • Property svn:keywords set to Id
File size: 21.6 KB
Line 
1//
2// Lol Engine
3//
4// Copyright: (c) 2010-2011 Sam Hocevar <sam@hocevar.net>
5//   This program is free software; you can redistribute it and/or
6//   modify it under the terms of the Do What The Fuck You Want To
7//   Public License, Version 2, as published by Sam Hocevar. See
8//   http://sam.zoy.org/projects/COPYING.WTFPL for more details.
9//
10
11#if defined HAVE_CONFIG_H
12#   include "config.h"
13#endif
14
15#include <cmath>
16#include <cstdio>
17
18#include "core.h"
19#include "lolgl.h"
20#include "loldebug.h"
21
22using namespace std;
23
24namespace lol
25{
26
27/*
28 * DebugQuad implementation class
29 */
30
31static int const NUM_ARRAYS = 2;
32static int const NUM_BUFFERS = 9;
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;
38
39class DebugQuadData
40{
41    friend class DebugQuad;
42
43private:
44    vec2 orig, step, aa, bb;
45
46    int initialised;
47    float time;
48#if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
49    GLuint array[NUM_ARRAYS];
50#endif
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#if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
85        glGenVertexArrays(NUM_ARRAYS, data->array);
86#endif
87        glGenBuffers(NUM_BUFFERS, data->buffer);
88        glGenTextures(NUM_TEXTURES, data->texture);
89        for (int i = 0; i < NUM_SHADERS; i++)
90            data->shader[i] = NULL;
91
92        /* Checkerboard texture */
93        glEnable(GL_TEXTURE_2D);
94        glBindTexture(GL_TEXTURE_2D, data->texture[0]);
95        for (int j = 0; j < TEX_SIZE; j++)
96            for (int i = 0; i < TEX_SIZE; i++)
97            {
98                uint8_t wb = (((i / 2) ^ (j / 2)) & 1) * 0xff;
99                data->image[0][(j * TEX_SIZE + i) * 4 + 0] = wb;
100                data->image[0][(j * TEX_SIZE + i) * 4 + 1] = wb;
101                data->image[0][(j * TEX_SIZE + i) * 4 + 2] = wb;
102                data->image[0][(j * TEX_SIZE + i) * 4 + 3] = 0xff;
103            }
104        /* Use GL_RGBA instead of 4 for the internal format (Android) */
105        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, TEX_SIZE, TEX_SIZE, 0,
106                     GL_RGBA, GL_UNSIGNED_BYTE, data->image[0]);
107        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
108        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
109
110        data->initialised = 1;
111    }
112    else if (data->initialised && IsDestroying())
113    {
114#if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
115        glDeleteVertexArrays(NUM_ARRAYS, data->array);
116#endif
117        glDeleteBuffers(NUM_BUFFERS, data->buffer);
118        glDeleteTextures(NUM_TEXTURES, data->texture);
119
120        for (int i = 0; i < NUM_SHADERS; i++)
121            if (data->shader[i])
122                Shader::Destroy(data->shader[i]);
123
124        data->initialised = 0;
125    }
126
127    /* Prepare our quad coordinates */
128    vec2i const layout(4, 3);
129    data->step = vec2(2.0f, -2.0f) / (3 * layout + vec2i(1));
130    data->orig = vec2(-1.0f, 1.0f) + data->step;
131    data->aa = data->orig;
132    data->bb = data->orig + 2.0f * data->step;
133
134    /* Generate a few random numbers */
135    float f1 = 0.5f + 0.5f * sinf(0.00034f * data->time);
136    float f2 = 0.5f + 0.5f * sinf(0.00053f * data->time + 1.0f);
137    float f3 = 0.5f + 0.5f * sinf(0.00072f * data->time + 4.0f);
138    float f4 = 0.5f + 0.5f * sinf(0.00091f * data->time + 8.0f);
139
140    GLfloat const colors[] = { f1, f2, f3, f4, f2, f1, f3, f1, f4,
141                               f3, f1, f4, f4, f3, f2, f1, f2, f3 };
142    GLfloat const texcoords[] = { f1, f3, f3, f2, f2, f4,
143                                  f2, f4, f4, f1, f1, f3 };
144
145    /* Cheap iterators */
146#if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
147    GLuint *array = data->array;
148#endif
149    GLuint *buffer = data->buffer;
150    Shader **shader = data->shader;
151    GLuint *attr = data->attr;
152
153    ResetState();
154
155#if defined HAVE_GLBEGIN || defined USE_GLEW
156    /*
157     * Test #1: simple glBegin code
158     *
159     * Renders an orange square.
160     */
161    glColor3f(0.8f, 0.5f, 0.2f);
162    glBegin(GL_TRIANGLES);
163        glVertex3f(data->aa.x, data->bb.y, 0.0f);
164        glVertex3f(data->bb.x, data->bb.y, 0.0f);
165        glVertex3f(data->bb.x, data->aa.y, 0.0f);
166
167        glVertex3f(data->bb.x, data->aa.y, 0.0f);
168        glVertex3f(data->aa.x, data->aa.y, 0.0f);
169        glVertex3f(data->aa.x, data->bb.y, 0.0f);
170    glEnd();
171
172    Advance();
173    ResetState();
174
175    /*
176     * Test #2: glBegin + per-vertex coloring
177     *
178     * Renders a multicoloured square with varying colors.
179     */
180
181    glBegin(GL_TRIANGLES);
182        glColor3f(f1, f2, f3);
183        glVertex3f(data->aa.x, data->bb.y, 0.0f);
184        glColor3f(f4, f2, f1);
185        glVertex3f(data->bb.x, data->bb.y, 0.0f);
186        glColor3f(f3, f1, f4);
187        glVertex3f(data->bb.x, data->aa.y, 0.0f);
188
189        glVertex3f(data->bb.x, data->aa.y, 0.0f);
190        glColor3f(f4, f3, f2);
191        glVertex3f(data->aa.x, data->aa.y, 0.0f);
192        glColor3f(f1, f2, f3);
193        glVertex3f(data->aa.x, data->bb.y, 0.0f);
194    glEnd();
195
196    Advance();
197    ResetState();
198
199    /*
200     * Test #3: glBegin + texture
201     *
202     * Renders an animated black-and-white distorted checkerboard.
203     */
204    glEnable(GL_TEXTURE_2D);
205    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
206    glColor3f(1.0f, 1.0f, 1.0f);
207    glBegin(GL_TRIANGLES);
208        glTexCoord2f(f1, f3);
209        glVertex3f(data->aa.x, data->bb.y, 0.0f);
210        glTexCoord2f(f3, f2);
211        glVertex3f(data->bb.x, data->bb.y, 0.0f);
212        glTexCoord2f(f2, f4);
213        glVertex3f(data->bb.x, data->aa.y, 0.0f);
214
215        glTexCoord2f(f2, f4);
216        glVertex3f(data->bb.x, data->aa.y, 0.0f);
217        glTexCoord2f(f4, f1);
218        glVertex3f(data->aa.x, data->aa.y, 0.0f);
219        glTexCoord2f(f1, f3);
220        glVertex3f(data->aa.x, data->bb.y, 0.0f);
221    glEnd();
222    glDisable(GL_TEXTURE_2D);
223
224    Advance();
225    ResetState();
226
227    /*
228     * Test #4: glBegin + color in fragment shader
229     *
230     * Renders a static, coloured and tiled pattern.
231     */
232    if (!shader[0])
233        shader[0] = Shader::Create(
234            "#version 110\n"
235            "void main()"
236            "{"
237            "    gl_Position = gl_Vertex;"
238            "}",
239
240            "#version 110\n"
241            "void main()"
242            "{"
243            "    float dx = mod(gl_FragCoord.x * gl_FragCoord.y, 2.0);"
244            "    float dy = mod(gl_FragCoord.x * 0.125, 1.0);"
245            "    float dz = mod(gl_FragCoord.y * 0.125, 1.0);"
246            "    gl_FragColor = vec4(dx, dy, dz, 1.0);"
247            "}");
248    shader[0]->Bind();
249    shader++;
250    glColor3f(0.0f, 1.0f, 1.0f);
251    glBegin(GL_TRIANGLES);
252        glVertex3f(data->aa.x, data->bb.y, 0.0f);
253        glVertex3f(data->bb.x, data->bb.y, 0.0f);
254        glVertex3f(data->bb.x, data->aa.y, 0.0f);
255
256        glVertex3f(data->bb.x, data->aa.y, 0.0f);
257        glVertex3f(data->aa.x, data->aa.y, 0.0f);
258        glVertex3f(data->aa.x, data->bb.y, 0.0f);
259    glEnd();
260    glUseProgram(0);
261
262    Advance();
263    ResetState();
264
265    /*
266     * Test #5: glBegin + pass vertex coord from vertex shader to fragment
267     * shader for use as color information.
268     *
269     * Renders a multicoloured square with varying colors.
270     */
271    if (!shader[0])
272        shader[0] = Shader::Create(
273            "#version 110\n"
274            "varying vec4 pass_Color;"
275            "void main()"
276            "{"
277            "    float r = gl_MultiTexCoord0.x;"
278            "    float g = gl_MultiTexCoord0.y;"
279            "    float b = gl_MultiTexCoord0.z;"
280            "    pass_Color = vec4(r, g, b, 1.0);"
281            "    gl_Position = gl_Vertex;"
282            "}",
283
284            "#version 110\n"
285            "varying vec4 pass_Color;"
286            "void main()"
287            "{"
288            "    gl_FragColor = pass_Color;"
289            "}");
290    shader[0]->Bind();
291    shader++;
292    glColor3f(0.0f, 1.0f, 1.0f);
293    glBegin(GL_TRIANGLES);
294        glTexCoord3f(f1, f2, f3);
295        glVertex3f(data->aa.x, data->bb.y, 0.0f);
296        glTexCoord3f(f4, f2, f1);
297        glVertex3f(data->bb.x, data->bb.y, 0.0f);
298        glTexCoord3f(f3, f1, f4);
299        glVertex3f(data->bb.x, data->aa.y, 0.0f);
300
301        glVertex3f(data->bb.x, data->aa.y, 0.0f);
302        glTexCoord3f(f4, f3, f2);
303        glVertex3f(data->aa.x, data->aa.y, 0.0f);
304        glTexCoord3f(f1, f2, f3);
305        glVertex3f(data->aa.x, data->bb.y, 0.0f);
306    glEnd();
307    glUseProgram(0);
308
309    Advance();
310    ResetState();
311
312    /*
313     * Test #6: glBegin + apply texture in fragment shader
314     *
315     * Renders an animated black-and-white distorted checkerboard with a
316     * zoom ratio twice the one in test #3.
317     *
318     * Note: there is no need to glEnable(GL_TEXTURE_2D) when the
319     * texture lookup is done in a shader.
320     */
321    if (!shader[0])
322        shader[0] = Shader::Create(
323            "#version 110\n"
324            "void main()"
325            "{"
326            "    gl_TexCoord[0] = gl_MultiTexCoord0;"
327            "    gl_Position = gl_Vertex;"
328            "}",
329
330            "#version 110\n"
331            "uniform sampler2D tex;"
332            "void main()"
333            "{"
334            "    gl_FragColor = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
335            "}");
336    shader[0]->Bind();
337    shader++;
338    glColor3f(0.0f, 1.0f, 1.0f);
339    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
340    glBegin(GL_TRIANGLES);
341        glTexCoord2f(f1, f3);
342        glVertex3f(data->aa.x, data->bb.y, 0.0f);
343        glTexCoord2f(f3, f2);
344        glVertex3f(data->bb.x, data->bb.y, 0.0f);
345        glTexCoord2f(f2, f4);
346        glVertex3f(data->bb.x, data->aa.y, 0.0f);
347
348        glTexCoord2f(f2, f4);
349        glVertex3f(data->bb.x, data->aa.y, 0.0f);
350        glTexCoord2f(f4, f1);
351        glVertex3f(data->aa.x, data->aa.y, 0.0f);
352        glTexCoord2f(f1, f3);
353        glVertex3f(data->aa.x, data->bb.y, 0.0f);
354    glEnd();
355    glUseProgram(0);
356
357    Advance();
358    ResetState();
359#endif
360
361    /*
362     * Test #7: simple vertex buffer
363     *
364     * Renders an orange square.
365     */
366#if !defined ANDROID_NDK
367    GLfloat const vertices1[] = { data->aa.x, data->bb.y, 0.0f,
368                                  data->bb.x, data->bb.y, 0.0f,
369                                  data->bb.x, data->aa.y, 0.0f,
370                                  data->bb.x, data->aa.y, 0.0f,
371                                  data->aa.x, data->aa.y, 0.0f,
372                                  data->aa.x, data->bb.y, 0.0f };
373
374    glColor4f(0.8f, 0.5f, 0.2f, 1.0f);
375    glEnableClientState(GL_VERTEX_ARRAY);
376
377    glVertexPointer(3, GL_FLOAT, 0, vertices1);
378    glDrawArrays(GL_TRIANGLES, 0, 6);
379
380    glDisableClientState(GL_VERTEX_ARRAY);
381
382    Advance();
383    ResetState();
384#endif
385
386    /*
387     * Test #8: vertex buffer + per-vertex coloring
388     *
389     * Renders a multicoloured square with varying colors.
390     */
391#if !defined ANDROID_NDK
392    GLfloat const vertices2[] = { data->aa.x, data->bb.y, 0.0f,
393                                  data->bb.x, data->bb.y, 0.0f,
394                                  data->bb.x, data->aa.y, 0.0f,
395                                  data->bb.x, data->aa.y, 0.0f,
396                                  data->aa.x, data->aa.y, 0.0f,
397                                  data->aa.x, data->bb.y, 0.0f };
398
399    glEnableClientState(GL_VERTEX_ARRAY);
400    glEnableClientState(GL_COLOR_ARRAY);
401
402    glVertexPointer(3, GL_FLOAT, 0, vertices2);
403    glColorPointer(3, GL_FLOAT, 0, colors);
404    glDrawArrays(GL_TRIANGLES, 0, 6);
405
406    glDisableClientState(GL_VERTEX_ARRAY);
407    glDisableClientState(GL_COLOR_ARRAY);
408
409    Advance();
410    ResetState();
411#endif
412
413    /*
414     * Test #9: vertex buffer + per-vertex coloring + texture
415     *
416     * Renders a multicoloured square with varying colors multiplied with an
417     * animated distorted checkerboard.
418     */
419#if !defined ANDROID_NDK
420    GLfloat const vertices3[] = { data->aa.x, data->bb.y, 0.0f,
421                                  data->bb.x, data->bb.y, 0.0f,
422                                  data->bb.x, data->aa.y, 0.0f,
423                                  data->bb.x, data->aa.y, 0.0f,
424                                  data->aa.x, data->aa.y, 0.0f,
425                                  data->aa.x, data->bb.y, 0.0f };
426
427    glEnable(GL_TEXTURE_2D);
428    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
429    glEnableClientState(GL_VERTEX_ARRAY);
430    glEnableClientState(GL_COLOR_ARRAY);
431    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
432
433    glVertexPointer(3, GL_FLOAT, 0, vertices3);
434    glColorPointer(3, GL_FLOAT, 0, colors);
435    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
436
437    glDrawArrays(GL_TRIANGLES, 0, 6);
438
439    glDisableClientState(GL_VERTEX_ARRAY);
440    glDisableClientState(GL_COLOR_ARRAY);
441    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
442    glDisable(GL_TEXTURE_2D);
443
444    Advance();
445    ResetState();
446#endif
447
448    /*
449     * Test #10: vertex buffer + texture & color in 1.10 fragment shader
450     *
451     * Renders a multicoloured square with varying colors xored with an
452     * animated distorted checkerboard.
453     */
454#if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
455    if (!shader[0])
456        shader[0] = Shader::Create(
457            "#version 110\n"
458            "varying vec4 pass_Color;"
459            "void main()"
460            "{"
461            "    gl_TexCoord[0] = gl_MultiTexCoord0;"
462            "    pass_Color = gl_Color;"
463            "    gl_Position = gl_Vertex;"
464            "}",
465
466            "#version 110\n"
467            "varying vec4 pass_Color;"
468            "uniform sampler2D tex;"
469            "void main()"
470            "{"
471            "    vec4 tmp = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
472            "    gl_FragColor = vec4(abs(tmp.xyz - pass_Color.xyz), 1.0);"
473            "}");
474
475    shader[0]->Bind();
476    shader++;
477    GLfloat const vertices4[] = { data->aa.x, data->bb.y, 0.0f,
478                                  data->bb.x, data->bb.y, 0.0f,
479                                  data->bb.x, data->aa.y, 0.0f,
480                                  data->bb.x, data->aa.y, 0.0f,
481                                  data->aa.x, data->aa.y, 0.0f,
482                                  data->aa.x, data->bb.y, 0.0f };
483
484    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
485
486    glEnableClientState(GL_VERTEX_ARRAY);
487    glEnableClientState(GL_COLOR_ARRAY);
488    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
489
490    glVertexPointer(3, GL_FLOAT, 0, vertices4);
491    glColorPointer(3, GL_FLOAT, 0, colors);
492    glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
493    glDrawArrays(GL_TRIANGLES, 0, 6);
494
495    glDisableClientState(GL_VERTEX_ARRAY);
496    glDisableClientState(GL_COLOR_ARRAY);
497    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
498    glUseProgram(0);
499
500    Advance();
501    ResetState();
502#endif
503
504    /*
505     * Test #11: vertex buffer + texture & color in 1.20 fragment shader
506     *
507     * Renders a multicoloured square with varying colors xored with an
508     * animated distorted checkerboard.
509     */
510#if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
511    if (!shader[0])
512    {
513        shader[0] = Shader::Create(
514            "#version 120\n"
515            "attribute vec3 in_Vertex;"
516            "attribute vec3 in_Color;"
517            "attribute vec2 in_MultiTexCoord0;"
518            "varying vec4 pass_Color;"
519            "void main()"
520            "{"
521            "    gl_TexCoord[0] = vec4(in_MultiTexCoord0, 0.0, 0.0);"
522            "    pass_Color = vec4(in_Color, 1.0);"
523            "    gl_Position = vec4(in_Vertex, 1.0);"
524            "}",
525
526            "#version 120\n"
527            "varying vec4 pass_Color;"
528            "uniform sampler2D tex;"
529            "void main()"
530            "{"
531            "    vec4 tmp = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
532            "    gl_FragColor = vec4(abs(tmp.xyz - pass_Color.xyz), 1.0);"
533            "}");
534        attr[0] = shader[0]->GetAttribLocation("in_Vertex");
535        attr[1] = shader[0]->GetAttribLocation("in_Color");
536        attr[2] = shader[0]->GetAttribLocation("in_MultiTexCoord0");
537    }
538    shader[0]->Bind();
539    shader++;
540    GLfloat const vertices5[] = { data->aa.x, data->bb.y, 0.0f,
541                                  data->bb.x, data->bb.y, 0.0f,
542                                  data->bb.x, data->aa.y, 0.0f,
543                                  data->bb.x, data->aa.y, 0.0f,
544                                  data->aa.x, data->aa.y, 0.0f,
545                                  data->aa.x, data->bb.y, 0.0f };
546
547    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
548
549    glBindVertexArray(*array++);
550
551    glBindBuffer(GL_ARRAY_BUFFER, *buffer++);
552    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices5), vertices5,
553                 GL_DYNAMIC_DRAW);
554    glVertexAttribPointer(attr[0], 3, GL_FLOAT, GL_FALSE, 0, 0);
555    glEnableVertexAttribArray(attr[0]);
556
557    glBindBuffer(GL_ARRAY_BUFFER, *buffer++);
558    glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors,
559                 GL_DYNAMIC_DRAW);
560    glVertexAttribPointer(attr[1], 3, GL_FLOAT, GL_FALSE, 0, 0);
561    glEnableVertexAttribArray(attr[1]);
562
563    glBindBuffer(GL_ARRAY_BUFFER, *buffer++);
564    glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
565                 GL_DYNAMIC_DRAW);
566    glVertexAttribPointer(attr[2], 2, GL_FLOAT, GL_FALSE, 0, 0);
567    glEnableVertexAttribArray(attr[2]);
568
569    glDrawArrays(GL_TRIANGLES, 0, 6);
570    glBindVertexArray(0);
571
572    glDisableVertexAttribArray(*attr++);
573    glDisableVertexAttribArray(*attr++);
574    glDisableVertexAttribArray(*attr++);
575    glUseProgram(0);
576
577    Advance();
578    ResetState();
579#endif
580
581    /*
582     * Test #12: vertex buffer + texture & color in 1.30 fragment shader
583     *
584     * Renders a multicoloured square with varying colors xored with an
585     * animated distorted checkerboard.
586     */
587#if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
588    if (!shader[0])
589    {
590        shader[0] = Shader::Create(
591            "#version 130\n"
592            "in vec3 in_Vertex;"
593            "in vec3 in_Color;"
594            "in vec2 in_MultiTexCoord0;"
595            "out vec4 pass_Color;"
596            "void main()"
597            "{"
598            "    gl_TexCoord[0] = vec4(in_MultiTexCoord0, 0.0, 0.0);"
599            "    pass_Color = vec4(in_Color, 1.0);"
600            "    gl_Position = vec4(in_Vertex, 1.0);"
601            "}",
602
603            "#version 130\n"
604            "in vec4 pass_Color;"
605            "uniform sampler2D tex;"
606            "void main()"
607            "{"
608            "    vec4 tmp = texture2D(tex, gl_TexCoord[0].xy * 0.25);"
609            "    gl_FragColor = vec4(abs(tmp.xyz - pass_Color.xyz), 1.0);"
610            "}");
611        attr[0] = shader[0]->GetAttribLocation("in_Vertex");
612        attr[1] = shader[0]->GetAttribLocation("in_Color");
613        attr[2] = shader[0]->GetAttribLocation("in_MultiTexCoord0");
614    }
615    shader[0]->Bind();
616    shader++;
617    GLfloat const vertices6[] = { data->aa.x, data->bb.y, 0.0f,
618                                  data->bb.x, data->bb.y, 0.0f,
619                                  data->bb.x, data->aa.y, 0.0f,
620                                  data->bb.x, data->aa.y, 0.0f,
621                                  data->aa.x, data->aa.y, 0.0f,
622                                  data->aa.x, data->bb.y, 0.0f };
623
624    glBindTexture(GL_TEXTURE_2D, data->texture[0]);
625
626    glBindVertexArray(*array++);
627
628    glBindBuffer(GL_ARRAY_BUFFER, *buffer++);
629    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices6), vertices6,
630                 GL_DYNAMIC_DRAW);
631    glVertexAttribPointer(attr[0], 3, GL_FLOAT, GL_FALSE, 0, 0);
632    glEnableVertexAttribArray(attr[0]);
633
634    glBindBuffer(GL_ARRAY_BUFFER, *buffer++);
635    glBufferData(GL_ARRAY_BUFFER, sizeof(colors), colors,
636                 GL_DYNAMIC_DRAW);
637    glVertexAttribPointer(attr[1], 3, GL_FLOAT, GL_FALSE, 0, 0);
638    glEnableVertexAttribArray(attr[2]);
639
640    glBindBuffer(GL_ARRAY_BUFFER, *buffer++);
641    glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
642                 GL_DYNAMIC_DRAW);
643    glVertexAttribPointer(attr[2], 2, GL_FLOAT, GL_FALSE, 0, 0);
644    glEnableVertexAttribArray(attr[2]);
645
646    glDrawArrays(GL_TRIANGLES, 0, 6);
647    glBindVertexArray(0);
648
649    glDisableVertexAttribArray(*attr++);
650    glDisableVertexAttribArray(*attr++);
651    glDisableVertexAttribArray(*attr++);
652    glUseProgram(0);
653
654    Advance();
655    ResetState();
656#endif
657
658    /* Check that we didn't overflow our list */
659#if !defined __CELLOS_LV2__ && !defined ANDROID_NDK
660    if (array > data->array + NUM_ARRAYS)
661        Log::Error("too many arrays used\n");
662#endif
663    if (buffer > data->buffer + NUM_BUFFERS)
664        Log::Error("too many buffers used\n");
665    if (shader > data->shader + NUM_SHADERS)
666        Log::Error("too many shaders used\n");
667    if (attr > data->attr + NUM_ATTRS)
668        Log::Error("too many attributes used\n");
669}
670
671void DebugQuad::ResetState()
672{
673    /* Reset GL states to something reasonably safe */
674#if defined HAVE_GLBEGIN || defined USE_GLEW || defined __CELLOS_LV2__
675    glMatrixMode(GL_PROJECTION);
676    glLoadIdentity();
677    glMatrixMode(GL_MODELVIEW);
678    glLoadIdentity();
679#endif
680
681    glEnable(GL_TEXTURE_2D);
682    glBindTexture(GL_TEXTURE_2D, 0);
683#if defined HAVE_GLBEGIN || defined USE_GLEW || defined __CELLOS_LV2__
684    glClientActiveTexture(GL_TEXTURE0);
685#endif
686    glDisable(GL_TEXTURE_2D);
687
688    glBindBuffer(GL_ARRAY_BUFFER, 0);
689#if !defined __CELLOS_LV2__
690    glUseProgram(0);
691#endif
692}
693
694void DebugQuad::Advance()
695{
696    data->aa.x += 3.0f * data->step.x;
697    data->bb.x += 3.0f * data->step.x;
698    if (data->bb.x > 1.0f)
699    {
700        data->aa.x = data->orig.x;
701        data->bb.x = data->orig.x + 2.0f * data->step.x;
702        data->aa.y += 3.0f * data->step.y;
703        data->bb.y += 3.0f * data->step.y;
704    }
705}
706
707DebugQuad::~DebugQuad()
708{
709    delete data;
710}
711
712} /* namespace lol */
713
Note: See TracBrowser for help on using the repository browser.