← Back to branch summary

~seh999/jcog/proto3

« back to all changes in this revision

Viewing changes to spacetime/src.ui.swing.vr/opencog/spacetime/vr/TerrainPluginVR.java

  • Committer: SeH
  • Date: 2009-09-19 22:59:48 UTC
  • Revision ID: seh999@gmail.com-20090919225948-q3ab80xa57i74mm6
start of major jReality refactoring

Show diffs side-by-side

added added

removed removed

Lines of Context:
spacetime/src.ui.swing.vr/opencog/spacetime/vr/TerrainPluginVR.java
1
 
package opencog.spacetime.vr;
2
 
 
3
 
import java.awt.BorderLayout;
4
 
import java.awt.Color;
5
 
import java.awt.Dimension;
6
 
import java.awt.GridLayout;
7
 
import java.awt.Insets;
8
 
import java.awt.event.ActionEvent;
9
 
import java.awt.event.ActionListener;
10
 
import java.io.File;
11
 
import java.io.IOException;
12
 
import java.security.AccessController;
13
 
import java.security.PrivilegedAction;
14
 
import java.util.prefs.Preferences;
15
 
 
16
 
import javax.swing.BorderFactory;
17
 
import javax.swing.Box;
18
 
import javax.swing.BoxLayout;
19
 
import javax.swing.JButton;
20
 
import javax.swing.JCheckBox;
21
 
import javax.swing.JFileChooser;
22
 
import javax.swing.JLabel;
23
 
import javax.swing.JPanel;
24
 
import javax.swing.JSlider;
25
 
import javax.swing.SwingConstants;
26
 
import javax.swing.border.CompoundBorder;
27
 
import javax.swing.border.EmptyBorder;
28
 
import javax.swing.border.TitledBorder;
29
 
import javax.swing.event.ChangeEvent;
30
 
import javax.swing.event.ChangeListener;
31
 
import javax.swing.filechooser.FileSystemView;
32
 
 
33
 
import opencog.spacetime.geometry.IndexedFaceSetUtility;
34
 
import opencog.spacetime.math.Matrix;
35
 
import opencog.spacetime.math.MatrixBuilder;
36
 
import opencog.spacetime.reader.Readers;
37
 
import opencog.spacetime.scene.Appearance;
38
 
import opencog.spacetime.scene.IndexedFaceSet;
39
 
import opencog.spacetime.scene.SceneGraphComponent;
40
 
import opencog.spacetime.scene.SceneGraphVisitor;
41
 
import opencog.spacetime.shader.CommonAttributes;
42
 
import opencog.spacetime.shader.CubeMap;
43
 
import opencog.spacetime.shader.ImageData;
44
 
import opencog.spacetime.shader.Texture2D;
45
 
import opencog.spacetime.shader.TextureUtility;
46
 
import opencog.spacetime.util.Input;
47
 
import opencog.spacetime.util.PickUtility;
48
 
import opencog.spacetime.util.Secure;
49
 
import opencog.spacetime.util.SystemProperties;
50
 
import opencog.spacetime.vr.Terrain.GeometryType;
51
 
 
52
 
import de.jtem.beans.SimpleColorChooser;
53
 
 
54
 
public class TerrainPluginVR extends AbstractPluginVR {
55
 
 
56
 
        // maximal value of texture scale
57
 
        private static final double MAX_TEX_SCALE = 10;
58
 
        
59
 
        // ratio of maximal value and minimal value of texture scale
60
 
        private static final double TEX_SCALE_RANGE = 400;
61
 
 
62
 
        // defaults
63
 
        private static final double DEFAULT_TEX_SCALE = .5;
64
 
        private static final String DEFAULT_TEXTURE = "grid";
65
 
        private static final String DEFAULT_TERRAIN = "flat";
66
 
        private static final Color DEFAULT_FACE_COLOR=Color.white;
67
 
        private static final boolean DEFAULT_REFLECTING=true;
68
 
        private static final double DEFAULT_REFLECTION=0.2;
69
 
        private static final boolean DEFAULT_TRANSPARENT=false;
70
 
        private static final double DEFAULT_TRANSPARENCY=0.3;
71
 
        private static final boolean DEFAULT_SPHERICAL_TERRAIN=false;
72
 
        private static final boolean DEFAULT_TEX_SCALE_ENABLED=true;
73
 
        
74
 
        // terrain tab
75
 
