1
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
2
|
// Copyright 2017 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
|
package org.distorted.library.effect;
|
21
|
|
22
|
import org.distorted.library.type.Data3D;
|
23
|
import org.distorted.library.type.Data4D;
|
24
|
import org.distorted.library.type.Data5D;
|
25
|
|
26
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
27
|
/**
|
28
|
* Directional, sinusoidal wave effect.
|
29
|
*
|
30
|
* Not a fully 3D effect. To achieve a fully 3D one we'd need another parameter making the whole thing
|
31
|
* a 6D effect but there's no room in the Vertex Uniforms which assign only 5 floats for interpolated
|
32
|
* effect values. Rethink this. ATM fully enough for 2.5D meshes like the MeshCubes.
|
33
|
*/
|
34
|
public class VertexEffectWave extends VertexEffect
|
35
|
{
|
36
|
private static final EffectName NAME = EffectName.WAVE;
|
37
|
|
38
|
private Data5D mWave;
|
39
|
private Data3D mCenter;
|
40
|
private Data4D mRegion;
|
41
|
|
42
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
43
|
/**
|
44
|
* Only for use by the library itself.
|
45
|
*
|
46
|
* @y.exclude
|
47
|
*/
|
48
|
public boolean compute(float[] uniforms, int index, long currentDuration, long step )
|
49
|
{
|
50
|
mCenter.get(uniforms,index+CENTER_OFFSET,currentDuration,step);
|
51
|
mRegion.get(uniforms,index+REGION_OFFSET,currentDuration,step);
|
52
|
boolean ret = mWave.get(uniforms,index+VALUES_OFFSET,currentDuration,step);
|
53
|
|
54
|
uniforms[index+VALUES_OFFSET+2] = (float)(Math.PI*uniforms[index+VALUES_OFFSET+2]/180);
|
55
|
uniforms[index+VALUES_OFFSET+3] = (float)(Math.PI*uniforms[index+VALUES_OFFSET+3]/180);
|
56
|
uniforms[index+VALUES_OFFSET+4] = (float)(Math.PI*uniforms[index+VALUES_OFFSET+4]/180);
|
57
|
|
58
|
return ret;
|
59
|
}
|
60
|
|
61
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
62
|
// Directional sinusoidal wave effect.
|
63
|
//
|
64
|
// This is an effect from a (hopefully!) generic family of effects of the form (vec3 V: |V|=1 , f(x,y) ) (*)
|
65
|
// i.e. effects defined by a unit vector and an arbitrary function. Those effects are defined to move each
|
66
|
// point (x,y,0) of the XY plane to the point (x,y,0) + V*f(x,y).
|
67
|
//
|
68
|
// In this case V is defined by angles A and B (sines and cosines of which are precomputed in
|
69
|
// EffectQueueVertex and passed in the uniforms).
|
70
|
// 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
|
71
|
// to the XY plane. Then A is defined to be the angle C0C' and angle B is the angle C'O(axisY).
|
72
|
//
|
73
|
// Also, in this case f(x,y) = amplitude*sin(x/length), with those 2 parameters passed in uniforms.
|
74
|
//
|
75
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
76
|
// How to compute any generic effect of type (*)
|
77
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
78
|
//
|
79
|
// By definition, the vertices move by f(x,y)*V.
|
80
|
//
|
81
|
// Normals are much more complicated.
|
82
|
// Let angle X be the angle (0,Vy,Vz)(0,Vy,0)(Vx,Vy,Vz).
|
83
|
// Let angle Y be the angle (Vx,0,Vz)(Vx,0,0)(Vx,Vy,Vz).
|
84
|
//
|
85
|
// Then it can be shown that the resulting surface, at point to which point (x0,y0,0) got moved to,
|
86
|
// has 2 tangent vectors given by
|
87
|
//
|
88
|
// SX = (1.0+cosX*fx , cosY*sinX*fx , |sinY|*sinX*fx); (**)
|
89
|
// SY = (cosX*sinY*fy , 1.0+cosY*fy , |sinX|*sinY*fy); (***)
|
90
|
//
|
91
|
// and then obviously the normal N is given by N= SX x SY .
|
92
|
//
|
93
|
// We still need to remember the note from the distort function dialog_about adding up normals:
|
94
|
// we first need to 'normalize' the normals to make their third components equal, and then we
|
95
|
// simply add up the first and the second component while leaving the third unchanged.
|
96
|
//
|
97
|
// How to see facts (**) and (***) ? Briefly:
|
98
|
// a) compute the 2D analogon and conclude that in this case the tangent SX is given by
|
99
|
// SX = ( cosA*f'(x) +1, sinA*f'(x) ) (where A is the angle vector V makes with X axis )
|
100
|
// b) cut the resulting surface with plane P which
|
101
|
// - includes vector V
|
102
|
// - crosses plane XY along line parallel to X axis
|
103
|
// c) apply the 2D analogon and notice that the tangent vector to the curve that is the common part of P
|
104
|
// and our surface (I am talking dialog_about the tangent vector which belongs to P) is given by
|
105
|
// (1+cosX*fx,0,sinX*fx) rotated by angle (90-|Y|) (where angles X,Y are defined above) along vector (1,0,0).
|
106
|
//
|
107
|
// Matrix of rotation:
|
108
|
//
|
109
|
// |sinY| cosY
|
110
|
// -cosY |sinY|
|
111
|
//
|
112
|
// d) compute the above and see that this is equal precisely to SX from (**).
|
113
|
// e) repeat points b,c,d in direction Y and come up with (***).
|
114
|
//
|
115
|
//////////////////////////////////////////////////////////////////////////////////////////////
|
116
|
// Note: we should avoid passing certain combinations of parameters to this function. One such known
|
117
|
// combination is ( A: small but positive, B: any, amplitude >= length ).
|
118
|
// In this case, certain 'unlucky' points have their normals almost horizontal (they got moved by (almost!)
|
119
|
// amplitude, and other point length (i.e. <=amplitude) away got moved by 0, so the slope in this point is
|
120
|
// very steep). Visual effect is: vast majority of surface pretty much unchanged, but random 'unlucky'
|
121
|
// points very dark)
|
122
|
//
|
123
|
// Generally speaking I'd keep to amplitude < length, as the opposite case has some other problems as well.
|
124
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
125
|
|
126
|
static String code()
|
127
|
{
|
128
|
return
|
129
|
|
130
|
"vec3 center = vUniforms[effect+1].yzw; \n"
|
131
|
+ "float amplitude = vUniforms[effect ].x; \n"
|
132
|
+ "float length = vUniforms[effect ].y; \n"
|
133
|
|
134
|
+ "vec3 ps = center - v; \n"
|
135
|
+ "float deg = amplitude*degree(vUniforms[effect+2],ps); \n"
|
136
|
|
137
|
+ "if( deg != 0.0 && length != 0.0 ) \n"
|
138
|
+ "{ \n"
|
139
|
+ "float phase = vUniforms[effect ].z; \n"
|
140
|
+ "float alpha = vUniforms[effect ].w; \n"
|
141
|
+ "float beta = vUniforms[effect+1].x; \n"
|
142
|
|
143
|
+ "float sinA = sin(alpha); \n"
|
144
|
+ "float cosA = cos(alpha); \n"
|
145
|
+ "float sinB = sin(beta); \n"
|
146
|
+ "float cosB = cos(beta); \n"
|
147
|
|
148
|
+ "float angle= 1.578*(ps.x*cosB-ps.y*sinB) / length + phase; \n"
|
149
|
+ "vec3 dir= vec3(sinB*cosA,cosB*cosA,sinA); \n"
|
150
|
+ "v += sin(angle)*deg*dir; \n"
|
151
|
|
152
|
+ "if( n.z != 0.0 ) \n"
|
153
|
+ "{ \n"
|
154
|
+ "float sqrtX = sqrt(dir.y*dir.y + dir.z*dir.z); \n"
|
155
|
+ "float sqrtY = sqrt(dir.x*dir.x + dir.z*dir.z); \n"
|
156
|
|
157
|
+ "float sinX = ( sqrtY==0.0 ? 0.0 : dir.z / sqrtY); \n"
|
158
|
+ "float cosX = ( sqrtY==0.0 ? 1.0 : dir.x / sqrtY); \n"
|
159
|
+ "float sinY = ( sqrtX==0.0 ? 0.0 : dir.z / sqrtX); \n"
|
160
|
+ "float cosY = ( sqrtX==0.0 ? 1.0 : dir.y / sqrtX); \n"
|
161
|
|
162
|
+ "float abs_z = dir.z <0.0 ? -(sinX*sinY) : (sinX*sinY); \n"
|
163
|
+ "float tmp = 1.578*cos(angle)*deg/length; \n"
|
164
|
|
165
|
+ "float fx =-cosB*tmp; \n"
|
166
|
+ "float fy = sinB*tmp; \n"
|
167
|
|
168
|
+ "vec3 sx = vec3 (1.0+cosX*fx,cosY*sinX*fx,abs_z*fx); \n"
|
169
|
+ "vec3 sy = vec3 (cosX*sinY*fy,1.0+cosY*fy,abs_z*fy); \n"
|
170
|
|
171
|
+ "vec3 normal = cross(sx,sy); \n"
|
172
|
|
173
|
+ "if( normal.z<=0.0 ) \n" // Why this bizarre thing rather than the straightforward
|
174
|
+ "{ \n" //
|
175
|
+ "normal.x= 0.0; \n" // if( normal.z>0.0 )
|
176
|
+ "normal.y= 0.0; \n" // {
|
177
|
+ "normal.z= 1.0; \n" // n.x = (n.x*normal.z + n.z*normal.x);
|
178
|
+ "} \n" // n.y = (n.y*normal.z + n.z*normal.y);
|
179
|
// n.z = (n.z*normal.z);
|
180
|
// }
|
181
|
+ "n.x = (n.x*normal.z + n.z*normal.x); \n" //
|
182
|
+ "n.y = (n.y*normal.z + n.z*normal.y); \n" // ? Because if we do the above, my Nexus4 crashes
|
183
|
+ "n.z = (n.z*normal.z); \n" // during shader compilation!
|
184
|
+ "} \n"
|
185
|
+ "}";
|
186
|
}
|
187
|
|
188
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
189
|
// PUBLIC API
|
190
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
191
|
/**
|
192
|
* Have to call this before the shaders get compiled (i.e before DistortedLibrary.onCreate()) for the Effect to work.
|
193
|
*/
|
194
|
public static void enable()
|
195
|
{
|
196
|
addEffect( NAME, code() );
|
197
|
}
|
198
|
|
199
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
200
|
/**
|
201
|
* Directional, sinusoidal wave effect.
|
202
|
*
|
203
|
* @param wave A 5-dimensional data structure describing the wave: first member is the amplitude,
|
204
|
* second is the wave length, third is the phase (i.e. when phase = PI/2, the sine
|
205
|
* wave at the center does not start from sin(0), but from sin(PI/2) ) and the next two
|
206
|
* describe the 'direction' of the wave.
|
207
|
* <p>
|
208
|
* Wave direction is defined to be a 3D vector of length 1. To define such vectors, we
|
209
|
* need 2 floats: thus the fourth member is the angle Alpha (in degrees) which the vector
|
210
|
* forms with the XY-plane, and the fifth is the angle Beta (again in degrees) which
|
211
|
* the projection of the vector to the XY-plane forms with the Y-axis (counterclockwise).
|
212
|
* <p>
|
213
|
* <p>
|
214
|
* Example1: if Alpha = 90, Beta = 90, (then V=(0,0,1) ) and the wave acts 'vertically'
|
215
|
* in the X-direction, i.e. cross-sections of the resulting surface with the XZ-plane
|
216
|
* will be sine shapes.
|
217
|
* <p>
|
218
|
* Example2: if Alpha = 90, Beta = 0, the again V=(0,0,1) and the wave is 'vertical',
|
219
|
* but this time it waves in the Y-direction, i.e. cross sections of the surface and the
|
220
|
* YZ-plane with be sine shapes.
|
221
|
* <p>
|
222
|
* Example3: if Alpha = 0 and Beta = 45, then V=(sqrt(2)/2, sqrt(2)/2, 0) and the wave
|
223
|
* is entirely 'horizontal' and moves point (x,y,0) in direction V by whatever is the
|
224
|
* value if sin at this point.
|
225
|
* @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
|
226
|
* @param region Region that masks the Effect.
|
227
|
*/
|
228
|
public VertexEffectWave(Data5D wave, Data3D center, Data4D region)
|
229
|
{
|
230
|
super(NAME);
|
231
|
mWave = wave;
|
232
|
mCenter = center;
|
233
|
mRegion = (region==null ? MAX_REGION : region);
|
234
|
}
|
235
|
|
236
|
///////////////////////////////////////////////////////////////////////////////////////////////////
|
237
|
/**
|
238
|
* Directional, sinusoidal wave effect.
|
239
|
*
|
240
|
* @param wave see {@link #VertexEffectWave(Data5D,Data3D,Data4D)}
|
241
|
* @param center 3-dimensional Data that, at any given time, returns the Center of the Effect.
|
242
|
*/
|
243
|
public VertexEffectWave(Data5D wave, Data3D center)
|
244
|
{
|
245
|
super(NAME);
|
246
|
mWave = wave;
|
247
|
mCenter = center;
|
248
|
mRegion = MAX_REGION;
|
249
|
}
|
250
|
}
|