Context Navigation

source: trunk/test/tutorial/tut03.cpp @ 1147
Tweet

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: