Project

General

Profile

Download (27.1 KB) Statistics
| Branch: | Revision:

library / src / main / res / raw / main_vertex_shader.glsl @ 81a0b906

1
//////////////////////////////////////////////////////////////////////////////////////////////
2
// Copyright 2016 Leszek Koltunski                                                          //
3
//                                                                                          //
4
// This file is part of Distorted.                                                          //
5
//                                                                                          //
6
// Distorted is free software: you can redistribute it and/or modify                        //
7
// it under the terms of the GNU General Public License as published by                     //
8
// the Free Software Foundation, either version 2 of the License, or                        //
9
// (at your option) any later version.                                                      //
10
//                                                                                          //
11
// Distorted is distributed in the hope that it will be useful,                             //
12
// but WITHOUT ANY WARRANTY; without even the implied warranty of                           //
13
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the                            //
14
// GNU General Public License for more details.                                             //
15
//                                                                                          //
16
// You should have received a copy of the GNU General Public License                        // 
17
// along with Distorted.  If not, see <http://www.gnu.org/licenses/>.                       //
18
//////////////////////////////////////////////////////////////////////////////////////////////
19

    
20
precision lowp float;
21

    
22
uniform vec3 u_objD;                 // half of object width x half of object height X half the depth;
23
                                     // point (0,0,0) is the center of the object
24

    
25
uniform float u_Depth;               // max absolute value of v.z ; beyond that the vertex would be culled by the near or far planes.
26
                                     // I read OpenGL ES has a built-in uniform variable gl_DepthRange.near = n,
27
                                     // .far = f, .diff = f-n so maybe u_Depth is redundant
28
                                     // Update: this struct is only available in fragment shaders
29
                                
30
uniform mat4 u_MVPMatrix;            // the combined model/view/projection matrix.
31
uniform mat4 u_MVMatrix;             // the combined model/view matrix.
32
		 
33
attribute vec3 a_Position;           // Per-vertex position.
34
attribute vec3 a_Normal;             // Per-vertex normal vector.
35
attribute vec2 a_TexCoordinate;      // Per-vertex texture coordinate.
36
		  
37
varying vec3 v_Position;             //
38
varying vec3 v_Normal;               //
39
varying vec2 v_TexCoordinate;        //
40

    
41
uniform int vNumEffects;             // total number of vertex effects
42

    
43
#if NUM_VERTEX>0
44
uniform int vType[NUM_VERTEX];       // their types.
45
uniform vec4 vUniforms[3*NUM_VERTEX];// i-th effect is 3 consecutive vec4's: [3*i], [3*i+1], [3*i+2].
46
                                     // The first vec4 is the Interpolated values,
47
                                     // next is half cache half Center, the third -  the Region.
48

    
49
//////////////////////////////////////////////////////////////////////////////////////////////
50
// HELPER FUNCTIONS
51
//////////////////////////////////////////////////////////////////////////////////////////////
52
// The trick below is the if-less version of the
53
//
54
// t = dx<0.0 ? (u_objD.x-v.x) / (u_objD.x-ux) : (u_objD.x+v.x) / (u_objD.x+ux);
55
// h = dy<0.0 ? (u_objD.y-v.y) / (u_objD.y-uy) : (u_objD.y+v.y) / (u_objD.y+uy);
56
// d = min(t,h);
57
//
58
// float d = min(-ps.x/(sign(ps.x)*u_objD.x+p.x),-ps.y/(sign(ps.y)*u_objD.y+p.y))+1.0;
59
//
60
// We still have to avoid division by 0 when p.x = +- u_objD.x or p.y = +- u_objD.y (i.e on the edge of the Object)
61
// We do that by first multiplying the above 'float d' with sign(denominator1*denominator2)^2.
62
//
63
//////////////////////////////////////////////////////////////////////////////////////////////
64
// return degree of the point as defined by the bitmap rectangle
65

    
66
float degree_bitmap(in vec2 S, in vec2 PS)
67
  {
68
  vec2 A = sign(PS)*u_objD.xy + S;
69

    
70
  vec2 signA = sign(A);                           //
71
  vec2 signA_SQ = signA*signA;                    // div = PS/A if A!=0, 0 otherwise.
72
  vec2 div = signA_SQ*PS/(A-(vec2(1,1)-signA_SQ));//
73

    
74
  return 1.0-max(div.x,div.y);
75
  }