        private JSlider terrainTexScaleSlider;
76
 
        private JCheckBox terrainTexScaleEnabled;
77
 
        private JPanel terrainPanel;
78
 
 
79
 
        private Texture2D terrainTex;
80
 
        private JFileChooser terrainTexFileChooser;
81
 
        private File terrainTexFile;
82
 
 
83
 
        private SceneGraphComponent nonflatTerrain;     
84
 
        
85
 
        static final SceneGraphComponent FLAT_TERRAIN;
86
 
        static {
87
 
                FLAT_TERRAIN = new SceneGraphComponent("flat terrain");
88
 
                MatrixBuilder.euclidean().rotateX(Math.PI/2).assignTo(FLAT_TERRAIN);
89
 
                //FLAT_TERRAIN.setGeometry(Primitives.plainQuadMesh(1, 1, 50, 50));
90
 
                FLAT_TERRAIN.setGeometry(BigMesh.bigMesh(50, 50, 2000));
91
 
                FLAT_TERRAIN.getGeometry().setGeometryAttributes("infinite plane", Boolean.TRUE);
92
 
                PickUtility.assignFaceAABBTrees(FLAT_TERRAIN);
93
 
        }
94
 
        
95
 
        private Terrain terrain;
96
 
 
97
 
        private JPanel terrainFileChooserPanel;
98
 
        private JPanel rotatePanel;
99
 
        private RotateBox rotateBox = new RotateBox();
100
 
 
101
 
        protected SceneGraphComponent customTerrain;
102
 
        
103
 
        protected SceneGraphComponent terrainNode = new SceneGraphComponent("terrain alignment");
104
 
        
105
 
        
106
 
        protected File terrainFile;
107
 
 
108
 
        
109
 
        
110
 
        private SimpleColorChooser faceColorChooser;
111
 
        private JCheckBox facesReflecting;
112
 
        private JSlider faceReflectionSlider;
113
 
        private JCheckBox transparency;
114
 
        private JSlider transparencySlider;
115
 
 
116
 
        private CubeMap cmFaces;
117
 
        private ImageData[] cubeMap;
118
 
 
119
 
        private JCheckBox sphericalTerrainBox;
120
 
 
121
 
        private JLabel texScaleLabel;
122
 
 
123
 
        public TerrainPluginVR() {
124
 
                super("terrain");
125
 
 
126
 
                // terrain
127
 
                terrain = new Terrain();
128
 
 
129
 
                Secure.doPrivileged(new PrivilegedAction<Object>() {
130
 
                        public Object run() {
131
 
                                makeTerrainTextureFileChooser();
132
 
                                return null;
133
 
                        }
134
 
                });
135
 
                Secure.doPrivileged(new PrivilegedAction<Object>() {
136
 
                        public Object run() {
137
 
                                makeTerrainFileChooser();
138
 
                                return null;
139
 
                        }
140
 
                });
141
 
                
142
 
                nonflatTerrain = Secure.doPrivileged(new PrivilegedAction<SceneGraphComponent>() {
143
 
                        public SceneGraphComponent run() {
144
 
                                try {
145
 
                                        return Readers.read(Input.getInput(ViewerVR.class.getResource("terrain.3ds")));
146
 
                                } catch (IOException e) {
147
 
                                        e.printStackTrace();
148
 
                                }
149
 
                                return null;
150
 
                        }
151
 
                });
152
 
                PickUtility.assignFaceAABBTrees(nonflatTerrain);
153
 
                nonflatTerrain.accept(new SceneGraphVisitor() {
154
 
                        public void visit(SceneGraphComponent c) {
155
 
                                c.childrenWriteAccept(this, false, false, false, false, true, false);
156
 
                        }
157
 
                        public void visit(IndexedFaceSet i) {
158
 
                                IndexedFaceSetUtility.calculateAndSetVertexNormals(i);          
159
 
                        }
160
 
                });
161
 
                
162
 
                rotateBox.addChangeListener(new ChangeListener() {
163
 
                        public void stateChanged(ChangeEvent e) {
164
 
                                rotateBox.getMatrix().assignTo(terrainNode);
165
 
                                updateTerrain();
166
 
                        }
167
 
                });
168
 
                makeTerrainTab();
169
 
        }
170
 
 
171
 
        @Override
172
 
        public void setViewerVR(ViewerVR vvr) {
173
 
                super.setViewerVR(vvr);
174
 
        }
175
 
        
176
 
