source: trunk/test/tutorial/tut03.cpp @ 1082

Last change on this file since 1082 was 1082, checked in by sam, 8 years ago

core: port all code to NativeClient. Nothing runs for now, but it builds.

  • Property svn:keywords set to Id
File size: 23.4 KB
Line 
1//
2// Lol Engine - Fractal tutorial
3//
4// Copyright: (c) 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 <cstring>
16
17#include "core.h"
18#include "lolgl.h"
19#include "loldebug.h"
20
21using namespace std;
22using namespace lol;
23
24#if USE_SDL && defined __APPLE__
25#   include <SDL_main.h>
26#endif
27
28#if defined _WIN32
29#   undef main /* FIXME: still needed? */
30#   include <direct.h>
31#endif
32
33#ifdef __CELLOS_LV2__
34static GLint const INTERNAL_FORMAT = GL_ARGB_SCE;
35static GLenum const TEXTURE_FORMAT = GL_BGRA;
36static GLenum const TEXTURE_TYPE = GL_UNSIGNED_INT_8_8_8_8_REV;
37#elif defined __native_client__
38static GLint const INTERNAL_FORMAT = GL_RGBA;
39static GLenum const TEXTURE_FORMAT = GL_RGBA;
40static GLenum const TEXTURE_TYPE = GL_UNSIGNED_BYTE;
41#else
42/* Seems efficient for little endian textures */
43static GLint const INTERNAL_FORMAT = GL_RGBA;
44static GLenum const TEXTURE_FORMAT = GL_BGRA;
45static GLenum const TEXTURE_TYPE = GL_UNSIGNED_INT_8_8_8_8_REV;
46#endif
47
48class Fractal : public WorldEntity
49{
50public:
51    Fractal(ivec2 const &size)
52    {
53        /* Ensure texture size is a multiple of 16 for better aligned
54         * data access. Store the dimensions of a texel for our shader. */
55        m_size = size;
56        m_size.x = (m_size.x + 15) & ~15;
57        m_size.y = (m_size.y + 15) & ~15;
58        m_texel_settings = vec4(vec2(1.0, 1.0) / (vec2)m_size, m_size);
59
60        /* Window size decides the world aspect ratio. For instance, 640×480
61         * will be mapped to (-0.66,-0.5) - (0.66,0.5). */
62        m_window_size = Video::GetSize();
63        if (m_window_size.y < m_window_size.x)
64            m_window2world = 0.5 / m_window_size.y;
65        else
66            m_window2world = 0.5 / m_window_size.x;
67        m_texel2world = (vec2)m_window_size / (vec2)m_size * m_window2world;
68
69        m_pixels = new u8vec4[m_size.x * m_size.y];
70        m_tmppixels = new u8vec4[m_size.x / 2 * m_size.y / 2];
71        m_frame = -1;
72        for (int i = 0; i < 4; i++)
73        {
74            m_deltashift[i] = 0.0;
75            m_deltascale[i] = 1.0;
76            m_dirty[i] = 2;
77        }
78        m_center = -0.75;
79        m_zoom_speed = 0.0;
80        m_radius = 5.0;
81        m_ready = false;
82
83        m_palette = new u8vec4[(MAX_ITERATIONS + 1) * PALETTE_STEP];
84        for (int i = 0; i < (MAX_ITERATIONS + 1) * PALETTE_STEP; i++)
85        {
86            double f = (double)i / PALETTE_STEP;
87
88            double r = 0.5 * sin(f * 0.27 - 2.5) + 0.5;
89            double g = 0.5 * sin(f * 0.13 + 1.1) + 0.5;
90            double b = 0.5 * sin(f * 0.21 + 0.4) + 0.5;
91
92            if (f < 7.0)
93            {
94                f = f < 1.0 ? 0.0 : (f - 1.0) / 6.0;
95                r *= f;
96                g *= f;
97                b *= f;
98            }
99
100            uint8_t red = r * 255.99f;
101            uint8_t green = g * 255.99f;
102            uint8_t blue = b * 255.99f;
103            m_palette[i] = u8vec4(blue, green, red, 0);
104        }
105
106        m_centertext = new Text(NULL, "gfx/font/ascii.png");
107        m_centertext->SetPos(ivec3(5, m_window_size.y - 15, 1));
108        Ticker::Ref(m_centertext);
109
110        m_mousetext = new Text(NULL, "gfx/font/ascii.png");
111        m_mousetext->SetPos(ivec3(5, m_window_size.y - 29, 1));
112        Ticker::Ref(m_mousetext);
113
114        m_zoomtext = new Text(NULL, "gfx/font/ascii.png");
115        m_zoomtext->SetPos(ivec3(5, m_window_size.y - 43, 1));
116        Ticker::Ref(m_zoomtext);
117
118        position = ivec3(0, 0, 0);
119        bbox[0] = position;
120        bbox[1] = ivec3(m_window_size, 0);
121        Input::TrackMouse(this);
122    }
123
124    ~Fractal()
125    {
126        Input::UntrackMouse(this);
127        Ticker::Unref(m_centertext);
128        Ticker::Unref(m_mousetext);
129        Ticker::Unref(m_zoomtext);
130        delete m_pixels;
131        delete m_tmppixels;
132        delete m_palette;
133    }
134
135    inline f64cmplx TexelToWorldOffset(ivec2 texel)
136    {
137        double dx = (0.5 + texel.x - m_size.x / 2) * m_texel2world.x;
138        double dy = (0.5 + m_size.y / 2 - texel.y) * m_texel2world.y;
139        return m_radius * f64cmplx(dx, dy);
140    }
141
142    inline f64cmplx ScreenToWorldOffset(ivec2 pixel)
143    {
144        /* No 0.5 offset here, because we want to be able to position the
145         * mouse at (0,0) exactly. */
146        double dx = pixel.x - m_window_size.x / 2;
147        double dy = m_window_size.y / 2 - pixel.y;
148        return m_radius * m_window2world * f64cmplx(dx, dy);
149    }
150
151    virtual void TickGame(float deltams)
152    {
153        WorldEntity::TickGame(deltams);
154
155        int prev_frame = m_frame;
156        m_frame = (m_frame + 1) % 4;
157
158        f64cmplx worldmouse = m_center + ScreenToWorldOffset(mousepos);
159
160        ivec3 buttons = Input::GetMouseButtons();
161#ifdef __CELLOS_LV2__
162        m_zoom_speed = 0.0005;
163#else
164        if ((buttons[0] || buttons[2]) && mousepos.x != -1)
165        {
166            double zoom = buttons[0] ? -0.0005 : 0.0005;
167            m_zoom_speed += deltams * zoom;
168            if (m_zoom_speed / zoom > 5)
169                m_zoom_speed = 5 * zoom;
170        }
171        else if (m_zoom_speed)
172        {
173            m_zoom_speed *= pow(2.0, -deltams * 0.005);
174            if (abs(m_zoom_speed) < 1e-5)
175                m_zoom_speed = 0.0;
176        }
177#endif
178
179        if (m_zoom_speed)
180        {
181            f64cmplx oldcenter = m_center;
182            double oldradius = m_radius;
183            double zoom = pow(2.0, deltams * m_zoom_speed);
184            if (m_radius * zoom > 8.0)
185                zoom = 8.0 / m_radius;
186            else if (m_radius * zoom < 1e-14)
187                zoom = 1e-14 / m_radius;
188            m_radius *= zoom;
189#ifdef __CELLOS_LV2__
190            m_center = f64cmplx(-.22815528839841, -1.11514249704382);
191            //m_center = f64cmplx(0.001643721971153, 0.822467633298876);
192#else
193            m_center = (m_center - worldmouse) * zoom + worldmouse;
194            worldmouse = m_center + ScreenToWorldOffset(mousepos);
195#endif
196
197            /* Store the transformation properties to go from m_frame - 1
198             * to m_frame. */
199            m_deltashift[prev_frame] = (m_center - oldcenter) / oldradius;
200            m_deltashift[prev_frame].x /= m_size.x * m_texel2world.x;
201            m_deltashift[prev_frame].y /= m_size.y * m_texel2world.y;
202            m_deltascale[prev_frame] = m_radius / oldradius;
203            m_dirty[0] = m_dirty[1] = m_dirty[2] = m_dirty[3] = 2;
204        }
205        else
206        {
207            /* If settings didn't change, set transformation from previous
208             * frame to identity. */
209            m_deltashift[prev_frame] = 0.0;
210            m_deltascale[prev_frame] = 1.0;
211        }
212
213        if (buttons[1])
214            m_dirty[0] = m_dirty[1] = m_dirty[2] = m_dirty[3] = 2;
215
216        /* Transformation from current frame to current frame is always
217         * identity. */
218        m_zoom_settings[m_frame][0] = 0.0f;
219        m_zoom_settings[m_frame][1] = 0.0f;
220        m_zoom_settings[m_frame][2] = 1.0f;
221
222        /* Compute transformation from other frames to current frame */
223        for (int i = 0; i < 3; i++)
224        {
225            int prev_index = (m_frame + 4 - i) % 4;
226            int cur_index = (m_frame + 3 - i) % 4;
227
228            m_zoom_settings[cur_index][0] = m_zoom_settings[prev_index][0] * m_deltascale[cur_index] + m_deltashift[cur_index].x;
229            m_zoom_settings[cur_index][1] = m_zoom_settings[prev_index][1] * m_deltascale[cur_index] + m_deltashift[cur_index].y;
230            m_zoom_settings[cur_index][2] = m_zoom_settings[prev_index][2] * m_deltascale[cur_index];
231        }
232
233        char buf[128];
234        sprintf(buf, "center: %+16.14f%+16.14fi", m_center.x, m_center.y);
235        m_centertext->SetText(buf);
236        sprintf(buf, " mouse: %+16.14f%+16.14fi", worldmouse.x, worldmouse.y);
237        m_mousetext->SetText(buf);
238        sprintf(buf, "  zoom: %g", 1.0 / m_radius);
239        m_zoomtext->SetText(buf);
240
241        u8vec4 *m_pixelstart = m_pixels + m_size.x * m_size.y / 4 * m_frame;
242
243        if (m_dirty[m_frame])
244        {
245            double const maxsqlen = 1024;
246            double const k1 = 1.0 / (1 << 10) / log2(maxsqlen);
247
248            m_dirty[m_frame]--;
249
250            for (int j = ((m_frame + 1) % 4) / 2; j < m_size.y; j += 2)
251            for (int i = m_frame % 2; i < m_size.x; i += 2)
252            {
253
254                f64cmplx z0 = m_center + TexelToWorldOffset(ivec2(i, j));
255                f64cmplx r0 = z0;
256                //f64cmplx r0(0.28693186889504513, 0.014286693904085048);
257                //f64cmplx r0(0.001643721971153, 0.822467633298876);
258                //f64cmplx r0(-1.207205434596, 0.315432814901);
259                //f64cmplx r0(-0.79192956889854, -0.14632423080102);
260                //f64cmplx r0(0.3245046418497685, 0.04855101129280834);
261                f64cmplx z;
262                int iter = MAX_ITERATIONS;
263                for (z = z0; iter && z.sqlen() < maxsqlen; z = z * z + r0)
264                    --iter;
265
266                if (iter)
267                {
268                    double f = iter;
269                    double n = z.sqlen();
270                    if (n > maxsqlen * maxsqlen)
271                        n = maxsqlen * maxsqlen;
272
273                    /* Approximate log(sqrt(n))/log(sqrt(maxsqlen)) */
274                    union { double n; uint64_t x; } u = { n };
275                    double k = (u.x >> 42) - (((1 << 10) - 1) << 10);
276                    k *= k1;
277
278                    /* Approximate log2(k) in [1,2]. */
279                    f += (- 0.344847817623168308695977510213252644185 * k
280                          + 2.024664188044341212602376988171727038739) * k
281                          - 1.674876738008591047163498125918330313237;
282
283                    *m_pixelstart++ = m_palette[(int)(f * PALETTE_STEP)];
284                }
285                else
286                {
287                    *m_pixelstart++ = u8vec4(0, 0, 0, 0);
288                }
289            }
290        }
291    }
292
293    virtual void TickDraw(float deltams)
294    {
295        WorldEntity::TickDraw(deltams);
296
297        static float const vertices[] =
298        {
299             1.0f,  1.0f,
300            -1.0f,  1.0f,
301            -1.0f, -1.0f,
302            -1.0f, -1.0f,
303             1.0f, -1.0f,
304             1.0f,  1.0f,
305        };
306
307        static float const texcoords[] =
308        {
309             1.0f,  1.0f,
310             0.0f,  1.0f,
311             0.0f,  0.0f,
312             0.0f,  0.0f,
313             1.0f,  0.0f,
314             1.0f,  1.0f,
315        };
316
317        if (!m_ready)
318        {
319            /* Create a texture of half the width and twice the height
320             * so that we can upload four different subimages each frame. */
321            glGenTextures(1, &m_texid);
322            glBindTexture(GL_TEXTURE_2D, m_texid);
323            glTexImage2D(GL_TEXTURE_2D, 0, INTERNAL_FORMAT,
324                         m_size.x / 2, m_size.y * 2, 0,
325                         TEXTURE_FORMAT, TEXTURE_TYPE, m_pixels);
326#if defined __CELLOS_LV2__
327            /* We need this hint because by default the storage type is
328             * GL_TEXTURE_SWIZZLED_GPU_SCE. */
329            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_ALLOCATION_HINT_SCE,
330                            GL_TEXTURE_TILED_GPU_SCE);
331#endif
332            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
333            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
334
335            m_shader = Shader::Create(
336#if !defined __CELLOS_LV2__
337                "#version 120\n"
338                "attribute vec2 in_TexCoord;\n"
339                "attribute vec2 in_Vertex;"
340                "void main(void) {"
341                "    gl_Position = vec4(in_Vertex, 0.0, 1.0);"
342                "    gl_TexCoord[0] = vec4(in_TexCoord, 0.0, 0.0);\n"
343                "}",
344
345                "#version 120\n"
346                ""
347                "uniform vec4 in_TexelSize;"
348                "uniform mat4 in_ZoomSettings;"
349                "uniform sampler2D in_Texture;"
350                ""
351                "float mylen(vec2 p) {"
352                //"    return abs(p.x) + abs(p.y);"
353                //"    return p.x * p.x + p.y * p.y;"
354                "    return length(p);"
355                "}"
356                ""
357                /* Get the coordinate of the nearest point in slice 0 in xy,
358                 * and the squared distance to that point in z.
359                 * p is in normalised [0,1] texture coordinates.
360                 * return value has the 0.25 Y scaling. */
361                "vec3 nearest0(vec2 p) {"
362                "    p -= vec2(0.5, 0.5);"
363                "    p *= in_ZoomSettings[0][2];"
364                "    p += vec2(in_ZoomSettings[0][0], -in_ZoomSettings[0][1]);"
365                "    p += vec2(0.5, 0.5);"
366                "    vec2 q = p + 0.5 * in_TexelSize.xy;"
367                "    q -= mod(q, 2.0 * in_TexelSize.xy);"
368                "    q += 0.5 * in_TexelSize.xy;"
369                "    float l = (abs(q.x - 0.5) < 0.5 && abs(q.y - 0.5) < 0.5)"
370                "             ? 1.0 / mylen(q - p) : 0.0;"
371                "    return vec3(q * vec2(1.0, 0.25), l);"
372                "}"
373                ""
374                "vec3 nearest1(vec2 p) {"
375                "    p -= vec2(0.5, 0.5);"
376                "    p *= in_ZoomSettings[1][2];"
377                "    p += vec2(in_ZoomSettings[1][0], -in_ZoomSettings[1][1]);"
378                "    p += vec2(0.5, 0.5);"
379                "    vec2 q = p + -0.5 * in_TexelSize.xy;"
380                "    q -= mod(q, 2.0 * in_TexelSize.xy);"
381                "    q += 1.5 * in_TexelSize.xy;"
382                "    float l = (abs(q.x - 0.5) < 0.5 && abs(q.y - 0.5) < 0.5)"
383                "             ? 1.0 / mylen(q - p) : 0.0;"
384                "    return vec3(q * vec2(1.0, 0.25) + vec2(0.0, 0.25), l);"
385                "}"
386                ""
387                "vec3 nearest2(vec2 p) {"
388                "    p -= vec2(0.5, 0.5);"
389                "    p *= in_ZoomSettings[2][2];"
390                "    p += vec2(in_ZoomSettings[2][0], -in_ZoomSettings[2][1]);"
391                "    p += vec2(0.5, 0.5);"
392                "    vec2 q = p + vec2(0.5, -0.5) * in_TexelSize.xy;"
393                "    q -= mod(q, 2.0 * in_TexelSize.xy);"
394                "    q += vec2(0.5, 1.5) * in_TexelSize.xy;"
395                "    float l = (abs(q.x - 0.5) < 0.5 && abs(q.y - 0.5) < 0.5)"
396                "             ? 1.0 / mylen(q - p) : 0.0;"
397                "    return vec3(q * vec2(1.0, 0.25) + vec2(0.0, 0.50), l);"
398                "}"
399                ""
400                "vec3 nearest3(vec2 p) {"
401                "    p -= vec2(0.5, 0.5);"
402                "    p *= in_ZoomSettings[3][2];"
403                "    p += vec2(in_ZoomSettings[3][0], -in_ZoomSettings[3][1]);"
404                "    p += vec2(0.5, 0.5);"
405                "    vec2 q = p + vec2(-0.5, 0.5) * in_TexelSize.xy;"
406                "    q -= mod(q, 2.0 * in_TexelSize.xy);"
407                "    q += vec2(1.5, 0.5) * in_TexelSize.xy;"
408                "    float l = (abs(q.x - 0.5) < 0.5 && abs(q.y - 0.5) < 0.5)"
409                "             ? 1.0 / mylen(q - p) : 0.0;"
410                "    return vec3(q * vec2(1.0, 0.25) + vec2(0.0, 0.75), l);"
411                "}"
412                ""
413                "void main(void) {"
414                "    vec2 coord = gl_TexCoord[0].xy;"
415                /* Slightly shift our pixel so that it does not lie at
416                 * an exact texel boundary. This would lead to visual
417                 * artifacts. */
418                "    coord -= 0.1 * in_TexelSize.xy;"
419                /* Get a pixel from each slice */
420                "    vec3 k0 = nearest0(coord);"
421                "    vec3 k1 = nearest1(coord);"
422                "    vec3 k2 = nearest2(coord);"
423                "    vec3 k3 = nearest3(coord);"
424                "    vec4 p0 = texture2D(in_Texture, k0.xy);"
425                "    vec4 p1 = texture2D(in_Texture, k1.xy);"
426                "    vec4 p2 = texture2D(in_Texture, k2.xy);"
427                "    vec4 p3 = texture2D(in_Texture, k3.xy);"
428//"if (k0.z >= k1.z && k0.z >= k2.z && k0.z >= k3.z) gl_FragColor = p0;"
429//"if (k1.z >= k0.z && k1.z >= k2.z && k1.z >= k3.z) gl_FragColor = p1;"
430//"if (k2.z >= k0.z && k2.z >= k1.z && k2.z >= k3.z) gl_FragColor = p2;"
431//"if (k3.z >= k0.z && k3.z >= k1.z && k3.z >= k2.z) gl_FragColor = p3;"
432                "    gl_FragColor = 1.0 / (k0.z + k1.z + k2.z + k3.z)"
433                "          * (k0.z * p0 + k1.z * p1 + k2.z * p2 + k3.z * p3);"
434                "}"
435#else
436                "void main(float4 in_Position : POSITION,"
437                "          float2 in_TexCoord : TEXCOORD0,"
438                "          out float4 out_Position : POSITION,"
439                "          out float2 out_TexCoord : TEXCOORD0)"
440                "{"
441                "    out_TexCoord = in_TexCoord;"
442                "    out_Position = in_Position;"
443                "}",
444
445                "float3 nearest0(float2 p, float4 in_TexelSize) {"
446                "    float2 q = p + 0.5 * in_TexelSize.xy;"
447                "    q -= fmod(q, 2.0 * in_TexelSize.xy);"
448                "    q += 0.5 * in_TexelSize.xy;"
449                "    return float3(q * float2(1.0, 0.25),"
450                "                  length(q - p));"
451                "}"
452                ""
453                "float3 nearest1(float2 p, float4 in_TexelSize) {"
454                "    float2 q = p - 0.5 * in_TexelSize.xy;"
455                "    q -= fmod(q, 2.0 * in_TexelSize.xy);"
456                "    q += 1.5 * in_TexelSize.xy;"
457                "    return float3(q * float2(1.0, 0.25) + float2(0.0, 0.25),"
458                "                  length(q - p));"
459                "}"
460                ""
461                "float3 nearest2(float2 p, float4 in_TexelSize) {"
462                "    float2 q = p + float2(0.5, -0.5) * in_TexelSize.xy;"
463                "    q -= fmod(q, 2.0 * in_TexelSize.xy);"
464                "    q += float2(0.5, 1.5) * in_TexelSize.xy;"
465                "    return float3(q * float2(1.0, 0.25) + float2(0.0, 0.50),"
466                "                  length(q - p));"
467                "}"
468                ""
469                "float3 nearest3(float2 p, float4 in_TexelSize) {"
470                "    float2 q = p + float2(-0.5, 0.5) * in_TexelSize.xy;"
471                "    q -= fmod(q, 2.0 * in_TexelSize.xy);"
472                "    q += float2(1.5, 0.5) * in_TexelSize.xy;"
473                "    return float3(q * float2(1.0, 0.25) + float2(0.0, 0.75),"
474                "                  length(q - p));"
475                "}"
476                ""
477                "void main(float2 in_TexCoord : TEXCOORD0,"
478                "          uniform float4 in_TexelSize,"
479                "          uniform sampler2D in_Texture,"
480                "          out float4 out_FragColor : COLOR)"
481                "{"
482                "    float2 coord = in_TexCoord.xy;"
483                "    coord -= 0.1 * in_TexelSize.xy;"
484                "    float4 p0 = tex2D(in_Texture, nearest0(coord, in_TexelSize).xy);"
485                "    float4 p1 = tex2D(in_Texture, nearest1(coord, in_TexelSize).xy);"
486                "    float4 p2 = tex2D(in_Texture, nearest2(coord, in_TexelSize).xy);"
487                "    float4 p3 = tex2D(in_Texture, nearest3(coord, in_TexelSize).xy);"
488                "    out_FragColor = 0.25 * (p0 + p1 + p2 + p3);"
489                "}"
490#endif
491            );
492            m_vertexattrib = m_shader->GetAttribLocation("in_Vertex");
493            m_texattrib = m_shader->GetAttribLocation("in_TexCoord");
494            m_texeluni = m_shader->GetUniformLocation("in_TexelSize");
495            m_zoomuni = m_shader->GetUniformLocation("in_ZoomSettings");
496            m_ready = true;
497
498#if !defined __CELLOS_LV2__ && !defined __ANDROID__
499            /* Method 1: store vertex buffer on the GPU memory */
500            glGenBuffers(1, &m_vbo);
501            glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
502            glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices,
503                         GL_STATIC_DRAW);
504            glGenBuffers(1, &m_tbo);
505            glBindBuffer(GL_ARRAY_BUFFER, m_tbo);
506            glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
507                         GL_STATIC_DRAW);
508#elif !defined __CELLOS_LV2__ && !defined __ANDROID__
509            /* Method 2: upload vertex information at each frame */
510#else
511#endif
512
513            /* FIXME: this object never cleans up */
514        }
515
516        glEnable(GL_TEXTURE_2D);
517        glBindTexture(GL_TEXTURE_2D, m_texid);
518
519        if (m_dirty[m_frame])
520        {
521            m_dirty[m_frame]--;
522
523#ifdef __CELLOS_LV2__
524            /* glTexSubImage2D is extremely slow on the PS3, to the point
525             * that uploading the whole texture is 40 times faster. */
526            glTexImage2D(GL_TEXTURE_2D, 0, INTERNAL_FORMAT,
527                         m_size.x / 2, m_size.y * 2, 0,
528                         TEXTURE_FORMAT, TEXTURE_TYPE, m_pixels);
529#else
530            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, m_frame * m_size.y / 2,
531                            m_size.x / 2, m_size.y / 2,
532                            TEXTURE_FORMAT, TEXTURE_TYPE,
533                            m_pixels + m_size.x * m_size.y / 4 * m_frame);
534#endif
535        }
536
537        m_shader->Bind();
538        m_shader->SetUniform(m_texeluni, m_texel_settings);
539        m_shader->SetUniform(m_zoomuni, m_zoom_settings);
540#if !defined __CELLOS_LV2__ && !defined __ANDROID__
541        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
542        glEnableVertexAttribArray(m_vertexattrib);
543        glVertexAttribPointer(m_vertexattrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
544
545        glBindBuffer(GL_ARRAY_BUFFER, m_tbo);
546        glEnableVertexAttribArray(m_texattrib);
547        glVertexAttribPointer(m_texattrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
548#elif !defined __CELLOS_LV2__ && !defined __ANDROID__
549        /* Never used for now */
550        //glEnableVertexAttribArray(m_vertexattrib);
551        //glVertexAttribPointer(m_vertexattrib, 2, GL_FLOAT, GL_FALSE, 0, vertices);
552#else
553        glEnableClientState(GL_VERTEX_ARRAY);
554        glVertexPointer(2, GL_FLOAT, 0, vertices);
555        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
556        glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
557#endif
558
559        glDrawArrays(GL_TRIANGLES, 0, 6);
560
561#if !defined __CELLOS_LV2__ && !defined __ANDROID__
562        glDisableVertexAttribArray(m_vertexattrib);
563        glDisableVertexAttribArray(m_texattrib);
564        glBindBuffer(GL_ARRAY_BUFFER, 0);
565#elif !defined __CELLOS_LV2__ && !defined __ANDROID__
566        /* Never used for now */
567        //glDisableVertexAttribArray(m_vertexattrib);
568        //glDisableVertexAttribArray(m_texattrib);
569#else
570        glDisableClientState(GL_VERTEX_ARRAY);
571        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
572#endif
573    }
574
575private:
576    static int const MAX_ITERATIONS = 170;
577    static int const PALETTE_STEP = 32;
578
579    ivec2 m_size, m_window_size;
580    double m_window2world;
581    f64vec2 m_texel2world;
582    u8vec4 *m_pixels, *m_tmppixels, *m_palette;
583    Shader *m_shader;
584    GLuint m_texid;
585#if !defined __CELLOS_LV2__ && !defined __ANDROID__
586    GLuint m_vbo, m_tbo;
587    GLuint m_tco;
588#endif
589    int m_vertexattrib, m_texattrib, m_texeluni, m_zoomuni;
590    int m_frame, m_dirty[4];
591    bool m_ready;
592
593    f64cmplx m_center;
594    double m_zoom_speed, m_radius;
595    vec4 m_texel_settings;
596    mat4 m_zoom_settings;
597    f64cmplx m_deltashift[4];
598    double m_deltascale[4];
599
600    /* Debug information */
601    Text *m_centertext, *m_mousetext, *m_zoomtext;
602};
603
604int main(int argc, char **argv)
605{
606#if defined _WIN32
607    _chdir("../..");
608#endif
609
610    Application app("Tutorial 3: Fractal", ivec2(640, 480), 60.0f);
611
612    new DebugFps(5, 5);
613    new Fractal(ivec2(640, 480));
614    //new DebugRecord("fractalol.ogm", 60.0f);
615
616    app.Run();
617
618    return EXIT_SUCCESS;
619}
620
Note: See TracBrowser for help on using the repository browser.