76

    
77
//////////////////////////////////////////////////////////////////////////////////////////////
78
// Return degree of the point as defined by the Region. Currently only supports circular regions.
79
//
80
// Let us first introduce some notation.
81
// Let 'PS' be the vector from point P (the current vertex) to point S (the center of the effect).
82
// Let region.xy be the vector from point S to point O (the center point of the region circle)
83
// Let region.z be the radius of the region circle.
84
// (This all should work regardless if S is inside or outside of the circle).
85
//
86
// Then, the degree of a point with respect to a given (circular!) Region is defined by:
87
//
88
// If P is outside the circle, return 0.
89
// Otherwise, let X be the point where the halfline SP meets the region circle - then return |PX|/||SX|,
90
// aka the 'degree' of point P.
91
//
92
// We solve the triangle OPX.
93
// We know the lengths |PO|, |OX| and the angle OPX, because cos(OPX) = cos(180-OPS) = -cos(OPS) = -PS*PO/(|PS|*|PO|)
94
// then from the law of cosines PX^2 + PO^2 - 2*PX*PO*cos(OPX) = OX^2 so PX = -a + sqrt(a^2 + OX^2 - PO^2)
95
// where a = PS*PO/|PS| but we are really looking for d = |PX|/(|PX|+|PS|) = 1/(1+ (|PS|/|PX|) ) and
96
// |PX|/|PS| = -b + sqrt(b^2 + (OX^2-PO^2)/PS^2) where b=PS*PO/|PS|^2 which can be computed with only one sqrt.
97

    
98
float degree_region(in vec4 region, in vec2 PS)
99
  {
100
  vec2 PO  = PS + region.xy;
101
  float D = region.z*region.z-dot(PO,PO);      // D = |OX|^2 - |PO|^2
102

    
103
  if( D<=0.0 ) return 0.0;
104

    
105
  float ps_sq = dot(PS,PS);
106
  float one_over_ps_sq = 1.0/(ps_sq-(sign(ps_sq)-1.0));  // return 1.0 if ps_sq = 0.0
107
                                                         // Important: if we want to write
108
                                                         // b = 1/a if a!=0, b=1 otherwise
109
                                                         // we need to write that as
110
                                                         // b = 1 / ( a-(sign(a)-1) )
111
                                                         // [ and NOT 1 / ( a + 1 - sign(a) ) ]
112
                                                         // because the latter, if 0<a<2^-24,
113
                                                         // will suffer from round-off error and in this case
114
                                                         // a + 1.0 = 1.0 !! so 1 / (a+1-sign(a)) = 1/0 !
115
  float DOT  = dot(PS,PO)*one_over_ps_sq;
116

    
117
  return 1.0 / (1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT));
118
  }
119

    
120
//////////////////////////////////////////////////////////////////////////////////////////////
121
// return min(degree_bitmap,degree_region). Just like degree_region, currently only supports circles.
122

    
123
float degree(in vec4 region, in vec2 S, in vec2 PS)
124
  {
125
  vec2 PO  = PS + region.xy;
126
  float D = region.z*region.z-dot(PO,PO);      // D = |OX|^2 - |PO|^2
127

    
128
  if( D<=0.0 ) return 0.0;
129

    
130
  vec2 A = sign(PS)*u_objD.xy + S;
131
  vec2 signA = sign(A);
132
  vec2 signA_SQ = signA*signA;
133
  vec2 div = signA_SQ*PS/(A-(vec2(1,1)-signA_SQ));
134
  float E = 1.0-max(div.x,div.y);
135

    
136
  float ps_sq = dot(PS,PS);
137
  float one_over_ps_sq = 1.0/(ps_sq-(sign(ps_sq)-1.0));  // return 1.0 if ps_sq = 0.0
138
  float DOT  = dot(PS,PO)*one_over_ps_sq;
139

    
140
  return min(1.0/(1.0 + 1.0/(sqrt(DOT*DOT+D*one_over_ps_sq)-DOT)),E);
141
  }