        @Override
177
 
        public JPanel getPanel() {
178
 
                return terrainPanel;
179
 
        }
180
 
        
181
 
        @Override
182
 
        public void environmentChanged() {
183
 
                cubeMap=getViewerVR().getEnvironment();
184
 
                setFacesReflecting(isFacesReflecting());
185
 
        }
186
 
        
187
 
        private void makeTerrainTab() {
188
 
                
189
 
                Insets insets = new Insets(0, 5, 0, 5);
190
 
                
191
 
                // create rotate panel
192
 
                rotatePanel = new JPanel(new BorderLayout());
193
 
                rotatePanel.setBorder(new EmptyBorder(40, 40, 40, 40));
194
 
                rotatePanel.add(rotateBox);
195
 
                final JButton okButton = new JButton("Ok");
196
 
                okButton.addActionListener(new ActionListener() {
197
 
                        public void actionPerformed(ActionEvent e) {
198
 
                                getViewerVR().switchToDefaultPanel();
199
 
                        }
200
 
                });
201
 
                rotatePanel.add(BorderLayout.SOUTH, okButton);
202
 
                
203
 
                terrainPanel = new JPanel(new BorderLayout());
204
 
                Box selections = new Box(BoxLayout.X_AXIS);
205
 
                selections.setBorder(new EmptyBorder(0,5,0,2));
206
 
                
207
 
                JPanel geomPanel = new JPanel(new BorderLayout());
208
 
                TitledBorder title = BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), "Geometry");
209
 
                geomPanel.setBorder(title);
210
 
                JPanel geom = terrain.getGeometrySelection();
211
 
                geomPanel.add(BorderLayout.NORTH,geom);
212
 
                JPanel buttonPanel = new JPanel(new GridLayout(2,1,0,5));
213
 
                buttonPanel.setBorder(new EmptyBorder(5,5,5,5));
214
 
                
215
 
                final JButton terrainLoadButton = new JButton("load");
216
 
                terrainLoadButton.setMargin(insets);
217
 
                terrainLoadButton.addActionListener(new ActionListener() {
218
 
                        public void actionPerformed(ActionEvent arg0) {
219
 
                                switchToTerrainBrowser();
220
 
                        }
221
 
                });
222
 
                buttonPanel.add(terrainLoadButton);
223
 
 
224
 
                final JButton rotateButton = new JButton("rotate");
225
 
                rotateButton.setMargin(insets);
226
 
                rotateButton.addActionListener(new ActionListener() {
227
 
                        public void actionPerformed(ActionEvent arg0) {
228
 
                                switchToRotateBrowser();
229
 
                        }
230
 
                });
231
 
                buttonPanel.add(rotateButton);
232
 
                
233
 
                geomPanel.add(BorderLayout.CENTER, buttonPanel);
234
 
 
235
 
                terrainLoadButton.setEnabled(terrain.getGeometryType() == Terrain.GeometryType.CUSTOM);
236
 
                rotateButton.setEnabled(terrain.getGeometryType() == Terrain.GeometryType.CUSTOM);
237
 
                
238
 
                Box tex = new Box(BoxLayout.Y_AXIS);
239
 
                title = BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder(), "Texture");
240
 
                tex.setBorder(title);
241
 
                tex.add(terrain.getTexureSelection());
242
 
                
243
 
                JPanel texLoadPanel = new JPanel(new GridLayout(1,1));
244
 
                texLoadPanel.setBorder(new EmptyBorder(5,5,0,5));
245
 
                
246
 
                final JButton textureLoadButton = new JButton("load");
247
 
                textureLoadButton.setMargin(insets);
248
 
                textureLoadButton.addActionListener(new ActionListener() {
249
 
                        public void actionPerformed(ActionEvent arg0) {
250
 
                                switchToTerrainTextureBrowser();
251
 
                        }
252
 
                });
253
 
                textureLoadButton.setEnabled(terrain.isCustomTexture());
254
 
                texLoadPanel.add(textureLoadButton);
255
 
                
256
 
                tex.add(texLoadPanel);
257
 
                
258
 
                Box texScaleBox = new Box(BoxLayout.X_AXIS);
259
 
                texScaleBox.setBorder(new EmptyBorder(10, 5, 5, 0));
260
 
                texScaleLabel = new JLabel("scale");
261
 
                terrainTexScaleSlider = new JSlider(SwingConstants.HORIZONTAL, 0, 100, 0);
