Revision 15213

View differences:

import/ext3D/trunk/ext3D/src/com/iver/ai2/gvsig3d/map3d/layers/FLayers3D.java
63 63
import es.upv.ai2.libjosg.viewer.Camera;
64 64
import es.upv.ai2.libjosg.viewer.IViewerContainer;
65 65

  
66
public class FLayers3D extends FLayers implements //TileCreatedListener,
66
public class FLayers3D extends FLayers implements // TileCreatedListener,
67 67
		RequestLayerListener, LegendListener, LayerListener {
68 68

  
69 69
	// JOSG library objects
......
127 127
				FLayer layer = (FLayer) layerList.get(iLayer);
128 128
				Layer3DProps props = getLayer3DProps(layer);
129 129
				addLayerToPlanet(layer, props.getOrder(), false);
130
				
131
				// Layer active or not 
132
				if (props.getType() == Layer3DProps.layer3DImage) {
133
					m_planet.setEnabledTextureLayer(props.getOrder(), layer
134
							.isVisible());
135
				}
136
				if (props.getType() == Layer3DProps.layer3DElevation) {
137
					m_planet.setEnabledHeightfieldLayer(0, layer.isVisible());
138
				}
130 139
			}
131 140
			if (iType == Layer3DProps.layer3DElevation && layerList.size() > 0)
132 141
				m_planet.invalidateHeightfieldLayer(0);
......
479 488

  
480 489
		Layer3DProps props3D = getLayer3DProps(layer);
481 490
		if (props3D.getType() == Layer3DProps.layer3DImage) {
482
			m_planet.setEnabledTextureLayer(props3D.getOrder(), layer.isVisible());
491
			m_planet.setEnabledTextureLayer(props3D.getOrder(), layer
492
					.isVisible());
483 493
		}
484 494
		if (props3D.getType() == Layer3DProps.layer3DElevation) {
485 495
			m_planet.setEnabledHeightfieldLayer(0, layer.isVisible());
......
678 688
			// Con autotransform
679 689
			AutoTransform trans = new AutoTransform();
680 690
			trans.addChild(flag);
681
			int scale = (int)((20/4.5) * 1000);
691
			int scale = (int) ((20 / 4.5) * 1000);
682 692
			trans.setScale(new Vec3(scale, scale, scale));
683 693
			trans.setPosition(posIni);
684 694
			trans
......
809 819

  
810 820
	}
811 821

  
812
	//Deprecated method