142

    
143
//////////////////////////////////////////////////////////////////////////////////////////////
144
// Clamp v.z to (-u_Depth,u_Depth) with the following function:
145
// define h to be, say, 0.7; let H=u_Depth
146
//      if v.z < -hH then v.z = (-(1-h)^2 * H^2)/(v.z+(2h-1)H) -H   (function satisfying f(-hH)=-hH, f'(-hH)=1, lim f(x) = -H)
147
// else if v.z >  hH then v.z = (-(1-h)^2 * H^2)/(v.z-(2h-1)H) +H   (function satisfying f(+hH)=+hH, f'(+hH)=1, lim f(x) = +H)
148
// else v.z = v.z
149

    
150
void restrictZ(inout float v)
151
  {
152
  const float h = 0.7;
153
  float signV = 2.0*max(0.0,sign(v))-1.0;
154
  float c = ((1.0-h)*(h-1.0)*u_Depth*u_Depth)/(v-signV*(2.0*h-1.0)*u_Depth) +signV*u_Depth;
155
  float b = max(0.0,sign(abs(v)-h*u_Depth));
156

    
157
  v = b*c+(1.0-b)*v; // Avoid branching: if abs(v)>h*u_Depth, then v=c; otherwise v=v.
158
  }
159

    
160
//////////////////////////////////////////////////////////////////////////////////////////////
161
// DEFORM EFFECT
162
//
163
// Deform the whole shape of the Object by force V. Algorithm is as follows:
164
//
165
// Suppose we apply force (Vx,Vy) at point (Cx,Cy) (i.e. the center of the effect). Then, first of all,
166
// divide the rectangle into 4 smaller rectangles along the 1 horizontal + 1 vertical lines that pass
167
// through (Cx,Cy). Now suppose we have already understood the following case:
168
//
169
// A vertical (0,Vy) force applied to a rectangle (WxH) in size, at center which is the top-left corner
170
// of the rectangle.  (*)
171
//
172
// If we understand (*), then we understand everything, because in order to compute the movement of the
173
// whole rectangle we can apply (*) 8 times: for each one of the 4 sub-rectangles, apply (*) twice,
174
// once for the vertical component of the force vector, the second time for the horizontal one.
175
//
176
// Let's then compute (*):
177
// 1) the top-left point will move by exactly (0,Vy)
178
// 2) we arbitrarily decide that the top-right point will move by (|Vy|/(|Vy|+A*W))*Vy, where A is some
179
//    arbitrary constant (const float A below). The F(V,W) = (|Vy|/(|Vy|+A*W)) comes from the following:
180
//    a) we want F(V,0) = 1
181
//    b) we want lim V->inf (F) = 1
182
//    c) we actually want F() to only depend on W/V, which we have here.
183
// 3) then the top edge of the rectangle will move along the line Vy*G(x), where G(x) = (1 - (A*W/(|Vy|+A*W))*(x/W)^2)
184
// 4) Now we decide that the left edge of the rectangle will move along Vy*H(y), where H(y) = (1 - |y|/(|Vy|+C*|y|))
185
//    where C is again an arbitrary constant. Again, H(y) comes from the requirement that no matter how
186
//    strong we push the left edge of the rectangle up or down, it can never 'go over itself', but its
187
//    length will approach 0 if squeezed very hard.
188
// 5) The last point we need to compute is the left-right motion of the top-right corner (i.e. if we push
189
//    the top-left corner up very hard, we want to have the top-right corner not only move up, but also to
190
//    the left at least a little bit).
191
//    We arbitrarily decide that, in addition to moving up-down by Vy*F(V,W), the corner will also move
192
//    left-right by I(V,W) = B*W*F(V,W), where B is again an arbitrary constant.
193
// 6) combining 3), 4) and 5) together, we arrive at a movement of an arbitrary point (x,y) away from the
194
//    top-left corner:
195
//    X(x,y) = -B*x * (|Vy|/(|Vy|+A*W)) * (1-(y/H)^2)                               (**)
196
//    Y(x,y) = Vy * (1 - |y|/(|Vy|+C*|y|)) * (1 - (A*W/(|Vy|+A*W))*(x/W)^2)         (**)
197
//
198
// We notice that formulas (**) have been construed so that it is possible to continously mirror them
199
// left-right and up-down (i.e. apply not only to the 'bottom-right' rectangle of the 4 subrectangles
200
// but to all 4 of them!).
201
//
202
// Constants:
203
// a) A : valid values: (0,infinity). 'Bendiness' if the surface - the higher A is, the more the surface
204
//        bends. A<=0 destroys the system.
205
// b) B : valid values: <-1,1>. The amount side edges get 'sucked' inwards when we pull the middle of the
206
//        top edge up. B=0 --> not at all, B=1: a looot. B=-0.5: the edges will actually be pushed outwards
207
//        quite a bit. One can also set it to <-1 or >1, but it will look a bit ridiculous.
208
// c) C : valid values: <1,infinity). The derivative of the H(y) function at 0, i.e. the rate of 'squeeze'
209
//        surface gets along the force line. C=1: our point gets pulled very closely to points above it
210
//        even when we apply only small vertical force to it. The higher C is, the more 'uniform' movement
211
//        along the force line is.
212
//        0<=C<1 looks completely ridiculous and C<0 destroys the system.
213

    
214
#ifdef DEFORM
215
void deform(in int effect, inout vec3 v, inout vec3 n)
216
  {
217
  const vec2 ONE = vec2(1.0,1.0);
218

    
219
  const float A = 0.5;
220
  const float B = 0.2;
221
  const float C = 5.0;
222

    
223
  vec2 center = vUniforms[effect+1].yz;
224
  vec2 ps     = center-v.xy;
225
  vec2 aPS    = abs(ps);
226
  vec2 maxps  = u_objD.xy + abs(center);
227
  float d     = degree_region(vUniforms[effect+2],ps);
228
  vec3 force  = vUniforms[effect].xyz * d;
229
  vec2 aForce = abs(force.xy);
230
  float denom = dot(ps+(1.0-d)*force.xy,ps);
231
  float one_over_denom = 1.0/(denom-0.001*(sign(denom)-1.0));
232
  vec2 Aw = A*maxps;
233
  vec2 quot = ps / maxps;
234
  quot = quot*quot;                          // ( (x/W)^2 , (y/H)^2 ) where x,y are distances from V to center
235

    
236
  float denomV = 1.0 / (aForce.y + Aw.x);
237
  float denomH = 1.0 / (aForce.x + Aw.y);
238

    
239
  vec2 vertCorr= ONE - aPS / ( aForce+C*aPS + (ONE-sign(aForce)) );  // avoid division by 0 when force and PS both are 0
240

    
241
  float mvXvert = -B * ps.x * aForce.y * (1.0-quot.y) * denomV;      // impact the vertical   component of the force vector has on horizontal movement
242
  float mvYhorz = -B * ps.y * aForce.x * (1.0-quot.x) * denomH;      // impact the horizontal component of the force vector has on vertical   movement
243
  float mvYvert =  force.y * (1.0-quot.x*Aw.x*denomV) * vertCorr.y;  // impact the vertical   component of the force vector has on vertical   movement
244
  float mvXhorz = -force.x * (1.0-quot.y*Aw.y*denomH) * vertCorr.x;  // impact the horizontal component of the force vector has on horizontal movement
245

    
246
  v.x -= (mvXvert+mvXhorz);
247
  v.y -= (mvYvert+mvYhorz);
248

    
249
  v.z += force.z*d*d*(3.0*d*d -8.0*d +6.0);                          // thick bubble
250
  float b = -(12.0*force.z*d*(1.0-d)*(1.0-d)*(1.0-d))*one_over_denom;//
251

    
252
  n.xy += n.z*b*ps;
253
  }