262
 
                terrainTexScaleSlider.setPreferredSize(new Dimension(70,20));
263
 
                terrainTexScaleSlider.addChangeListener(new ChangeListener() {
264
 
                        public void stateChanged(ChangeEvent arg0) {
265
 
                                double d = .01 * terrainTexScaleSlider.getValue();
266
 
                                setTerrainTextureScale(Math.exp(Math.log(TEX_SCALE_RANGE) * d)/TEX_SCALE_RANGE * MAX_TEX_SCALE);
267
 
                        }
268
 
                });
269
 
                terrainTexScaleEnabled = new JCheckBox();
270
 
                terrainTexScaleEnabled.addChangeListener(new ChangeListener() {
271
 
                        public void stateChanged(ChangeEvent e) {
272
 
                                setTexScaleEnabled(terrainTexScaleEnabled.isSelected());
273
 
                        }
274
 
                });
275
 
                texScaleBox.add(terrainTexScaleEnabled);
276
 
                texScaleBox.add(texScaleLabel);
277
 
                texScaleBox.add(terrainTexScaleSlider);
278
 
                tex.add(texScaleBox);
279
 
                
280
 
                selections.add(geomPanel);
281
 
                selections.add(tex);
282
 
                
283
 
                terrain.addChangeListener(new ChangeListener() {
284
 
                        public void stateChanged(ChangeEvent e) {
285
 
                                updateTerrain();
286
 
                                textureLoadButton.setEnabled(terrain.isCustomTexture());
287
 
                                terrainLoadButton.setEnabled(terrain.getGeometryType() == Terrain.GeometryType.CUSTOM);
288
 
                                rotateButton.setEnabled(terrain.getGeometryType() == Terrain.GeometryType.CUSTOM);
289
 
                        }
290
 
                });
291
 
 
292
 
                JPanel bottom = new JPanel(new BorderLayout());
293
 
                
294
 
                terrainPanel.add(selections);
295
 
                terrainPanel.add(BorderLayout.SOUTH, bottom);
296
 
                
297
 
                
298
 
                // faces
299
 
                faceColorChooser = new SimpleColorChooser();
300
 
                faceColorChooser.setBorder(new EmptyBorder(8,8,8,8));
301
 
                faceColorChooser.addChangeListener( new ChangeListener() {
302
 
                        public void stateChanged(ChangeEvent e) {
303
 
                                setFaceColor(faceColorChooser.getColor());
304
 
                        }
305
 
                });
306
 
                faceColorChooser.addActionListener(new ActionListener() {
307
 
                        public void actionPerformed(ActionEvent e) {
308
 
                                getViewerVR().switchToDefaultPanel();
309
 
                        }
310
 
                });
311
 
                
312
 
                Box faceBox = new Box(BoxLayout.Y_AXIS);
313
 
                faceBox.setBorder(
314
 
                                new CompoundBorder(
315
 
                                                new EmptyBorder(0, 5, 2, 3),
316
 
                                                BorderFactory.createTitledBorder(
317
 
                                                                BorderFactory.createEtchedBorder(),
318
 
                                                                "Appearance"
319
 
                                                )
320
 
                                )
321
 
                );
322
 
                Box faceButtonBox = new Box(BoxLayout.X_AXIS);
323
 
                //faceButtonBox.setBorder(boxBorder);
324
 
                facesReflecting = new JCheckBox("reflect");
325
 
                facesReflecting.addActionListener(new ActionListener() {
326
 
                        public void actionPerformed(ActionEvent e) {
327
 
                                setFacesReflecting(isFacesReflecting());
328
 
                        }
329
 
                });
330
 
                faceButtonBox.add(facesReflecting);
331
 
                faceReflectionSlider = new JSlider(SwingConstants.HORIZONTAL, 0, 100, 0);
332
 
                faceReflectionSlider.setPreferredSize(new Dimension(100,20));
333
 
                faceReflectionSlider.addChangeListener(new ChangeListener() {
334
 
                        public void stateChanged(ChangeEvent e) {
335
 
                                setFaceReflection(getFaceReflection());
336
 
                        }
337
 
                });
338
 
                faceButtonBox.add(faceReflectionSlider);
339
 
                JButton faceColorButton = new JButton("color");
340
 
                faceBox.add(faceButtonBox);
341
 
 
342
 
                Box transparencyBox = new Box(BoxLayout.X_AXIS);