813
	/*public void tileCreated(TileEvent evt) {
814
		int textureStage = 0;
815
		int MDTStage = 0;
822
	// Deprecated method
823
	/*
824
	 * public void tileCreated(TileEvent evt) { int textureStage = 0; int
825
	 * MDTStage = 0;
826
	 * 
827
	 * SingleLayerIterator lyrIterator = new SingleLayerIterator(this); while
828
	 * (lyrIterator.hasNext()) { FLayer lyr = lyrIterator.next();
829
	 * 
830
	 * Layer3DProps props3D = getLayer3DProps(lyr); int dataType =
831
	 * props3D.getType();
832
	 * 
833
	 * if (lyr.isVisible()) { // if (true) { if (dataType ==
834
	 * Layer3DProps.layer3DVector) continue; // get/create cache service
835
	 * FLayerCacheService cacheService = (FLayerCacheService) props3D
836
	 * .getCacheService(); if (cacheService == null) { cacheService = new
837
	 * FLayerCacheService(m_planet, props3D .getCacheName(), lyr,
838
	 * m_viewProjection); cacheService.setCacheRootDir(Layer3DProps.m_cacheDir);
839
	 * props3D.setCacheService(cacheService); }
840
	 * 
841
	 * Point tileIndices = new Point(evt.getX(), evt.getY()); TileNum tileNum =
842
	 * new TileNum(evt.getLevel(), tileIndices);
843
	 * 
844
	 * String tileFileName;
845
	 * 
846
	 * if (cacheService.intersectsLayer(tileNum)) { // extent test try {
847
	 * tileFileName = cacheService.getTileAsFName(tileNum); } catch
848
	 * (CacheServiceException e) { return; }
849
	 * 
850
	 * if (dataType == Layer3DProps.layer3DImage) { // float opacity = 1.0f;
851
	 * String fileExtension = "png";
852
	 * evt.getTilePagedLod().setTexture(tileFileName, fileExtension,
853
	 * textureStage); m_planet.setTextureOpacity(textureStage, props3D
854
	 * .getOpacity()); textureStage++; } else if (dataType ==
855
	 * Layer3DProps.layer3DElevation) { String fileExtension = "tif";
856
	 * evt.getTilePagedLod().setHeightField(tileFileName, fileExtension,
857
	 * MDTStage); // m_planet.setVerticalExaggeration(MDTStage, //
858
	 * ((ProjectView3D) this.m_viewProjection) // .getVerticalExaggeration());
859
	 * m_planet.setVerticalExaggeration(MDTStage, props3D .getVerticalEx());
860
	 * MDTStage++; } } else { // no intersection if (dataType ==
861
	 * Layer3DProps.layer3DImage) { evt.getTilePagedLod() .setTexture("", "",
862
	 * textureStage++); } if (dataType == Layer3DProps.layer3DElevation) {
863
	 * evt.getTilePagedLod().setHeightField("", "", MDTStage); } } } else { if
864
	 * (dataType == Layer3DProps.layer3DImage) { textureStage++; } if (dataType ==
865
	 * Layer3DProps.layer3DElevation) { MDTStage++; } } // REPAINTING VIEWER if
866
	 * (m_canvas3d != null) m_canvas3d.repaint(); } }
867
	 */
816 868

  
817
		SingleLayerIterator lyrIterator = new SingleLayerIterator(this);
818
		while (lyrIterator.hasNext()) {
819
			FLayer lyr = lyrIterator.next();
820

  
821
			Layer3DProps props3D = getLayer3DProps(lyr);
822
			int dataType = props3D.getType();
823

  
824
			if (lyr.isVisible()) {
825
				// if (true) {
826
				if (dataType == Layer3DProps.layer3DVector)
827
					continue;
828

  
829
				// get/create cache service
830
				FLayerCacheService cacheService = (FLayerCacheService) props3D
831
						.getCacheService();
832
				if (cacheService == null) {
833
					cacheService = new FLayerCacheService(m_planet, props3D
834
							.getCacheName(), lyr, m_viewProjection);
835
					cacheService.setCacheRootDir(Layer3DProps.m_cacheDir);
836
					props3D.setCacheService(cacheService);
837
				}
838

  
839
				Point tileIndices = new Point(evt.getX(), evt.getY());
840
				TileNum tileNum = new TileNum(evt.getLevel(), tileIndices);
841

  
842
				String tileFileName;
843

  
844
				if (cacheService.intersectsLayer(tileNum)) { // extent test
845
					try {
846
						tileFileName = cacheService.getTileAsFName(tileNum);
847
					} catch (CacheServiceException e) {
848
						return;
849
					}
850

  
851
					if (dataType == Layer3DProps.layer3DImage) {
852
						// float opacity = 1.0f;
853
						String fileExtension = "png";
854
						evt.getTilePagedLod().setTexture(tileFileName,
855
								fileExtension, textureStage);
856
						m_planet.setTextureOpacity(textureStage, props3D
857
								.getOpacity());
858
						textureStage++;
859
					} else if (dataType == Layer3DProps.layer3DElevation) {
860
						String fileExtension = "tif";
861
						evt.getTilePagedLod().setHeightField(tileFileName,
862
								fileExtension, MDTStage);
863
						// m_planet.setVerticalExaggeration(MDTStage,
864
						// ((ProjectView3D) this.m_viewProjection)
865
						// .getVerticalExaggeration());
866
						m_planet.setVerticalExaggeration(MDTStage, props3D
867
								.getVerticalEx());
868
						MDTStage++;
869
					}
870
				} else { // no intersection
871
					if (dataType == Layer3DProps.layer3DImage) {
872
						evt.getTilePagedLod()
873
								.setTexture("", "", textureStage++);
874
					}
875
					if (dataType == Layer3DProps.layer3DElevation) {
876
						evt.getTilePagedLod().setHeightField("", "", MDTStage);
877
					}
878
				}
879
			} else {
880
				if (dataType == Layer3DProps.layer3DImage) {
881
					textureStage++;
882
				}
883
				if (dataType == Layer3DProps.layer3DElevation) {
884
					MDTStage++;
885
				}
886
			}
887

  
888
			// REPAINTING VIEWER
889
			if (m_canvas3d != null)
890
				m_canvas3d.repaint();
891

  
892
		}