254
#endif
255

    
256
//////////////////////////////////////////////////////////////////////////////////////////////
257
// DISTORT EFFECT
258
//
259
// Point (Px,Py) gets moved by vector (Wx,Wy,Wz) where Wx/Wy = Vx/Vy i.e. Wx=aVx and Wy=aVy where
260
// a=Py/Sy (N --> when (Px,Py) is above (Sx,Sy)) or a=Px/Sx (W) or a=(w-Px)/(w-Sx) (E) or a=(h-Py)/(h-Sy) (S)
261
// It remains to be computed which of the N,W,E or S case we have: answer: a = min[ Px/Sx , Py/Sy , (w-Px)/(w-Sx) , (h-Py)/(h-Sy) ]
262
// Computations above are valid for screen (0,0)x(w,h) but here we have (-w/2,-h/2)x(w/2,h/2)
263
//
264
// the vertical part
265
// Let |(v.x,v.y),(ux,uy)| = |PS|, ux-v.x=dx,uy-v.y=dy, f(x) (0<=x<=|SX|) be the shape of the side of the bubble.
266
// H(v.x,v.y) = |PS|>|SX| ? 0 : f(|PX|)
267
// N(v.x,v.y) = |PS|>|SX| ? (0,0,1) : ( -(dx/|PS|)sin(beta), -(dy/|PS|)sin(beta), cos(beta) ) where tan(beta) is f'(|PX|)
268
// ( i.e. normalize( dx, dy, -|PS|/f'(|PX|))
269
//
270
// Now we also have to take into account the effect horizontal move by V=(u_dVx[i],u_dVy[i]) will have on the normal vector.
271
// Solution:
272
// 1. Decompose the V into two subcomponents, one parallel to SX and another perpendicular.
273
// 2. Convince yourself (draw!) that the perpendicular component has no effect on normals.
274
// 3. The parallel component changes the length of |SX| by the factor of a=(|SX|-|Vpar|)/|SX| (where the length
275
//    can be negative depending on the direction)
276
// 4. that in turn leaves the x and y parts of the normal unchanged and multiplies the z component by a!
277
//
278
// |Vpar| = (u_dVx[i]*dx - u_dVy[i]*dy) / sqrt(ps_sq) = (Vx*dx-Vy*dy)/ sqrt(ps_sq)  (-Vy because y is inverted)
279
// a =  (|SX| - |Vpar|)/|SX| = 1 - |Vpar|/((sqrt(ps_sq)/(1-d)) = 1 - (1-d)*|Vpar|/sqrt(ps_sq) = 1-(1-d)*(Vx*dx-Vy*dy)/ps_sq
280
//
281
// Side of the bubble
282
//
283
// choose from one of the three bubble shapes: the cone, the thin bubble and the thick bubble
284
// Case 1:
285
// f(t) = t, i.e. f(x) = uz * x/|SX|   (a cone)
286
// -|PS|/f'(|PX|) = -|PS|*|SX|/uz but since ps_sq=|PS|^2 and d=|PX|/|SX| then |PS|*|SX| = ps_sq/(1-d)
287
// so finally -|PS|/f'(|PX|) = -ps_sq/(uz*(1-d))
288
//
289
// Case 2:
290
// f(t) = 3t^2 - 2t^3 --> f(0)=0, f'(0)=0, f'(1)=0, f(1)=1 (the bell curve)
291
// here we have t = x/|SX| which makes f'(|PX|) = 6*uz*|PS|*|PX|/|SX|^3.
292
// so -|PS|/f'(|PX|) = (-|SX|^3)/(6uz|PX|) =  (-|SX|^2) / (6*uz*d) but
293
// d = |PX|/|SX| and ps_sq = |PS|^2 so |SX|^2 = ps_sq/(1-d)^2
294
// so finally -|PS|/f'(|PX|) = -ps_sq/ (6uz*d*(1-d)^2)
295
//
296
// Case 3:
297
// f(t) = 3t^4-8t^3+6t^2 would be better as this satisfies f(0)=0, f'(0)=0, f'(1)=0, f(1)=1,
298
// f(0.5)=0.7 and f'(t)= t(t-1)^2 >=0 for t>=0 so this produces a fuller, thicker bubble!
299
// then -|PS|/f'(|PX|) = (-|PS|*|SX)) / (12uz*d*(d-1)^2) but |PS|*|SX| = ps_sq/(1-d) (see above!)
300
// so finally -|PS|/f'(|PX|) = -ps_sq/ (12uz*d*(1-d)^3)
301
//
302
// Now, new requirement: we have to be able to add up normal vectors, i.e. distort already distorted surfaces.
303
// If a surface is given by z = f(x,y), then the normal vector at (x0,y0) is given by (-df/dx (x0,y0), -df/dy (x0,y0), 1 ).
304
// so if we have two surfaces defined by f1(x,y) and f2(x,y) with their normals expressed as (f1x,f1y,1) and (f2x,f2y,1)
305
// then the normal to g = f1+f2 is simply given by (f1x+f2x,f1y+f2y,1), i.e. if the third components are equal, then we
306
// can simply add up the first and second components.
307
//
308
// Thus we actually want to compute N(v.x,v.y) = a*(-(dx/|PS|)*f'(|PX|), -(dy/|PS|)*f'(|PX|), 1) and keep adding
309
// the first two components. (a is the horizontal part)
310

    
311
#ifdef DISTORT
312
void distort(in int effect, inout vec3 v, inout vec3 n)
313
  {
314
  vec2 center = vUniforms[effect+1].yz;
315
  vec2 ps = center-v.xy;
316
  vec3 force = vUniforms[effect].xyz;
317
  float d = degree(vUniforms[effect+2],center,ps);
318
  float denom = dot(ps+(1.0-d)*force.xy,ps);
319
  float one_over_denom = 1.0/(denom-0.001*(sign(denom)-1.0));          // = denom==0 ? 1000:1/denom;
320

    
321
  //v.z += force.z*d;                                                  // cone
322
  //b = -(force.z*(1.0-d))*one_over_denom;                             //
323

    
324
  //v.z += force.z*d*d*(3.0-2.0*d);                                    // thin bubble
325
  //b = -(6.0*force.z*d*(1.0-d)*(1.0-d))*one_over_denom;               //
326

    
327
  v.z += force.z*d*d*(3.0*d*d -8.0*d +6.0);                            // thick bubble
328
  float b = -(12.0*force.z*d*(1.0-d)*(1.0-d)*(1.0-d))*one_over_denom;  //
329

    
330
  v.xy += d*force.xy;
331
  n.xy += n.z*b*ps;
332
  }
