source: trunk/test/tutorial/03_fractal.cpp @ 1300

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

core: prefix some member variables with m_ for clarity.

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