343
 
                transparencyBox.setBorder(new EmptyBorder(0,0,0,8));
344
 
                transparency = new JCheckBox("transp");
345
 
                transparency.addChangeListener(new ChangeListener() {
346
 
                        public void stateChanged(ChangeEvent e) {
347
 
                                setTransparencyEnabled(transparency.isSelected());
348
 
                        }
349
 
                });
350
 
                transparencySlider = new JSlider(SwingConstants.HORIZONTAL, 0, 100, 1);
351
 
                transparencySlider.setPreferredSize(new Dimension(70,20));
352
 
                transparencySlider.addChangeListener(new ChangeListener() {
353
 
                        public void stateChanged(ChangeEvent arg0) {
354
 
                                setTransparency(getTransparency());
355
 
                        }
356
 
                });
357
 
                transparencyBox.add(transparency);
358
 
                transparencyBox.add(transparencySlider);
359
 
                faceColorButton.setMargin(new Insets(0,5,0,5));
360
 
                faceColorButton.addActionListener(new ActionListener() {
361
 
                        public void actionPerformed(ActionEvent arg0) {
362
 
                                switchToColorChooser();
363
 
                        }
364
 
                });
365
 
                transparencyBox.add(faceColorButton);
366
 
                faceBox.add(transparencyBox);
367
 
                
368
 
                bottom.add(faceBox);
369
 
 
370
 
        }
371
 
        
372
 
        public void setTexScaleEnabled(boolean b) {
373
 
                terrainTexScaleEnabled.setSelected(b);
374
 
                if (b) {
375
 
                        setTerrainTextureScale(getTerrainTextureScale());
376
 
                } else {
377
 
                        if (terrainTex != null) terrainTex.setTextureMatrix(null);
378
 
                }
379
 
                terrainTexScaleSlider.setEnabled(b);
380
 
                texScaleLabel.setEnabled(b);
381
 
        }
382
 
        
383
 
        public boolean isTexScaleEnabled() {
384
 
                return terrainTexScaleEnabled.isSelected();
385
 
        }
386
 
 
387
 
        protected void switchToColorChooser() {
388
 
                getViewerVR().switchTo(faceColorChooser);
389
 
        }
390
 
 
391
 
        private Appearance getAppearance() {
392
 
                return getViewerVR().getTerrainAppearance();
393
 
        }
394
 
        
395
 
        public double getFaceReflection() {
396
 
                return .01 * faceReflectionSlider.getValue();
397
 
        }
398
 
        
399
 
        public void setFaceReflection(double d) {
400
 
                faceReflectionSlider.setValue((int)(100*d));
401
 
                if (cmFaces != null) cmFaces.setBlendColor(new Color(1f, 1f, 1f, (float) d));
402
 
        }
403
 
        
404
 
        public double getTransparency() {
405
 
                return .01 * transparencySlider.getValue();
406
 
        }
407
 
        
408
 
        public void setTransparency(double d) {
409
 
                transparencySlider.setValue((int)(100 * d));
410
 
                getAppearance().setAttribute(CommonAttributes.POLYGON_SHADER+"."+CommonAttributes.TRANSPARENCY, d);
411
 
        }
412
 
                
413
 
        public boolean isFacesReflecting() {
414
 
                return facesReflecting.isSelected();
415
 
        }
416
 
        
417
 
        public void setFacesReflecting(boolean b) {
418
 
                facesReflecting.setSelected(b);
419
 
                if (!isFacesReflecting()) {
420
 
                        if (cmFaces != null) {
421
 
                                TextureUtility.removeReflectionMap(getAppearance(), CommonAttributes.POLYGON_SHADER);
422
 
                                cmFaces = null;
423
 
                        }
424
 
                } else {
425
 
                        cmFaces = TextureUtility.createReflectionMap(getAppearance(), CommonAttributes.POLYGON_SHADER, cubeMap);
426
 
                        setFaceReflection(getFaceReflection());
427
 
                }
428
 
        }
429
 
        
430
 
        public Color getFaceColor() {
431
 
                return (Color) getAppearance().getAttribute(
432
 
                                CommonAttributes.POLYGON_SHADER + "."+ CommonAttributes.DIFFUSE_COLOR
433
 
                );
434
 
        }