333
#endif
334

    
335
//////////////////////////////////////////////////////////////////////////////////////////////
336
// SINK EFFECT
337
//
338
// Pull P=(v.x,v.y) towards center of the effect with P' = P + (1-h)*dist(S-P)
339
// when h>1 we are pushing points away from S: P' = P + (1/h-1)*dist(S-P)
340

    
341
#ifdef SINK
342
void sink(in int effect,inout vec3 v)
343
  {
344
  vec2 center = vUniforms[effect+1].yz;
345
  vec2 ps = center-v.xy;
346
  float h = vUniforms[effect].x;
347
  float t = degree(vUniforms[effect+2],center,ps) * (1.0-h)/max(1.0,h);
348

    
349
  v.xy += t*ps;
350
  }
351
#endif
352

    
353
//////////////////////////////////////////////////////////////////////////////////////////////
354
// PINCH EFFECT
355
//
356
// Pull P=(v.x,v.y) towards the line that
357
// a) passes through the center of the effect
358
// b) forms angle defined in the 2nd interpolated value with the X-axis
359
// with P' = P + (1-h)*dist(line to P)
360
// when h>1 we are pushing points away from S: P' = P + (1/h-1)*dist(line to P)
361

    
362
#ifdef PINCH
363
void pinch(in int effect,inout vec3 v)
364
  {
365
  vec2 center = vUniforms[effect+1].yz;
366
  vec2 ps = center-v.xy;
367
  float h = vUniforms[effect].x;
368
  float t = degree(vUniforms[effect+2],center,ps) * (1.0-h)/max(1.0,h);
369
  float angle = vUniforms[effect].y;
370
  vec2 dir = vec2(sin(angle),-cos(angle));
371

    
372
  v.xy += t*dot(ps,dir)*dir;
373
  }
