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

Last change on this file since 1172 was 1172, checked in by sam, 9 years ago

test: fix logic bugs in two tutorials.

  • Property svn:keywords set to Id
File size: 30.3 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#include <cmath>
17
18#include "core.h"
19#include "lolgl.h"
20#include "loldebug.h"
21
22using namespace std;
23using namespace lol;
24
25#if USE_SDL && defined __APPLE__
26#   include <SDL_main.h>
27#endif
28
29#if defined _WIN32
30#   undef main /* FIXME: still needed? */
31#   include <direct.h>
32#endif
33
34#ifdef __CELLOS_LV2__
35static GLint const INTERNAL_FORMAT = GL_ARGB_SCE;
36static GLenum const TEXTURE_FORMAT = GL_BGRA;
37static GLenum const TEXTURE_TYPE = GL_UNSIGNED_INT_8_8_8_8_REV;
38#elif defined __native_client__
39static GLint const INTERNAL_FORMAT = GL_RGBA;
40static GLenum const TEXTURE_FORMAT = GL_RGBA;
41static GLenum const TEXTURE_TYPE = GL_UNSIGNED_BYTE;
42#else
43/* Seems efficient for little endian textures */
44static GLint const INTERNAL_FORMAT = GL_RGBA;
45static GLenum const TEXTURE_FORMAT = GL_BGRA;
46static GLenum const TEXTURE_TYPE = GL_UNSIGNED_INT_8_8_8_8_REV;
47#endif
48
49class Fractal : public WorldEntity
50{
51public:
52    Fractal(ivec2 const &size)
53    {
54        /* Ensure texture size is a multiple of 16 for better aligned
55         * data access. Store the dimensions of a texel for our shader,
56         * as well as the half-size of the screen. */
57        m_size = size;
58        m_size.x = (m_size.x + 15) & ~15;
59        m_size.y = (m_size.y + 15) & ~15;
60        /* FIXME: casts are necessary because of missing operators */
61        m_texel_settings = vec4(1.0, 1.0, 2.0, 2.0) / (vec4)m_size.xyxy;
62        m_screen_settings = vec4(1.0, 1.0, 0.5, 0.5) * (vec4)m_size.xyxy;
63
64        /* Window size decides the world aspect ratio. For instance, 640×480
65         * will be mapped to (-0.66,-0.5) - (0.66,0.5). */
66#if !defined __native_client__
67        m_window_size = Video::GetSize();
68#else
69        /* FIXME: it's illegal to call this on the game thread! */
70        m_window_size = ivec2(640, 480);
71#endif
72        if (m_window_size.y < m_window_size.x)
73            m_window2world = 0.5 / m_window_size.y;
74        else
75            m_window2world = 0.5 / m_window_size.x;
76        m_texel2world = (vec2)m_window_size / (vec2)m_size
77                                            * (vec2)m_window2world;
78
79        m_oldmouse = ivec2(0, 0);
80
81        m_pixels = new u8vec4[m_size.x * m_size.y];
82        m_tmppixels = new u8vec4[m_size.x / 2 * m_size.y / 2];
83        m_frame = -1;
84        m_slices = 4;
85        for (int i = 0; i < 4; i++)
86        {
87            m_deltashift[i] = 0.0;
88            m_deltascale[i] = 1.0;
89            m_dirty[i] = 2;
90        }
91#if defined __CELLOS_LV2__
92        //m_center = f64cmplx(-.22815528839841, -1.11514249704382);
93        //m_center = f64cmplx(0.001643721971153, 0.822467633298876);
94        m_center = f64cmplx(-0.65823419062254, 0.50221777363480);
95        m_zoom_speed = -0.000025;
96#else
97        m_center = -0.75;
98        m_zoom_speed = 0.0;
99#endif
100        m_translate = 0;
101        m_radius = 5.0;
102        m_ready = false;
103        m_drag = false;
104
105        m_palette = new u8vec4[(MAX_ITERATIONS + 1) * PALETTE_STEP];
106        for (int i = 0; i < (MAX_ITERATIONS + 1) * PALETTE_STEP; i++)
107        {
108            double f = (double)i / PALETTE_STEP;
109
110            double r = 0.5 * sin(f * 0.27 + 2.0) + 0.5;
111            double g = 0.5 * sin(f * 0.17 - 1.8) + 0.5;
112            double b = 0.5 * sin(f * 0.21 - 2.6) + 0.5;
113
114            if (f < 7.0)
115            {
116                f = f < 1.0 ? 0.0 : (f - 1.0) / 6.0;
117                r *= f;
118                g *= f;
119                b *= f;
120            }
121
122            uint8_t red = r * 255.99f;
123            uint8_t green = g * 255.99f;
124            uint8_t blue = b * 255.99f;
125#if defined __CELLOS_LV2__
126            m_palette[i] = u8vec4(255, red, green, blue);
127#elif defined __native_client__
128            m_palette[i] = u8vec4(red, green, blue, 255);
129#else
130            m_palette[i] = u8vec4(blue, green, red, 255);
131#endif
132        }
133
134#if !defined __native_client__
135        m_centertext = new Text(NULL, "gfx/font/ascii.png");
136        m_centertext->SetPos(ivec3(5, m_window_size.y - 15, 1));
137        Ticker::Ref(m_centertext);
138
139        m_mousetext = new Text(NULL, "gfx/font/ascii.png");
140        m_mousetext->SetPos(ivec3(5, m_window_size.y - 29, 1));
141        Ticker::Ref(m_mousetext);
142
143        m_zoomtext = new Text(NULL, "gfx/font/ascii.png");
144        m_zoomtext->SetPos(ivec3(5, m_window_size.y - 43, 1));
145        Ticker::Ref(m_zoomtext);
146#endif
147
148        position = ivec3(0, 0, 0);
149        bbox[0] = position;
150        bbox[1] = ivec3(m_window_size, 0);
151        Input::TrackMouse(this);
152
153        /* Spawn worker threads and wait for their readiness. */
154        for (int i = 0; i < MAX_THREADS; i++)
155            m_threads[i] = new Thread(DoWorkHelper, this);
156        for (int i = 0; i < MAX_THREADS; i++)
157            m_spawnqueue.Pop();
158    }
159
160    ~Fractal()
161    {
162        /* Signal worker threads for completion and wait for
163         * them to quit. */
164        for (int i = 0; i < MAX_THREADS; i++)
165            m_jobqueue.Push(-1);
166        for (int i = 0; i < MAX_THREADS; i++)
167            m_donequeue.Pop();
168
169        Input::UntrackMouse(this);
170#if !defined __native_client__
171        Ticker::Unref(m_centertext);
172        Ticker::Unref(m_mousetext);
173        Ticker::Unref(m_zoomtext);
174#endif
175        delete m_pixels;
176        delete m_tmppixels;
177        delete m_palette;
178    }
179
180    inline f64cmplx TexelToWorldOffset(vec2 texel)
181    {
182        double dx = (0.5 + texel.x - m_size.x / 2) * m_texel2world.x;
183        double dy = (0.5 + m_size.y / 2 - texel.y) * m_texel2world.y;
184        return m_radius * f64cmplx(dx, dy);
185    }
186
187    inline f64cmplx ScreenToWorldOffset(vec2 pixel)
188    {
189        /* No 0.5 offset here, because we want to be able to position the
190         * mouse at (0,0) exactly. */
191        double dx = pixel.x - m_window_size.x / 2;
192        double dy = m_window_size.y / 2 - pixel.y;
193        return m_radius * m_window2world * f64cmplx(dx, dy);
194    }
195
196    virtual void TickGame(float deltams)
197    {
198        WorldEntity::TickGame(deltams);
199
200        int prev_frame = m_frame;
201        m_frame = (m_frame + 1) % 4;
202
203        f64cmplx worldmouse = m_center + ScreenToWorldOffset(mousepos);
204
205        ivec3 buttons = Input::GetMouseButtons();
206#if !defined __CELLOS_LV2__
207        if (buttons[1])
208        {
209            if (!m_drag)
210            {
211                m_oldmouse = mousepos;
212                m_drag = true;
213            }
214            m_translate = ScreenToWorldOffset(m_oldmouse)
215                        - ScreenToWorldOffset(mousepos);
216            /* XXX: the purpose of this hack is to avoid translating by
217             * an exact number of pixels. If this were to happen, the step()
218             * optimisation for i915 cards in our shader would behave
219             * incorrectly because a quarter of the pixels in the image
220             * would have tie rankings in the distance calculation. */
221            m_translate *= 1023.0 / 1024.0;
222            m_oldmouse = mousepos;
223        }
224        else
225        {
226            m_drag = false;
227            if (m_translate != 0.0)
228            {
229                m_translate *= pow(2.0, -deltams * 0.005);
230                if (m_translate.norm() / m_radius < 1e-4)
231                    m_translate = 0.0;
232            }
233        }
234
235        if ((buttons[0] || buttons[2]) && mousepos.x != -1)
236        {
237            double zoom = buttons[0] ? -0.0005 : 0.0005;
238            m_zoom_speed += deltams * zoom;
239            if (m_zoom_speed / zoom > 5)
240                m_zoom_speed = 5 * zoom;
241        }
242        else if (m_zoom_speed)
243        {
244            m_zoom_speed *= pow(2.0, -deltams * 0.005);
245            if (abs(m_zoom_speed) < 1e-5 || m_drag)
246                m_zoom_speed = 0.0;
247        }
248#endif
249
250        if (m_zoom_speed || m_translate != 0.0)
251        {
252            f64cmplx oldcenter = m_center;
253            double oldradius = m_radius;
254            double zoom = pow(2.0, deltams * m_zoom_speed);
255            if (m_radius * zoom > 8.0)
256            {
257                m_zoom_speed *= -1.0;
258                zoom = 8.0 / m_radius;
259            }
260            else if (m_radius * zoom < 1e-14)
261            {
262                m_zoom_speed *= -1.0;
263                zoom = 1e-14 / m_radius;
264            }
265            m_radius *= zoom;
266#if !defined __CELLOS_LV2__
267            m_center += m_translate;
268            m_center = (m_center - worldmouse) * zoom + worldmouse;
269            worldmouse = m_center + ScreenToWorldOffset(mousepos);
270#endif
271
272            /* Store the transformation properties to go from m_frame - 1
273             * to m_frame. */
274            m_deltashift[prev_frame] = (m_center - oldcenter) / oldradius;
275            m_deltashift[prev_frame].x /= m_size.x * m_texel2world.x;
276            m_deltashift[prev_frame].y /= m_size.y * m_texel2world.y;
277            m_deltascale[prev_frame] = m_radius / oldradius;
278            m_dirty[0] = m_dirty[1] = m_dirty[2] = m_dirty[3] = 2;
279        }
280        else
281        {
282            /* If settings didn't change, set transformation from previous
283             * frame to identity. */
284            m_deltashift[prev_frame] = 0.0;
285            m_deltascale[prev_frame] = 1.0;
286        }
287
288        /* Transformation from current frame to current frame is always
289         * identity. */
290        m_zoom_settings[m_frame][0] = 0.0f;
291        m_zoom_settings[m_frame][1] = 0.0f;
292        m_zoom_settings[m_frame][2] = 1.0f;
293
294        /* Compute transformation from other frames to current frame */
295        for (int i = 0; i < 3; i++)
296        {
297            int prev_index = (m_frame + 4 - i) % 4;
298            int cur_index = (m_frame + 3 - i) % 4;
299
300            m_zoom_settings[cur_index][0] = m_zoom_settings[prev_index][0] * m_deltascale[cur_index] + m_deltashift[cur_index].x;
301            m_zoom_settings[cur_index][1] = m_zoom_settings[prev_index][1] * m_deltascale[cur_index] + m_deltashift[cur_index].y;
302            m_zoom_settings[cur_index][2] = m_zoom_settings[prev_index][2] * m_deltascale[cur_index];
303        }
304
305        /* Precompute texture offset change instead of doing it in GLSL */
306        for (int i = 0; i < 4; i++)
307        {
308            m_zoom_settings[i][0] += 0.5 * (1.0 - m_zoom_settings[i][2]);
309            m_zoom_settings[i][1] -= 0.5 * (1.0 - m_zoom_settings[i][2]);
310        }
311
312#if !defined __native_client__
313        char buf[128];
314        sprintf(buf, "center: %+16.14f%+16.14fi", m_center.x, m_center.y);
315        m_centertext->SetText(buf);
316        sprintf(buf, " mouse: %+16.14f%+16.14fi", worldmouse.x, worldmouse.y);
317        m_mousetext->SetText(buf);
318        sprintf(buf, "  zoom: %g", 1.0 / m_radius);
319        m_zoomtext->SetText(buf);
320#endif
321
322        if (m_dirty[m_frame])
323        {
324            m_dirty[m_frame]--;
325
326            for (int i = 0; i < m_size.y; i += MAX_LINES * 2)
327                m_jobqueue.Push(i);
328        }
329    }
330
331    static void *DoWorkHelper(void *data)
332    {
333        Fractal *that = (Fractal *)data;
334        that->m_spawnqueue.Push(0);
335        for ( ; ; )
336        {
337            int line = that->m_jobqueue.Pop();
338            if (line == -1)
339                break;
340            that->DoWork(line);
341            that->m_donequeue.Push(0);
342        }
343        that->m_donequeue.Push(0);
344        return NULL;
345    };
346
347    void DoWork(int line)
348    {
349        double const maxsqlen = 1024;
350        double const k1 = 1.0 / (1 << 10) / (std::log(maxsqlen) / std::log(2.0));
351
352        int jmin = ((m_frame + 1) % 4) / 2 + line;
353        int jmax = jmin + MAX_LINES * 2;
354        if (jmax > m_size.y)
355            jmax = m_size.y;
356        u8vec4 *m_pixelstart = m_pixels
357                             + m_size.x * (m_size.y / 4 * m_frame + line / 4);
358
359        for (int j = jmin; j < jmax; j += 2)
360        for (int i = m_frame % 2; i < m_size.x; i += 2)
361        {
362            f64cmplx z0 = m_center + TexelToWorldOffset(ivec2(i, j));
363            f64cmplx z1, z2, z3, r0 = z0;
364            //f64cmplx r0(0.28693186889504513, 0.014286693904085048);
365            //f64cmplx r0(0.001643721971153, 0.822467633298876);
366            //f64cmplx r0(-1.207205434596, 0.315432814901);
367            //f64cmplx r0(-0.79192956889854, -0.14632423080102);
368            //f64cmplx r0(0.3245046418497685, 0.04855101129280834);
369            int iter = MAX_ITERATIONS - 4;
370            for (;;)
371            {
372                /* Unroll the loop: tests are more expensive to do at each
373                 * iteration than the few extra multiplications. */
374                z1 = z0 * z0 + r0;
375                z2 = z1 * z1 + r0;
376                z3 = z2 * z2 + r0;
377                z0 = z3 * z3 + r0;
378                if (sqlen(z0) >= maxsqlen)
379                    break;
380                iter -= 4;
381                if (iter < 4)
382                    break;
383            }
384
385            if (iter)
386            {
387                double n = sqlen(z0);
388
389                if (sqlen(z1) >= maxsqlen) { iter += 3; n = sqlen(z1); }
390                else if (sqlen(z2) >= maxsqlen) { iter += 2; n = sqlen(z2); }
391                else if (sqlen(z3) >= maxsqlen) { iter += 1; n = sqlen(z3); }
392
393                if (n > maxsqlen * maxsqlen)
394                    n = maxsqlen * maxsqlen;
395
396                /* Approximate log(sqrt(n))/log(sqrt(maxsqlen)) */
397                double f = iter;
398                union { double n; uint64_t x; } u = { n };
399                double k = (u.x >> 42) - (((1 << 10) - 1) << 10);
400                k *= k1;
401
402                /* Approximate log2(k) in [1,2]. */
403                f += (- 0.344847817623168308695977510213252644185 * k
404                      + 2.024664188044341212602376988171727038739) * k
405                      - 1.674876738008591047163498125918330313237;
406
407                *m_pixelstart++ = m_palette[(int)(f * PALETTE_STEP)];
408            }
409            else
410            {
411#if defined __CELLOS_LV2__
412                *m_pixelstart++ = u8vec4(255, 0, 0, 0);
413#else
414                *m_pixelstart++ = u8vec4(0, 0, 0, 255);
415#endif
416            }
417        }
418    }
419
420    virtual void TickDraw(float deltams)
421    {
422        WorldEntity::TickDraw(deltams);
423
424        static float const vertices[] =
425        {
426             1.0f,  1.0f,
427            -1.0f,  1.0f,
428            -1.0f, -1.0f,
429            -1.0f, -1.0f,
430             1.0f, -1.0f,
431             1.0f,  1.0f,
432        };
433
434        static float const texcoords[] =
435        {
436             1.0f,  1.0f,
437             0.0f,  1.0f,
438             0.0f,  0.0f,
439             0.0f,  0.0f,
440             1.0f,  0.0f,
441             1.0f,  1.0f,
442        };
443
444        if (!m_ready)
445        {
446            /* Create a texture of half the width and twice the height
447             * so that we can upload four different subimages each frame. */
448            glGenTextures(1, &m_texid);
449            glBindTexture(GL_TEXTURE_2D, m_texid);
450            glTexImage2D(GL_TEXTURE_2D, 0, INTERNAL_FORMAT,
451                         m_size.x / 2, m_size.y * 2, 0,
452                         TEXTURE_FORMAT, TEXTURE_TYPE, m_pixels);
453#if defined __CELLOS_LV2__
454            /* We need this hint because by default the storage type is
455             * GL_TEXTURE_SWIZZLED_GPU_SCE. */
456            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_ALLOCATION_HINT_SCE,
457                            GL_TEXTURE_TILED_GPU_SCE);
458#endif
459            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
460            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
461
462            m_shader = Shader::Create(
463#if !defined __CELLOS_LV2__
464#if !defined HAVE_GLES_2X
465                "#version 120\n"
466#else
467                "precision highp float;"
468#endif
469                ""
470                "uniform mat4 u_ZoomSettings;"
471                "uniform vec4 u_TexelSize;"
472                "uniform vec4 u_ScreenSize;"
473                ""
474                "attribute vec2 a_TexCoord;"
475                "attribute vec2 a_Vertex;"
476                ""
477                "varying vec4 v_CenterX, v_CenterY, v_IndexX, v_IndexY;"
478                ""
479                "void main(void)"
480                "{"
481                "    gl_Position = vec4(a_Vertex, 0.0, 1.0);"
482                     /* Center point in [-.5,.5], apply zoom and translation
483                      * transformation, and go back to texture coordinates
484                      * in [0,1]. That's the ideal point we would like to
485                      * compute the value for. Then add or remove half the
486                      * size of a texel: the distance from this new point to
487                      * the final point will be our error. */
488                "    vec4 offsets = vec4(0.5, -0.5, 0.015625, -0.015625);"
489                "    vec4 zoomscale = vec4(u_ZoomSettings[0][2],"
490                "                          u_ZoomSettings[1][2],"
491                "                          u_ZoomSettings[2][2],"
492                "                          u_ZoomSettings[3][2]);"
493                "    vec4 zoomtx = vec4(u_ZoomSettings[0][0],"
494                "                       u_ZoomSettings[1][0],"
495                "                       u_ZoomSettings[2][0],"
496                "                       u_ZoomSettings[3][0]);"
497                "    vec4 zoomty = vec4(u_ZoomSettings[0][1],"
498                "                       u_ZoomSettings[1][1],"
499                "                       u_ZoomSettings[2][1],"
500                "                       u_ZoomSettings[3][1]);"
501                "    v_CenterX = zoomscale * a_TexCoord.x + zoomtx"
502                "              + offsets.xyxy * u_TexelSize.x;"
503                "    v_CenterY = zoomscale * a_TexCoord.y - zoomty"
504                "              + offsets.xyyx * u_TexelSize.y;"
505                     /* Precompute the multiple of one texel where our ideal
506                      * point lies. The fragment shader will call floor() on
507                      * this value. We add or remove a slight offset to avoid
508                      * rounding issues at the image's edges. */
509                "    v_IndexX = v_CenterX * u_ScreenSize.z - offsets.zwzw;"
510                "    v_IndexY = v_CenterY * u_ScreenSize.w - offsets.zwwz;"
511                "}",
512
513#if !defined HAVE_GLES_2X
514                "#version 120\n"
515#else
516                "precision highp float;"
517#endif
518                ""
519                "uniform vec4 u_TexelSize;"
520                "uniform sampler2D u_Texture;"
521                ""
522                "varying vec4 v_CenterX, v_CenterY, v_IndexX, v_IndexY;"
523                ""
524                "void main(void)"
525                "{"
526                "    vec4 v05 = vec4(0.5, 0.5, 0.5, 0.5);"
527                "    vec4 rx, ry, t0, dx, dy, dd;"
528                     /* Get a pixel coordinate from each slice into rx & ry */
529                "    rx = u_TexelSize.x + u_TexelSize.z * floor(v_IndexX);"
530                "    ry = u_TexelSize.y + u_TexelSize.w * floor(v_IndexY);"
531                     /* Compute inverse distance to expected pixel in dd,
532                      * and put zero if we fall outside the texture. */
533                "    t0 = step(abs(rx - v05), v05) * step(abs(ry - v05), v05);"
534                "    dx = rx - v_CenterX;"
535                "    dy = ry - v_CenterY;"
536                //"    vec4 dd = t0 * (abs(dx) + abs(dy));"
537                //"    vec4 dd = t0 / (0.001 + sqrt((dx * dx) + (dy * dy)));"
538                "    dd = t0 / (0.000001 + (dx * dx) + (dy * dy));"
539                     /* Modify Y coordinate to select proper quarter. */
540                "    ry = ry * 0.25 + vec4(0.0, 0.25, 0.5, 0.75);"
541                ""
542#if 1
543                "\n#if 0\n" /* XXX: disabled until we can autodetect i915 */
544                     /* t1.x <-- dd.x > dd.y */
545                     /* t1.y <-- dd.z > dd.w */
546                "    vec2 t1 = step(dd.xz, dd.yw);"
547                     /* ret.x <-- max(rx.x, rx.y) wrt. t1.x */
548                     /* ret.y <-- max(rx.z, rx.w) wrt. t1.y */
549                     /* ret.z <-- max(ry.x, ry.y) wrt. t1.x */
550                     /* ret.w <-- max(ry.z, ry.w) wrt. t1.y */
551                "    vec4 ret = mix(vec4(rx.xz, ry.xz),"
552                "                   vec4(rx.yw, ry.yw), t1.xyxy);"
553                     /* dd.x <-- max(dd.x, dd.y) */
554                     /* dd.z <-- max(dd.z, dd.w) */
555                "    dd.xy = mix(dd.xz, dd.yw, t1);"
556                     /* t2 <-- dd.x > dd.z */
557                "    float t2 = step(dd.x, dd.y);"
558                     /* ret.x <-- max(ret.x, ret.y); */
559                     /* ret.y <-- max(ret.z, ret.yw; */
560                "    ret.xy = mix(ret.xz, ret.yw, t2);"
561                "\n#else\n"
562                     /* Fallback for i915 cards -- the trick to reduce the
563                      * number of operations is to compute both step(a,b)
564                      * and step(b,a) and hope that their sum is 1. This is
565                      * almost always the case, and when it isn't we can
566                      * afford to have a few wrong pixels. However, a real
567                      * problem is when panning the image, because half the
568                      * screen is likely to flicker. To avoid this problem,
569                      * we cheat a little (see m_translate comment above). */
570                "    vec4 t1 = step(dd.xzyw, dd.ywxz);"
571                "    vec4 ret = vec4(rx.xz, ry.xz) * t1.zwzw"
572                "             + vec4(rx.yw, ry.yw) * t1.xyxy;"
573                "    dd.xy = dd.xz * t1.zw + dd.yw * t1.xy;"
574                "    vec2 t2 = step(dd.xy, dd.yx);"
575                "    ret.xy = ret.xz * t2.yy + ret.yw * t2.xx;"
576                "\n#endif\n"
577                     /* Nearest neighbour */
578                "    gl_FragColor = texture2D(u_Texture, ret.xy);"
579#else
580                     /* Alternate version: some kind of linear interpolation */
581                "    vec4 p0 = texture2D(u_Texture, vec2(rx.x, ry.x));"
582                "    vec4 p1 = texture2D(u_Texture, vec2(rx.y, ry.y));"
583                "    vec4 p2 = texture2D(u_Texture, vec2(rx.z, ry.z));"
584                "    vec4 p3 = texture2D(u_Texture, vec2(rx.w, ry.w));"
585                "    gl_FragColor = 1.0 / (dd.x + dd.y + dd.z + dd.w)"
586                "          * (dd.x * p0 + dd.y * p1 + dd.z * p2 + dd.w * p3);"
587#endif
588                "}"
589#else
590                "void main(float4 a_Vertex : POSITION,"
591                "          float2 a_TexCoord : TEXCOORD0,"
592                "          uniform float4x4 u_ZoomSettings,"
593                "          uniform float4 u_TexelSize,"
594                "          uniform float4 u_ScreenSize,"
595                "          out float4 out_Position : POSITION,"
596                "          out float4 v_CenterX,"
597                "          out float4 v_CenterY,"
598                "          out float4 v_IndexX,"
599                "          out float4 v_IndexY)"
600                "{"
601                "    out_Position = a_Vertex;"
602                "    float4 offsets = float4(0.5, -0.5, 0.015625, -0.015625);"
603                "    float4 zoomscale = float4(u_ZoomSettings[2][0],"
604                "                              u_ZoomSettings[2][1],"
605                "                              u_ZoomSettings[2][2],"
606                "                              u_ZoomSettings[2][3]);"
607                "    float4 zoomtx = float4(u_ZoomSettings[0][0],"
608                "                           u_ZoomSettings[0][1],"
609                "                           u_ZoomSettings[0][2],"
610                "                           u_ZoomSettings[0][3]);"
611                "    float4 zoomty = float4(u_ZoomSettings[1][0],"
612                "                           u_ZoomSettings[1][1],"
613                "                           u_ZoomSettings[1][2],"
614                "                           u_ZoomSettings[1][3]);"
615                "    v_CenterX = zoomscale * a_TexCoord.x + zoomtx"
616                "              + offsets.xyxy * u_TexelSize.x;"
617                "    v_CenterY = zoomscale * a_TexCoord.y - zoomty"
618                "              + offsets.xyyx * u_TexelSize.y;"
619                "    v_IndexX = v_CenterX * u_ScreenSize.z - offsets.zwzw;"
620                "    v_IndexY = v_CenterY * u_ScreenSize.w - offsets.zwwz;"
621                "}",
622
623                "void main(in float4 v_CenterX,"
624                "          in float4 v_CenterY,"
625                "          in float4 v_IndexX,"
626                "          in float4 v_IndexY,"
627                "          uniform float4 u_TexelSize2,"
628                "          uniform sampler2D u_Texture,"
629                "          out float4 out_FragColor : COLOR)"
630                "{"
631                "    float4 v05 = float4(0.5, 0.5, 0.5, 0.5);"
632                "    float4 rx, ry, t0, dx, dy, dd;"
633                "    rx = u_TexelSize2.x + u_TexelSize2.z * floor(v_IndexX);"
634                "    ry = u_TexelSize2.y + u_TexelSize2.w * floor(v_IndexY);"
635                "    t0 = step(abs(rx - v05), v05) * step(abs(ry - v05), v05);"
636                "    dx = rx - v_CenterX;"
637                "    dy = ry - v_CenterY;"
638                "    dd = t0 / (0.000001 + (dx * dx) + (dy * dy));"
639                "    ry = ry * 0.25 + float4(0.0, 0.25, 0.5, 0.75);"
640                "    float2 t1 = step(dd.xz, dd.yw);"
641                "    float4 ret = lerp(float4(rx.xz, ry.xz),"
642                "                      float4(rx.yw, ry.yw), t1.xyxy);"
643                "    dd.xy = lerp(dd.xz, dd.yw, t1);"
644                "    float t2 = step(dd.x, dd.y);"
645                "    ret.xy = lerp(ret.xz, ret.yw, t2);"
646                "    out_FragColor = tex2D(u_Texture, ret.xy);"
647                "}"
648#endif
649            );
650            m_vertexattrib = m_shader->GetAttribLocation("a_Vertex");
651            m_texattrib = m_shader->GetAttribLocation("a_TexCoord");
652            m_texeluni = m_shader->GetUniformLocation("u_TexelSize");
653#if defined __CELLOS_LV2__
654            m_texeluni2 = m_shader->GetUniformLocation("u_TexelSize2");
655#endif
656            m_screenuni = m_shader->GetUniformLocation("u_ScreenSize");
657            m_zoomuni = m_shader->GetUniformLocation("u_ZoomSettings");
658            m_ready = true;
659
660#if !defined __CELLOS_LV2__ && !defined __ANDROID__
661            /* Method 1: store vertex buffer on the GPU memory */
662            glGenBuffers(1, &m_vbo);
663            glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
664            glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices,
665                         GL_STATIC_DRAW);
666            glGenBuffers(1, &m_tbo);
667            glBindBuffer(GL_ARRAY_BUFFER, m_tbo);
668            glBufferData(GL_ARRAY_BUFFER, sizeof(texcoords), texcoords,
669                         GL_STATIC_DRAW);
670#elif !defined __CELLOS_LV2__ && !defined __ANDROID__
671            /* Method 2: upload vertex information at each frame */
672#else
673#endif
674
675            /* FIXME: this object never cleans up */
676        }
677
678#if !defined HAVE_GLES_2X
679        glEnable(GL_TEXTURE_2D);
680#endif
681        glBindTexture(GL_TEXTURE_2D, m_texid);
682
683        if (m_dirty[m_frame])
684        {
685            for (int i = 0; i < m_size.y; i += MAX_LINES * 2)
686                m_donequeue.Pop();
687
688            m_dirty[m_frame]--;
689
690#ifdef __CELLOS_LV2__
691            /* glTexSubImage2D is extremely slow on the PS3, to the point
692             * that uploading the whole texture is 40 times faster. */
693            glTexImage2D(GL_TEXTURE_2D, 0, INTERNAL_FORMAT,
694                         m_size.x / 2, m_size.y * 2, 0,
695                         TEXTURE_FORMAT, TEXTURE_TYPE, m_pixels);
696#else
697            glTexSubImage2D(GL_TEXTURE_2D, 0, 0, m_frame * m_size.y / 2,
698                            m_size.x / 2, m_size.y / 2,
699                            TEXTURE_FORMAT, TEXTURE_TYPE,
700                            m_pixels + m_size.x * m_size.y / 4 * m_frame);
701#endif
702        }
703
704        m_shader->Bind();
705        m_shader->SetUniform(m_texeluni, m_texel_settings);
706#if defined __CELLOS_LV2__
707        m_shader->SetUniform(m_texeluni2, m_texel_settings);
708#endif
709        m_shader->SetUniform(m_screenuni, m_screen_settings);
710        m_shader->SetUniform(m_zoomuni, m_zoom_settings);
711#if !defined __CELLOS_LV2__ && !defined __ANDROID__
712        glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
713        glEnableVertexAttribArray(m_vertexattrib);
714        glVertexAttribPointer(m_vertexattrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
715
716        glBindBuffer(GL_ARRAY_BUFFER, m_tbo);
717        glEnableVertexAttribArray(m_texattrib);
718        glVertexAttribPointer(m_texattrib, 2, GL_FLOAT, GL_FALSE, 0, 0);
719#elif !defined __CELLOS_LV2__ && !defined __ANDROID__
720        /* Never used for now */
721        //glEnableVertexAttribArray(m_vertexattrib);
722        //glVertexAttribPointer(m_vertexattrib, 2, GL_FLOAT, GL_FALSE, 0, vertices);
723#else
724        glEnableClientState(GL_VERTEX_ARRAY);
725        glVertexPointer(2, GL_FLOAT, 0, vertices);
726        glEnableClientState(GL_TEXTURE_COORD_ARRAY);
727        glTexCoordPointer(2, GL_FLOAT, 0, texcoords);
728#endif
729
730        glDrawArrays(GL_TRIANGLES, 0, 6);
731
732#if !defined __CELLOS_LV2__ && !defined __ANDROID__
733        glDisableVertexAttribArray(m_vertexattrib);
734        glDisableVertexAttribArray(m_texattrib);
735        glBindBuffer(GL_ARRAY_BUFFER, 0);
736#elif !defined __CELLOS_LV2__ && !defined __ANDROID__
737        /* Never used for now */
738        //glDisableVertexAttribArray(m_vertexattrib);
739        //glDisableVertexAttribArray(m_texattrib);
740#else
741        glDisableClientState(GL_VERTEX_ARRAY);
742        glDisableClientState(GL_TEXTURE_COORD_ARRAY);
743#endif
744    }
745
746private:
747    static int const MAX_ITERATIONS = 340;
748    static int const PALETTE_STEP = 32;
749    static int const MAX_THREADS = 8;
750    static int const MAX_LINES = 8;
751
752    ivec2 m_size, m_window_size, m_oldmouse;
753    double m_window2world;
754    f64vec2 m_texel2world;
755    u8vec4 *m_pixels, *m_tmppixels, *m_palette;
756    Shader *m_shader;
757    GLuint m_texid;
758#if !defined __CELLOS_LV2__ && !defined __ANDROID__
759    GLuint m_vbo, m_tbo;
760    GLuint m_tco;
761#endif
762    int m_vertexattrib, m_texattrib, m_texeluni, m_screenuni, m_zoomuni;
763#if defined __CELLOS_LV2__
764    int m_texeluni2;
765#endif
766    int m_frame, m_slices, m_dirty[4];
767    bool m_ready, m_drag;
768
769    f64cmplx m_center, m_translate;
770    double m_zoom_speed, m_radius;
771    vec4 m_texel_settings, m_screen_settings;
772    mat4 m_zoom_settings;
773    f64cmplx m_deltashift[4];
774    double m_deltascale[4];
775
776    /* Worker threads */
777    Thread *m_threads[MAX_THREADS];
778    Queue<int> m_spawnqueue, m_jobqueue, m_donequeue;
779
780    /* Debug information */
781#if !defined __native_client__
782    Text *m_centertext, *m_mousetext, *m_zoomtext;
783#endif
784};
785
786int main(int argc, char **argv)
787{
788#if defined _WIN32
789    _chdir("../..");
790#endif
791
792    Application app("Tutorial 3: Fractal", ivec2(640, 480), 60.0f);
793
794    new DebugFps(5, 5);
795    new Fractal(ivec2(640, 480));
796    //new DebugRecord("fractalol.ogm", 60.0f);
797
798    app.Run();
799
800    return EXIT_SUCCESS;
801}
802
Note: See TracBrowser for help on using the repository browser.