435
 
        
436
 
        public void setFaceColor(Color c) {
437
 
                faceColorChooser.setColor(c);
438
 
                String attribute = CommonAttributes.POLYGON_SHADER + "."+ CommonAttributes.DIFFUSE_COLOR;
439
 
                getAppearance().setAttribute(attribute,c);
440
 
        }
441
 
        
442
 
        public boolean isTransparencyEnabled() {
443
 
                return transparency.isSelected();
444
 
        }
445
 
        
446
 
        public void setTransparencyEnabled(boolean b) {
447
 
                transparency.setSelected(b);
448
 
                getAppearance().setAttribute(CommonAttributes.TRANSPARENCY_ENABLED, b);
449
 
        }
450
 
 
451
 
        private void makeTerrainTextureFileChooser() {
452
 
                FileSystemView view = FileSystemView.getFileSystemView();
453
 
                String texDir = ".";
454
 
                String dataDir = Secure.getProperty(SystemProperties.JREALITY_DATA);
455
 
                if (dataDir!= null) texDir = dataDir+"/textures";
456
 
                File defaultDir = new File(texDir);
457
 
                terrainTexFileChooser = new JFileChooser(!defaultDir.exists() ? view.getHomeDirectory() : defaultDir, view);
458
 
                terrainTexFileChooser.addActionListener(new ActionListener() {
459
 
                        public void actionPerformed(ActionEvent ev) {
460
 
                                File file = terrainTexFileChooser.getSelectedFile();
461
 
                                try {
462
 
                                        if (ev.getActionCommand() == JFileChooser.APPROVE_SELECTION
463
 
                                                        && file != null) {
464
 
                                                terrainTexFile = file;
465
 
                                                ImageData img = ImageData.load(Input.getInput(terrainTexFile));
466
 
                                                //tex = TextureUtility.createTexture(contentAppearance, "polygonShader", img, false);
467
 
                                                setTerrainTexture(img);
468
 
                                                setTerrainTextureScale(getTerrainTextureScale());
469
 
                                                
470
 
                                        }
471
 
                                } catch (IOException e) {
472
 
                                        e.printStackTrace();
473
 
                                }
474
 
                                getViewerVR().switchToDefaultPanel();
475
 
                        }
476
 
                });
477
 
        }
478
 
 
479
 
        private void makeTerrainFileChooser() {
480
 
                terrainFileChooserPanel = new JPanel(new BorderLayout());
481
 
                sphericalTerrainBox = new JCheckBox("spherical");
482
 
                FileSystemView view = FileSystemView.getFileSystemView();
483
 
                String texDir = ".";
484
 
                String dataDir = Secure.getProperty(SystemProperties.JREALITY_DATA);
485
 
                if (dataDir!= null) texDir = dataDir;
486
 
                File defaultDir = new File(texDir);
487
 
                final JFileChooser terrainFileChooser = new JFileChooser(!defaultDir.exists() ? view.getHomeDirectory() : defaultDir, view);
488
 
                terrainFileChooser.addActionListener(new ActionListener() {
489
 
                        public void actionPerformed(ActionEvent ev) {
490
 
                                File file = terrainFileChooser.getSelectedFile();
491
 
                                try {
492
 
                                        if (ev.getActionCommand() == JFileChooser.APPROVE_SELECTION
493
 
                                                        && file != null) {
494
 
                                                terrainFile = file;
495
 
                                                customTerrain = Readers.read(Input.getInput(terrainFile));
496
 
                                                PickUtility.assignFaceAABBTrees(customTerrain);
497
 
                                                if (!sphericalTerrainBox.isSelected()) getViewerVR().setTerrain(customTerrain);
498
 
                                                else getViewerVR().setTerrainWithCenter(customTerrain);
499
 
                                        }
500
 
                                } catch (IOException e) {
501
 
                                        e.printStackTrace();
502
 
                                }
503
 
                                getViewerVR().switchToDefaultPanel();
504
 
                        }
505
 
                });
506
 
                terrainFileChooserPanel.add(BorderLayout.SOUTH, sphericalTerrainBox);
507
 
                terrainFileChooserPanel.add(BorderLayout.CENTER, terrainFileChooser);
508
 
        }
509
 
 
510
 
        public double getTerrainTextureScale() {
511
 
                double d = .01 * terrainTexScaleSlider.getValue();
512
 
                return Math.exp(Math.log(TEX_SCALE_RANGE) * d)/TEX_SCALE_RANGE * MAX_TEX_SCALE;
513
 
        }