374
#endif
375

    
376
//////////////////////////////////////////////////////////////////////////////////////////////
377
// SWIRL EFFECT
378
//
379
// Let d be the degree of the current vertex V with respect to center of the effect S and Region vRegion.
380
// This effect rotates the current vertex V by vInterpolated.x radians clockwise around the circle dilated
381
// by (1-d) around the center of the effect S.
382

    
383
#ifdef SWIRL
384
void swirl(in int effect, inout vec3 v)
385
  {
386
  vec2 center  = vUniforms[effect+1].yz;
387
  vec2 PS = center-v.xy;
388
  vec4 SO = vUniforms[effect+2];
389
  float d1_circle = degree_region(SO,PS);
390
  float d1_bitmap = degree_bitmap(center,PS);
391

    
392
  float alpha = vUniforms[effect].x;
393
  float sinA = sin(alpha);
394
  float cosA = cos(alpha);
395

    
396
  vec2 PS2 = vec2( PS.x*cosA+PS.y*sinA,-PS.x*sinA+PS.y*cosA ); // vector PS rotated by A radians clockwise around center.
397
  vec4 SG = (1.0-d1_circle)*SO;                                // coordinates of the dilated circle P is going to get rotated around
398
  float d2 = max(0.0,degree(SG,center,PS2));                   // make it a max(0,deg) because otherwise when center=left edge of the
399
                                                               // bitmap some points end up with d2<0 and they disappear off view.
400
  v.xy += min(d1_circle,d1_bitmap)*(PS - PS2/(1.0-d2));        // if d2=1 (i.e P=center) we should have P unchanged. How to do it?
401
  }
