Revision 56cbe1cf
Added by Leszek Koltunski almost 8 years ago
src/main/java/org/distorted/examples/vertex3d/Vertex3DActivity.java | ||
---|---|---|
29 | 29 |
import android.widget.Button; |
30 | 30 |
import android.widget.LinearLayout; |
31 | 31 |
import android.widget.NumberPicker; |
32 |
import android.widget.SeekBar; |
|
33 |
import android.widget.SeekBar.OnSeekBarChangeListener; |
|
34 | 32 |
import android.widget.Spinner; |
35 | 33 |
import android.widget.TableRow; |
36 |
import android.widget.TextView; |
|
37 | 34 |
|
38 | 35 |
import org.distorted.examples.R; |
39 | 36 |
import org.distorted.library.Distorted; |
... | ... | |
41 | 38 |
import org.distorted.library.DistortedCubes; |
42 | 39 |
import org.distorted.library.DistortedObject; |
43 | 40 |
import org.distorted.library.EffectNames; |
41 |
import org.distorted.library.EffectTypes; |
|
42 |
import org.distorted.library.type.Dynamic1D; |
|
43 |
import org.distorted.library.type.Dynamic2D; |
|
44 |
import org.distorted.library.type.Dynamic3D; |
|
45 |
import org.distorted.library.type.Dynamic4D; |
|
46 |
|
|
47 |
import java.util.ArrayList; |
|
44 | 48 |
|
45 | 49 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
46 | 50 |
|
47 | 51 |
public class Vertex3DActivity extends Activity |
48 |
implements OnSeekBarChangeListener, |
|
49 |
View.OnClickListener, |
|
52 |
implements View.OnClickListener, |
|
50 | 53 |
AdapterView.OnItemSelectedListener |
51 | 54 |
{ |
52 | 55 |
private static final int COLOR_OFF = 0xffffe81f; |
... | ... | |
56 | 59 |
|
57 | 60 |
// fields needed for the first 'pick-a-shape' screen |
58 | 61 |
// |
59 |
private int mNumCols = 3;
|
|
60 |
private int mNumRows = 3;
|
|
62 |
private int mNumCols = 10;
|
|
63 |
private int mNumRows = 10;
|
|
61 | 64 |
private NumberPicker mColsPicker, mRowsPicker; |
62 |
private LinearLayout mLay; |
|
63 | 65 |
private boolean[] mShape; |
64 | 66 |
private DistortedObject mObject; |
65 | 67 |
private int mObjectType; |
66 | 68 |
private int mBitmap; |
67 | 69 |
|
68 |
// fields needed for the second 'apply vertex effects' screen |
|
69 |
// |
|
70 |
private SeekBar bar; |
|
71 |
private TextView textDeform, textDistort, textSink, textSwirl, textCenter; |
|
72 |
private int deformX, deformY, deformZ; |
|
73 |
private int distortX, distortY, distortZ; |
|
74 |
private int sinkA; |
|
75 |
private int swirlA; |
|
76 |
private int centerX, centerY; |
|
77 |
|
|
78 |
private float fdeformX, fdeformY, fdeformZ; |
|
79 |
private float fdistortX, fdistortY, fdistortZ; |
|
80 |
private float fsinkA; |
|
81 |
private float fswirlA; |
|
82 |
private float fcenterX, fcenterY; |
|
83 |
private EffectNames[] effects = new EffectNames[4]; |
|
84 |
|
|
70 |
private ArrayList<Vertex3DEffect> mEffects; |
|
71 |
private int mEffectAdd; |
|
85 | 72 |
|
86 | 73 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
87 |
|
|
74 |
|
|
88 | 75 |
@Override |
89 | 76 |
protected void onCreate(Bundle savedState) |
90 | 77 |
{ |
91 | 78 |
super.onCreate(savedState); |
92 | 79 |
|
80 |
mEffects = new ArrayList<>(); |
|
81 |
|
|
93 | 82 |
setContentView(R.layout.objectpickerlayout); |
94 | 83 |
|
95 | 84 |
mColsPicker = (NumberPicker)findViewById(R.id.objectpicker_cols); |
96 | 85 |
mRowsPicker = (NumberPicker)findViewById(R.id.objectpicker_rows); |
97 | 86 |
|
98 |
mColsPicker.setMaxValue(10);
|
|
87 |
mColsPicker.setMaxValue(15);
|
|
99 | 88 |
mColsPicker.setMinValue( 0); |
100 |
mRowsPicker.setMaxValue(10);
|
|
89 |
mRowsPicker.setMaxValue(15);
|
|
101 | 90 |
mRowsPicker.setMinValue( 0); |
102 | 91 |
|
103 | 92 |
mColsPicker.setOnValueChangedListener(new NumberPicker.OnValueChangeListener() |
... | ... | |
145 | 134 |
|
146 | 135 |
private void setGrid() |
147 | 136 |
{ |
148 |
mLay = (LinearLayout)findViewById(R.id.objectpicker_buttongrid);
|
|
137 |
LinearLayout lay = (LinearLayout)findViewById(R.id.objectpicker_buttongrid);
|
|
149 | 138 |
|
150 |
int width = mLay.getWidth();
|
|
151 |
int height= mLay.getHeight();
|
|
139 |
int width = lay.getWidth();
|
|
140 |
int height= lay.getHeight();
|
|
152 | 141 |
int w = mNumCols>0 ? (width / mNumCols) -10 : 0; |
153 | 142 |
int h = mNumRows>0 ? (height/ mNumRows) -10 : 0; |
154 | 143 |
int size= w<h ? w:h; |
155 | 144 |
int pad = size/20; |
156 | 145 |
|
157 |
mLay.removeAllViews();
|
|
146 |
lay.removeAllViews();
|
|
158 | 147 |
|
159 | 148 |
mShape = new boolean[mNumRows*mNumCols]; |
160 | 149 |
|
161 |
TableRow.LayoutParams p = new android.widget.TableRow.LayoutParams();
|
|
150 |
TableRow.LayoutParams p = new TableRow.LayoutParams(); |
|
162 | 151 |
|
163 | 152 |
p.rightMargin = pad; |
164 | 153 |
p.leftMargin = pad; |
... | ... | |
183 | 172 |
mShape[rows*mNumCols+cols] = true; |
184 | 173 |
} |
185 | 174 |
|
186 |
mLay.addView(tr);
|
|
175 |
lay.addView(tr);
|
|
187 | 176 |
} |
188 | 177 |
} |
189 | 178 |
|
... | ... | |
196 | 185 |
|
197 | 186 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
198 | 187 |
|
199 |
public void onClick(View view)
|
|
188 |
public int getBitmap()
|
|
200 | 189 |
{ |
201 |
Button tmp = (Button)view; |
|
202 |
int id = tmp.getId(); |
|
203 |
mShape[id] = !mShape[id]; |
|
204 |
tmp.setBackgroundColor(mShape[id] ? COLOR_ON:COLOR_OFF); |
|
190 |
return mBitmap; |
|
205 | 191 |
} |
206 | 192 |
|
207 | 193 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
208 | 194 |
|
209 |
public int getBitmap()
|
|
195 |
public void onClick(View view)
|
|
210 | 196 |
{ |
211 |
return mBitmap; |
|
197 |
Button tmp = (Button)view; |
|
198 |
int id = tmp.getId(); |
|
199 |
mShape[id] = !mShape[id]; |
|
200 |
tmp.setBackgroundColor(mShape[id] ? COLOR_ON:COLOR_OFF); |
|
212 | 201 |
} |
213 | 202 |
|
214 | 203 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
215 | 204 |
|
216 | 205 |
public void Continue(View v) |
217 | 206 |
{ |
207 |
firstScreen = false; |
|
208 |
|
|
218 | 209 |
if( mObjectType==1 ) |
219 | 210 |
{ |
220 |
firstScreen = false; |
|
221 | 211 |
mObject = new DistortedBitmap(100,100,mNumCols); |
222 |
setContentView(R.layout.vertex3dlayout); |
|
223 |
Default(null); |
|
212 |
setVertexView(); |
|
224 | 213 |
} |
225 | 214 |
else |
226 | 215 |
{ |
... | ... | |
250 | 239 |
|
251 | 240 |
mObject = new DistortedCubes(mNumCols, str, 10); |
252 | 241 |
|
253 |
setContentView(R.layout.vertex3dlayout); |
|
254 |
Default(null); |
|
242 |
setVertexView(); |
|
255 | 243 |
} |
256 | 244 |
|
257 | 245 |
|
... | ... | |
261 | 249 |
{ |
262 | 250 |
switch(parent.getId()) |
263 | 251 |
{ |
264 |
case R.id.objectpicker_spinnerType : mObjectType = pos; break; |
|
252 |
case R.id.objectpicker_spinnerType : mObjectType = pos; |
|
253 |
break; |
|
265 | 254 |
case R.id.objectpicker_spinnerBitmap: switch(pos) |
266 | 255 |
{ |
267 | 256 |
case 0: mBitmap = R.raw.face; break; |
... | ... | |
270 | 259 |
case 3: mBitmap = R.raw.grid; break; |
271 | 260 |
} |
272 | 261 |
break; |
262 |
case R.id.vertex3dspinner : mEffectAdd = pos; |
|
263 |
break; |
|
273 | 264 |
} |
274 | 265 |
} |
275 | 266 |
|
... | ... | |
280 | 271 |
} |
281 | 272 |
|
282 | 273 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
283 |
// 'second screen' methods |
|
284 | 274 |
|
285 |
public void Default(View view)
|
|
275 |
public int getWidth()
|
|
286 | 276 |
{ |
287 |
effects[0] = EffectNames.DEFORM; |
|
288 |
effects[1] = EffectNames.DISTORT; |
|
289 |
effects[2] = EffectNames.SINK; |
|
290 |
effects[3] = EffectNames.SWIRL; |
|
291 |
|
|
292 |
deformX = 50; |
|
293 |
deformY = 50; |
|
294 |
deformZ = 50; |
|
295 |
|
|
296 |
distortX = 50; |
|
297 |
distortY = 50; |
|
298 |
distortZ = 50; |
|
299 |
|
|
300 |
sinkA = 50; |
|
301 |
swirlA = 50; |
|
302 |
|
|
303 |
centerX = 50; |
|
304 |
centerY = 50; |
|
305 |
|
|
306 |
textCenter = (TextView)findViewById(R.id.vertex3dcenterText); |
|
307 |
computeCenter(); |
|
308 |
setCenterText(); |
|
309 |
|
|
310 |
setBar(R.id.vertex3dcenterX, centerX); |
|
311 |
setBar(R.id.vertex3dcenterY, centerY); |
|
312 |
|
|
313 |
addViews(); |
|
314 |
} |
|
315 |
|
|
316 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
317 |
|
|
318 |
private void addViews() |
|
319 |
{ |
|
320 |
LinearLayout layout = (LinearLayout)findViewById(R.id.vertex3dlayout); |
|
321 |
|
|
322 |
layout.removeAllViews(); |
|
323 |
|
|
324 |
View deform = getLayoutInflater().inflate(R.layout.vertex3ddeform , null); |
|
325 |
View distort= getLayoutInflater().inflate(R.layout.vertex3ddistort, null); |
|
326 |
View sink = getLayoutInflater().inflate(R.layout.vertex3dsink , null); |
|
327 |
View swirl = getLayoutInflater().inflate(R.layout.vertex3dswirl , null); |
|
328 |
|
|
329 |
for( int i=effects.length-1 ; i>=0 ; i-- ) |
|
330 |
{ |
|
331 |
switch(effects[i]) |
|
332 |
{ |
|
333 |
case DEFORM : layout.addView(deform , 0); break; |
|
334 |
case DISTORT: layout.addView(distort, 0); break; |
|
335 |
case SINK : layout.addView(sink , 0); break; |
|
336 |
case SWIRL : layout.addView(swirl , 0); break; |
|
337 |
} |
|
338 |
} |
|
339 |
|
|
340 |
textDeform = (TextView)findViewById(R.id.vertex3ddeformText); |
|
341 |
textDistort= (TextView)findViewById(R.id.vertex3ddistortText); |
|
342 |
textSink = (TextView)findViewById(R.id.vertex3dsinkText); |
|
343 |
textSwirl = (TextView)findViewById(R.id.vertex3dswirlText); |
|
344 |
|
|
345 |
setDeformText(); |
|
346 |
setDistortText(); |
|
347 |
setSinkText(); |
|
348 |
setSwirlText(); |
|
349 |
|
|
350 |
setBar(R.id.vertex3ddeformBar1, deformX); |
|
351 |
setBar(R.id.vertex3ddeformBar2, deformY); |
|
352 |
setBar(R.id.vertex3ddeformBar3, deformZ); |
|
353 |
|
|
354 |
setBar(R.id.vertex3ddistortBar1, distortX); |
|
355 |
setBar(R.id.vertex3ddistortBar2, distortY); |
|
356 |
setBar(R.id.vertex3ddistortBar3, distortZ); |
|
357 |
|
|
358 |
setBar(R.id.vertex3dsinkBar1, sinkA); |
|
359 |
|
|
360 |
setBar(R.id.vertex3dswirlBar1, swirlA); |
|
361 |
|
|
362 |
Vertex3DSurfaceView view = (Vertex3DSurfaceView)findViewById(R.id.vertex3dSurfaceView); |
|
363 |
view.getRenderer().setOrder(effects); |
|
364 |
} |
|
365 |
|
|
366 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
367 |
|
|
368 |
private void moveUp(EffectNames name) |
|
369 |
{ |
|
370 |
int len = effects.length-1; |
|
371 |
int index = -1; |
|
372 |
|
|
373 |
for(int i=0; i<=len; i++) |
|
374 |
{ |
|
375 |
if( effects[i]==name ) |
|
376 |
{ |
|
377 |
index=i; |
|
378 |
break; |
|
379 |
} |
|
380 |
} |
|
381 |
|
|
382 |
if( index==0 ) |
|
383 |
{ |
|
384 |
for(int i=0; i<len; i++) |
|
385 |
effects[i] = effects[i+1]; |
|
386 |
|
|
387 |
effects[len] = name; |
|
388 |
} |
|
389 |
else if( index>0 ) |
|
390 |
{ |
|
391 |
effects[index] = effects[index-1]; |
|
392 |
effects[index-1] = name; |
|
393 |
} |
|
394 |
|
|
395 |
addViews(); |
|
396 |
} |
|
397 |
|
|
398 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
399 |
|
|
400 |
public void ButtonDeform(View v) |
|
401 |
{ |
|
402 |
moveUp(EffectNames.DEFORM); |
|
277 |
return mObject==null ? 0: mObject.getWidth(); |
|
403 | 278 |
} |
404 | 279 |
|
405 | 280 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
406 | 281 |
|
407 |
public void ButtonDistort(View v)
|
|
282 |
public int getHeight()
|
|
408 | 283 |
{ |
409 |
moveUp(EffectNames.DISTORT);
|
|
284 |
return mObject==null ? 0: mObject.getHeight();
|
|
410 | 285 |
} |
411 | 286 |
|
412 | 287 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
288 |
// 'second screen' methods |
|
413 | 289 |
|
414 |
public void ButtonSink(View v) |
|
415 |
{ |
|
416 |
moveUp(EffectNames.SINK); |
|
417 |
} |
|
418 |
|
|
419 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
420 |
|
|
421 |
public void ButtonSwirl(View v) |
|
422 |
{ |
|
423 |
moveUp(EffectNames.SWIRL); |
|
424 |
} |
|
425 |
|
|
426 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
427 |
|
|
428 |
private void setBar(int id, int value) |
|
429 |
{ |
|
430 |
bar = (SeekBar)findViewById(id); |
|
431 |
bar.setOnSeekBarChangeListener(this); |
|
432 |
bar.setProgress(value); |
|
433 |
} |
|
434 |
|
|
435 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
436 |
|
|
437 |
private void computeDeform() |
|
438 |
{ |
|
439 |
Vertex3DSurfaceView view = (Vertex3DSurfaceView)findViewById(R.id.vertex3dSurfaceView); |
|
440 |
Vertex3DRenderer renderer = view.getRenderer(); |
|
441 |
|
|
442 |
fdeformX = (deformX-50)*renderer.mScreenMin/200.0f; |
|
443 |
fdeformY = (deformY-50)*renderer.mScreenMin/200.0f; |
|
444 |
fdeformZ = (deformZ-50)*renderer.mScreenMin/200.0f; |
|
445 |
|
|
446 |
renderer.setDeform( fdeformX, fdeformY, fdeformZ ); |
|
447 |
} |
|
448 |
|
|
449 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
450 |
|
|
451 |
private void setDeformText() |
|
452 |
{ |
|
453 |
fdeformX = ((int)(100*fdeformX))/100.0f; |
|
454 |
fdeformY = ((int)(100*fdeformY))/100.0f; |
|
455 |
fdeformZ = ((int)(100*fdeformZ))/100.0f; |
|
456 |
|
|
457 |
textDeform.setText("deform("+fdeformX+" , "+fdeformY+" , "+fdeformZ+")"); |
|
458 |
} |
|
459 |
|
|
460 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
461 |
|
|
462 |
private void computeDistort() |
|
463 |
{ |
|
464 |
Vertex3DSurfaceView view = (Vertex3DSurfaceView)findViewById(R.id.vertex3dSurfaceView); |
|
465 |
Vertex3DRenderer renderer = view.getRenderer(); |
|
466 |
|
|
467 |
fdistortX = (distortX-50)*renderer.mScreenMin/200.0f; |
|
468 |
fdistortY = (distortY-50)*renderer.mScreenMin/200.0f; |
|
469 |
fdistortZ = (distortZ-50)*renderer.mScreenMin/200.0f; |
|
470 |
|
|
471 |
renderer.setDistort(fdistortX, fdistortY, fdistortZ); |
|
472 |
} |
|
473 |
|
|
474 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
475 |
|
|
476 |
private void setDistortText() |
|
477 |
{ |
|
478 |
fdistortX = ((int)(100*fdistortX))/100.0f; |
|
479 |
fdistortY = ((int)(100*fdistortY))/100.0f; |
|
480 |
fdistortZ = ((int)(100*fdistortZ))/100.0f; |
|
481 |
|
|
482 |
textDistort.setText("distort("+fdistortX+" , "+fdistortY+" , "+fdistortZ+")"); |
|
483 |
} |
|
484 |
|
|
485 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
486 |
|
|
487 |
private void computeSink() |
|
488 |
{ |
|
489 |
Vertex3DSurfaceView view = (Vertex3DSurfaceView)findViewById(R.id.vertex3dSurfaceView); |
|
490 |
|
|
491 |
fsinkA = (sinkA>= 50 ? 0.18f*sinkA-8.0f : 0.018f*sinkA + 0.1f); |
|
492 |
|
|
493 |
view.getRenderer().setSink( fsinkA ); |
|
494 |
} |
|
495 |
|
|
496 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
497 |
|
|
498 |
private void setSinkText() |
|
499 |
{ |
|
500 |
fsinkA = ((int)(100*fsinkA))/100.0f; |
|
501 |
|
|
502 |
textSink.setText("sink("+fsinkA+")"); |
|
503 |
} |
|
504 |
|
|
505 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
506 |
|
|
507 |
private void computeSwirl() |
|
508 |
{ |
|
509 |
Vertex3DSurfaceView view = (Vertex3DSurfaceView)findViewById(R.id.vertex3dSurfaceView); |
|
510 |
|
|
511 |
fswirlA = (swirlA-50)*3.6f; |
|
512 |
|
|
513 |
view.getRenderer().setSwirl( fswirlA ); |
|
514 |
} |
|
515 |
|
|
516 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
517 |
|
|
518 |
private void setSwirlText() |
|
290 |
private void setVertexView() |
|
519 | 291 |
{ |
520 |
fswirlA = ((int)(100*fswirlA))/100.0f;
|
|
292 |
final View view = getLayoutInflater().inflate(R.layout.vertex3dlayout, null);
|
|
521 | 293 |
|
522 |
textSwirl.setText("swirl("+fswirlA+")"); |
|
523 |
} |
|
294 |
setContentView(view); |
|
524 | 295 |
|
525 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
296 |
String[] effects = new String[] { "DISTORT", |
|
297 |
"DEFORM", |
|
298 |
"SINK", |
|
299 |
"SWIRL" }; |
|
526 | 300 |
|
527 |
private void computeCenter() |
|
528 |
{ |
|
529 |
Vertex3DSurfaceView view = (Vertex3DSurfaceView)findViewById(R.id.vertex3dSurfaceView); |
|
301 |
Spinner effectSpinner = (Spinner)findViewById(R.id.vertex3dspinner ); |
|
302 |
effectSpinner.setOnItemSelectedListener(this); |
|
530 | 303 |
|
531 |
fcenterX = centerX; |
|
532 |
fcenterY = centerY; |
|
304 |
ArrayAdapter<String> adapterEffect = new ArrayAdapter<>(this, android.R.layout.simple_spinner_item, effects); |
|
305 |
adapterEffect.setDropDownViewResource(android.R.layout.simple_spinner_dropdown_item); |
|
306 |
effectSpinner.setAdapter(adapterEffect); |
|
533 | 307 |
|
534 |
view.getRenderer().setCenter( fcenterX, fcenterY );
|
|
308 |
mEffectAdd = 0;
|
|
535 | 309 |
} |
536 | 310 |
|
537 | 311 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
538 | 312 |
|
539 |
private void setCenterText()
|
|
313 |
public void newEffect(View v)
|
|
540 | 314 |
{ |
541 |
fcenterX = ((int)(100*fcenterX))/100.0f; |
|
542 |
fcenterY = ((int)(100*fcenterY))/100.0f; |
|
315 |
EffectNames name; |
|
543 | 316 |
|
544 |
textCenter.setText("center("+fcenterX+","+fcenterY+")"); |
|
545 |
} |
|
317 |
switch(mEffectAdd) |
|
318 |
{ |
|
319 |
case 0 : name = EffectNames.DISTORT; break; |
|
320 |
case 1 : name = EffectNames.DEFORM ; break; |
|
321 |
case 2 : name = EffectNames.SINK ; break; |
|
322 |
case 3 : name = EffectNames.SWIRL ; break; |
|
323 |
default: return; |
|
324 |
} |
|
546 | 325 |
|
547 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
326 |
Vertex3DEffect eff = new Vertex3DEffect(name, this); |
|
327 |
mEffects.add(eff); |
|
548 | 328 |
|
549 |
public float getCenterX() |
|
550 |
{ |
|
551 |
return fcenterX; |
|
329 |
LinearLayout layout = (LinearLayout)findViewById(R.id.vertex3dlayout); |
|
330 |
View view = eff.createView(); |
|
331 |
layout.addView(view); |
|
332 |
View center = eff.createCenter(); |
|
333 |
layout.addView(center); |
|
334 |
View region = eff.createRegion(); |
|
335 |
layout.addView(region); |
|
336 |
|
|
337 |
Dynamic1D dyn1 = eff.getDyn1(); |
|
338 |
Dynamic2D cent = eff.getCenter(); |
|
339 |
Dynamic3D dyn3 = eff.getDyn3(); |
|
340 |
Dynamic4D regi = eff.getRegion(); |
|
341 |
|
|
342 |
switch(mEffectAdd) |
|
343 |
{ |
|
344 |
case 0: mObject.distort(dyn3, cent, regi); break; |
|
345 |
case 1: mObject.deform (dyn3, cent ); break; |
|
346 |
case 2: mObject.sink (dyn1, cent, regi); break; |
|
347 |
case 3: mObject.swirl (dyn1, cent, regi); break; |
|
348 |
} |
|
552 | 349 |
} |
553 | 350 |
|
554 | 351 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
555 | 352 |
|
556 |
public float getCenterY()
|
|
353 |
public void removeAll(View v)
|
|
557 | 354 |
{ |
558 |
return fcenterY; |
|
355 |
mEffects.clear(); |
|
356 |
LinearLayout layout = (LinearLayout)findViewById(R.id.vertex3dlayout); |
|
357 |
layout.removeAllViews(); |
|
358 |
mObject.abortEffects(EffectTypes.VERTEX); |
|
559 | 359 |
} |
560 | 360 |
|
561 | 361 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
... | ... | |
601 | 401 |
Distorted.onDestroy(); |
602 | 402 |
super.onDestroy(); |
603 | 403 |
} |
604 |
|
|
605 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
606 |
|
|
607 |
public void onProgressChanged(SeekBar bar, int progress, boolean fromUser) |
|
608 |
{ |
|
609 |
switch (bar.getId()) |
|
610 |
{ |
|
611 |
case R.id.vertex3dcenterX : centerX = progress; computeCenter() ; setCenterText() ; break; |
|
612 |
case R.id.vertex3dcenterY : centerY = progress; computeCenter() ; setCenterText() ; break; |
|
613 |
case R.id.vertex3ddeformBar1 : deformX = progress; computeDeform() ; setDeformText() ; break; |
|
614 |
case R.id.vertex3ddeformBar2 : deformY = progress; computeDeform() ; setDeformText() ; break; |
|
615 |
case R.id.vertex3ddeformBar3 : deformZ = progress; computeDeform() ; setDeformText() ; break; |
|
616 |
case R.id.vertex3ddistortBar1 : distortX= progress; computeDistort(); setDistortText() ; break; |
|
617 |
case R.id.vertex3ddistortBar2 : distortY= progress; computeDistort(); setDistortText() ; break; |
|
618 |
case R.id.vertex3ddistortBar3 : distortZ= progress; computeDistort(); setDistortText() ; break; |
|
619 |
case R.id.vertex3dsinkBar1 : sinkA = progress; computeSink() ; setSinkText() ; break; |
|
620 |
case R.id.vertex3dswirlBar1 : swirlA = progress; computeSwirl() ; setSwirlText() ; break; |
|
621 |
} |
|
622 |
} |
|
623 |
|
|
624 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
625 |
|
|
626 |
public void onStartTrackingTouch(SeekBar bar) { } |
|
627 |
|
|
628 |
/////////////////////////////////////////////////////////////////////////////////////////////////// |
|
629 | 404 |
|
630 |
public void onStopTrackingTouch(SeekBar bar) { } |
|
631 | 405 |
} |
Also available in: Unified diff
Re-write Vertex3D to provide similar functionality to Fragment3D (displaying the center and region bitmaps still missing)