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

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

ps3: start implementing the PS3 threading system, and port the new
Mandelbrot shader code to Cg.

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