402
#endif
403

    
404
//////////////////////////////////////////////////////////////////////////////////////////////
405
// WAVE EFFECT
406
//
407
// Directional sinusoidal wave effect.
408
//
409
// This is an effect from a (hopefully!) generic family of effects of the form (vec3 V: |V|=1 , f(x,y) )  (*)
410
// i.e. effects defined by a unit vector and an arbitrary function. Those effects are defined to move each
411
// point (x,y,0) of the XY plane to the point (x,y,0) + V*f(x,y).
412
//
413
// In this case V is defined by angles A and B (sines and cosines of which are precomputed in
414
// EffectQueueVertex and passed in the uniforms).
415
// Let's move V to start at the origin O, let point C be the endpoint of V, and let C' be C's projection
416
// to the XY plane. Then A is defined to be the angle C0C' and angle B is the angle C'O(axisY).
417
//
418
// Also, in this case f(x,y) = amplitude*sin(x/length), with those 2 parameters passed in uniforms.
419
//
420
//////////////////////////////////////////////////////////////////////////////////////////////
421
// How to compute any generic effect of type (*)
422
//////////////////////////////////////////////////////////////////////////////////////////////
423
//
424
// By definition, the vertices move by f(x,y)*V.
425
//
426
// Normals are much more complicated.
427
// Let angle X be the angle (0,Vy,Vz)(0,Vy,0)(Vx,Vy,Vz).
428
// Let angle Y be the angle (Vx,0,Vz)(Vx,0,0)(Vx,Vy,Vz).
429
//
430
// Then it can be shown that the resulting surface, at point to which point (x0,y0,0) got moved to,
431
// has 2 tangent vectors given by
432
//
433
// SX = (1.0+cosX*fx , cosY*sinX*fx , |sinY|*sinX*fx);  (**)
434
// SY = (cosX*sinY*fy , 1.0+cosY*fy , |sinX|*sinY*fy);  (***)
435
//
436
// and then obviously the normal N is given by N= SX x SY .
437
//
438
// We still need to remember the note from the distort function about adding up normals:
439
// we first need to 'normalize' the normals to make their third components equal, and then we
440
// simply add up the first and the second component while leaving the third unchanged.
441
//
442
// How to see facts (**) and (***) ? Briefly:
443
// a) compute the 2D analogon and conclude that in this case the tangent SX is given by
444
//    SX = ( cosA*f'(x) +1, sinA*f'(x) )    (where A is the angle vector V makes with X axis )
445
// b) cut the resulting surface with plane P which
446
//    - includes vector V
447
//    - crosses plane XY along line parallel to X axis
448
// c) apply the 2D analogon and notice that the tangent vector to the curve that is the common part of P
449
//    and our surface (I am talking about the tangent vector which belongs to P) is given by
450
//    (1+cosX*fx,0,sinX*fx) rotated by angle (90-|Y|) (where angles X,Y are defined above) along vector (1,0,0).
451
//
452
//    Matrix of rotation:
453
//
454
//    |sinY|  cosY
455
//    -cosY  |sinY|
456
//
457
// d) compute the above and see that this is equal precisely to SX from (**).
458
// e) repeat points b,c,d in direction Y and come up with (***).
459
//
460
//////////////////////////////////////////////////////////////////////////////////////////////
461
// Note: we should avoid passing certain combinations of parameters to this function. One such known
462
// combination is ( A: small but positive, B: any, amplitude >= length ).
463
// In this case, certain 'unlucky' points have their normals almost horizontal (they got moved by (almost!)
464
// amplitude, and other point length (i.e. <=amplitude) away got moved by 0, so the slope in this point is
465
// very steep). Visual effect is: vast majority of surface pretty much unchanged, but random 'unlucky'
466
// points very dark)
467
//
468
// Generally speaking I'd keep to amplitude < length, as the opposite case has some other problems as well.
469

    
470
#ifdef WAVE
471
void wave(in int effect, inout vec3 v, inout vec3 n)
472
  {
473
  vec2 center     = vUniforms[effect+1].yz;
474
  float amplitude = vUniforms[effect  ].x;
475
  float length    = vUniforms[effect  ].y;
476

    
477
  vec2 ps = center - v.xy;
478
  float deg = amplitude*degree_region(vUniforms[effect+2],ps);
479

    
480
  if( deg != 0.0 && length != 0.0 )
481
    {
482
    float phase = vUniforms[effect  ].z;
483
    float alpha = vUniforms[effect  ].w;
484
    float beta  = vUniforms[effect+1].x;
485

    
486
    float sinA = sin(alpha);
487
    float cosA = cos(alpha);
488
    float sinB = sin(beta);
489
    float cosB = cos(beta);
490

    
491
    float angle= 1.578*(ps.x*cosB-ps.y*sinB) / length + phase;
492

    
493
    vec3 dir= vec3(sinB*cosA,cosB*cosA,sinA);
494

    
495
    v += sin(angle)*deg*dir;
496

    
497
    if( n.z != 0.0 )
498
      {
499
      float sqrtX = sqrt(dir.y*dir.y + dir.z*dir.z);
500
      float sqrtY = sqrt(dir.x*dir.x + dir.z*dir.z);
501

    
502
      float sinX = ( sqrtY==0.0 ? 0.0 : dir.z / sqrtY);
503
      float cosX = ( sqrtY==0.0 ? 1.0 : dir.x / sqrtY);
504
      float sinY = ( sqrtX==0.0 ? 0.0 : dir.z / sqrtX);
505
      float cosY = ( sqrtX==0.0 ? 1.0 : dir.y / sqrtX);
506

    
507
      float abs_z = dir.z <0.0 ? -(sinX*sinY) : (sinX*sinY);
508

    
509
      float tmp = 1.578*cos(angle)*deg/length;
510

    
511
      float fx =-cosB*tmp;
512
      float fy = sinB*tmp;
513

    
514
      vec3 sx = vec3 (1.0+cosX*fx,cosY*sinX*fx,abs_z*fx);
515
      vec3 sy = vec3 (cosX*sinY*fy,1.0+cosY*fy,abs_z*fy);
516

    
517
      vec3 normal = cross(sx,sy);
518

    
519
      if( normal.z<=0.0 )                   // Why this bizarre shit rather than the straightforward
520
        {                                   //
521
        normal.x= 0.0;                      // if( normal.z>0.0 )
522
        normal.y= 0.0;                      //   {
523
        normal.z= 1.0;                      //   n.x = (n.x*normal.z + n.z*normal.x);
524
        }                                   //   n.y = (n.y*normal.z + n.z*normal.y);
525
                                            //   n.z = (n.z*normal.z);
526
                                            //   }
527
      n.x = (n.x*normal.z + n.z*normal.x);  //
528
      n.y = (n.y*normal.z + n.z*normal.y);  // ? Because if we do the above, my shitty Nexus4 crashes
529
      n.z = (n.z*normal.z);                 // during shader compilation!
530
      }
531
    }
532
  }