893

  
894
	}*/
895

  
896 869
	public void requestMDTLayer(TileEvent evt) {
897 870

  
898 871
		// TODO : All this method are not tested
......
932 905

  
933 906
			if (dataType == Layer3DProps.layer3DElevation) {
934 907
				String fileExtension = "tif";
935
				//evt.getTilePagedLod().setHeightField(tileFileName, fileExtension, order);
936
				m_planet.setHeightfield(evt.getTilePagedLod(), tileFileName, order);
908
				// evt.getTilePagedLod().setHeightField(tileFileName,
909
				// fileExtension, order);
910
				m_planet.setHeightfield(evt.getTilePagedLod(), tileFileName,
911
						order);
937 912
				// m_planet.setVerticalExaggeration(order,
938 913
				// ((ProjectView3D) this.m_viewProjection)
939 914
				// .getVerticalExaggeration());
940
				m_planet.setVerticalExaggerationLayer(order, props3D.getVerticalEx());
915
				m_planet.setVerticalExaggerationLayer(order, props3D
916
						.getVerticalEx());
941 917

  
942 918
			}
943 919
		} else { // no intersection for elevation layer
944 920
			// This code are not correctly for elevation layer
945 921
			if (dataType == Layer3DProps.layer3DImage) {
946 922
				m_planet.setHeightfield(evt.getTilePagedLod(), "", order);
947
				//evt.getTilePagedLod().setHeightField("", "", order);
923
				// evt.getTilePagedLod().setHeightField("", "", order);
948 924
			}
949 925
		}
950 926

  
......
960 936
		int order = evt.getRequestedLayer();
961 937
		ArrayList imageLayers = (ArrayList) m_layerLists
962 938
				.get(Layer3DProps.layer3DImage);
963
		
939

  
964 940
		// if there are not one layer return
965 941
		if (imageLayers.size() == 0)
966 942
			return;
......
984 960
		TileNum tileNum = new TileNum(evt.getLevel(), tileIndices);
985 961

  
986 962
		String tileFileName;
987
		
963

  
988 964
		if (cacheService.intersectsLayer(tileNum)) { // extent test
989 965
			try {
990 966
				tileFileName = cacheService.getTileAsFName(tileNum);
......
995 971
			if (dataType == Layer3DProps.layer3DImage) {
996 972
				// float opacity = 1.0f;
997 973
				String fileExtension = "png";
998
				//@TODO:aplicar texturas al planeta
999
				//evt.getTilePagedLod().setTexture(tileFileName, fileExtension, order);
1000
 				m_planet.setTexture(evt.getTilePagedLod(), tileFileName, order);
974
				// @TODO:aplicar texturas al planeta
975
				// evt.getTilePagedLod().setTexture(tileFileName, fileExtension,
976
				// order);
977
				m_planet.setTexture(evt.getTilePagedLod(), tileFileName, order);
1001 978
				m_planet.setTextureOpacityLayer(order, props3D.getOpacity());
1002 979
			}
1003 980
			/*
......
1008 985
		} else { // no intersection
1009 986
			if (dataType == Layer3DProps.layer3DImage) {
1010 987
				m_planet.setTexture(evt.getTilePagedLod(), "", order);
1011
				//evt.getTilePagedLod().setTexture("", "", order);
988
				// evt.getTilePagedLod().setTexture("", "", order);
1012 989
			}
1013 990
		}
1014 991

  

Also available in: Unified diff