514
 
 
515
 
        public void setTerrainTextureScale(double d) {
516
 
                terrainTexScaleSlider.setValue(
517
 
                                (int)(Math.log(d / MAX_TEX_SCALE * TEX_SCALE_RANGE)/Math.log(TEX_SCALE_RANGE)*100)
518
 
                        );
519
 
                if (terrainTex != null) {
520
 
                        terrainTex.setTextureMatrix(MatrixBuilder.euclidean().scale(d).getMatrix());
521
 
                }
522
 
        }
523
 
        
524
 
        public void switchToTerrainTextureBrowser() {
525
 
                getViewerVR().switchToFileChooser(terrainTexFileChooser);
526
 
        }
527
 
 
528
 
        protected void switchToTerrainBrowser() {
529
 
                getViewerVR().switchToFileChooser(terrainFileChooserPanel);
530
 
        }
531
 
 
532
 
        protected void switchToRotateBrowser() {
533
 
                getViewerVR().switchTo(rotatePanel);
534
 
        }
535
 
 
536
 
 
537
 
        private void setTerrainTexture(ImageData tex) {
538
 
                if (tex != null) {
539
 
                        terrainTex = TextureUtility.createTexture(getViewerVR().getTerrainAppearance(), "polygonShader", tex);
540
 
                } else {
541
 
                        TextureUtility.removeTexture(getViewerVR().getTerrainAppearance(), "polygonShader");
542
 
                }
543
 
        }
544
 
 
545
 
        private void updateTerrain() {
546
 
                // remove last terrain
547
 
                while (terrainNode.getChildComponentCount() > 0) terrainNode.removeChild(terrainNode.getChildComponent(0));
548
 
                // allow spherical only for custom terrain:
549
 
                boolean spherical=false;
550
 
                switch (terrain.getGeometryType()) {
551
 
                case FLAT:
552
 
                        terrainNode.addChild(FLAT_TERRAIN);
553
 
                        new Matrix().assignTo(terrainNode);
554
 
                        break;
555
 
                case NON_FLAT:
556
 
                        terrainNode.addChild(nonflatTerrain);
557
 
                        new Matrix().assignTo(terrainNode);
558
 
                        break;
559
 
                default:
560
 
                        if (customTerrain != null) {
561
 
                                spherical=sphericalTerrainBox.isSelected();
562
 
                                terrainNode.addChild(customTerrain);
563
 
                        }
564
 
                }
565
 
 
566
 
                if (spherical) getViewerVR().setTerrainWithCenter(terrainNode);
567
 
                else getViewerVR().setTerrain(terrainNode);
568
 
 
569
 
                if (terrain.isCustomTexture()) { 
570
 
                        try {
571
 
                                setTerrainTexture(terrainTexFile == null ? null : ImageData.load(Input.getInput(terrainTexFile)));
572
 
                        } catch (IOException e) {
573
 
                                e.printStackTrace();
574
 
                        }
575
 
                } else {
576
 
                        setTerrainTexture(terrain.getTexture());
577
 
                }
578
 
                setTerrainTextureScale(getTerrainTextureScale());
579
 
        }
580
 
        
581
 
        @Override
582
 
        public void storePreferences(Preferences prefs) {
583
 
                prefs.putDouble("texScale", getTerrainTextureScale());
584
 
                prefs.put("texture", terrain.getTextureName());
585
 
                if (terrain.isCustomTexture() && terrainTexFile != null) {
586
 
                        prefs.put("customTex", terrainTexFile.getAbsolutePath());
587
 
                }
588
 
                
589
 
                prefs.put("geometry", terrain.getGeometryName());
590
 
                if (terrain.getGeometryType() == GeometryType.CUSTOM && terrainFile != null) {
591
 
                        prefs.put("customTerrain", terrainFile.getAbsolutePath());
592
 
                }
593
 
 
594
 
                prefs.putBoolean("sphericalTerrain", isSphericalTerrain());
595
 
                
596
 
                prefs.putInt("colorRed", getFaceColor().getRed());
597
 
                prefs.putInt("colorGreen", getFaceColor().getGreen());
598
 
                prefs.putInt("colorBlue", getFaceColor().getBlue());
599
 
 
600
 
                prefs.putDouble("reflection", getFaceReflection());
601
 
                prefs.putBoolean("reflecting", isFacesReflecting());
602
 
                prefs.putBoolean("transparencyEnabled", isTransparencyEnabled());
603
 
                prefs.putDouble("transparency", getTransparency());
604
 
 
605
 
                prefs.putBoolean("texScaleEnabled", isTexScaleEnabled());
606
 
        }