533
#endif
534

    
535
#endif  // NUM_VERTEX>0
536

    
537
//////////////////////////////////////////////////////////////////////////////////////////////
538

    
539
void main()
540
  {
541
  vec3 v = 2.0*u_objD*a_Position;
542
  vec3 n = a_Normal;
543

    
544
#if NUM_VERTEX>0
545
  int j=0;
546

    
547
  for(int i=0; i<vNumEffects; i++)
548
    {
549
#ifdef DISTORT
550
    if( vType[i]==DISTORT) distort(j,v,n); else
551
#endif
552
#ifdef DEFORM
553
    if( vType[i]==DEFORM ) deform (j,v,n); else
554
#endif
555
#ifdef SINK
556
    if( vType[i]==SINK   ) sink   (j,v);   else
557
#endif
558
#ifdef PINCH
559
    if( vType[i]==PINCH  ) pinch  (j,v);   else
560
#endif
561
#ifdef SWIRL
562
    if( vType[i]==SWIRL  ) swirl  (j,v);   else
563
#endif
564
#ifdef WAVE
565
    if( vType[i]==WAVE   ) wave   (j,v,n); else
566
#endif
567
    {}
568

    
569
    j+=3;
570
    }
571

    
572
  restrictZ(v.z);
573
#endif
574
   
575
  v_Position      = v;
576
  v_TexCoordinate = a_TexCoordinate;
577
  v_Normal        = normalize(vec3(u_MVMatrix*vec4(n,0.0)));
578
  gl_Position     = u_MVPMatrix*vec4(v,1.0);
579
  }                               
(4-4/6)