607
 
        
608
 
        private boolean isSphericalTerrain() {
609
 
                return sphericalTerrainBox.isSelected();
610
 
        }
611
 
 
612
 
        @Override
613
 
        public void restoreDefaults() {
614
 
                setTerrainTextureScale(DEFAULT_TEX_SCALE);
615
 
                
616
 
                terrain.setTextureByName(DEFAULT_TEXTURE);
617
 
                terrainTexFile = null;
618
 
                
619
 
                terrain.setGeometryByName(DEFAULT_TERRAIN);
620
 
                terrainFile = null;
621
 
                
622
 
                setSphericalTerrain(DEFAULT_SPHERICAL_TERRAIN);
623
 
                
624
 
                setFaceColor(DEFAULT_FACE_COLOR);
625
 
                setFaceReflection(DEFAULT_REFLECTION);
626
 
                setFacesReflecting(DEFAULT_REFLECTING);
627
 
                setTransparencyEnabled(DEFAULT_TRANSPARENT);
628
 
                setTransparency(DEFAULT_TRANSPARENCY);
629
 
                
630
 
                setTexScaleEnabled(DEFAULT_TEX_SCALE_ENABLED);
631
 
        }
632
 
        
633
 
        private void setSphericalTerrain(boolean b) {
634
 
                sphericalTerrainBox.setSelected(b);
635
 
        }
636
 
 
637
 
        @Override
638
 
        public void restorePreferences(Preferences prefs) {
639
 
                setTerrainTextureScale(prefs.getDouble("texScale", DEFAULT_TEX_SCALE));
640
 
                
641
 
                String texName = prefs.get("texture", DEFAULT_TEXTURE);
642
 
                if ("custom".equals(texName)) {
643
 
                        String fileName = prefs.get("customTex", null);
644
 
                        if (fileName != null) {
645
 
                                terrainTexFile = new File(fileName);
646
 
                                if (!terrainTexFile.exists()) terrainTexFile = null;
647
 
                        }
648
 
                }
649
 
                terrain.setTextureByName(texName);
650
 
 
651
 
                String terrainName = prefs.get("geometry", DEFAULT_TERRAIN);
652
 
                if ("custom".equals(terrainName)) {
653
 
                        String fileName = prefs.get("customTerrain", null);
654
 
                        boolean center = prefs.getBoolean("customTerrainCenter", false);
655
 
                        System.out.println("terrainFile="+fileName);
656
 
                        if (fileName != null) {
657
 
                                terrainFile = new File(fileName);
658
 
                                if (!terrainFile.exists()) terrainFile = null;
659
 
                                else
660
 
                                        try {
661
 
                                                customTerrain = Readers.read(terrainFile);
662
 
                                                PickUtility.assignFaceAABBTrees(customTerrain);
663
 
                                        } catch (IOException e) {
664
 
                                                e.printStackTrace();
665
 
                                        }
666
 
                        }
667
 
                }
668
 
                terrain.setGeometryByName(terrainName);
669
 
                
670
 
                setSphericalTerrain(prefs.getBoolean("sphericalTerrain", DEFAULT_SPHERICAL_TERRAIN));
671
 
                
672
 
                int r = prefs.getInt("colorRed", DEFAULT_FACE_COLOR.getRed());
673
 
                int g = prefs.getInt("colorGreen", DEFAULT_FACE_COLOR.getGreen());
674
 
                int b = prefs.getInt("colorBlue", DEFAULT_FACE_COLOR.getBlue());
675
 
                setFaceColor(new Color(r,g,b));
676
 
 
677
 
                setFaceReflection(prefs.getDouble("reflection", DEFAULT_REFLECTION));
678
 
                setFacesReflecting(prefs.getBoolean("reflecting", DEFAULT_REFLECTING));
679
 
                setTransparencyEnabled(prefs.getBoolean("transparencyEnabled", DEFAULT_TRANSPARENT));
680
 
                setTransparency(prefs.getDouble("transparency", DEFAULT_TRANSPARENCY));
681
 
                
682
 
                setTexScaleEnabled(prefs.getBoolean("texScaleEnabled", DEFAULT_TEX_SCALE_ENABLED));
683
 
    }
684
 
}