Use this call to zoom into {@link GVRScene}s

@param gvrScenes the scenes to zoom into

@throws UnsupportedOperationException returns an exception when the camera rig attached to
the scene does not support this operation
977100
public void zoomIn(GVRScene... gvrScenes) {
        for (GVRScene gvrScene : gvrScenes) {
            try {
                GVRPerspectiveCamera leftCameraMainScene = ((GVRPerspectiveCamera) gvrScene.getMainCameraRig().getLeftCamera());
                GVRPerspectiveCamera rightCameraMainScene = ((GVRPerspectiveCamera) gvrScene.getMainCameraRig().getRightCamera());
                if (leftCameraMainScene.getFovY() > MAX_ZOOM) {
                    leftCameraMainScene.setFovY(leftCameraMainScene.getFovY() - ZOOM_FACTOR);
                    rightCameraMainScene.setFovY(rightCameraMainScene.getFovY() - ZOOM_FACTOR);
                }
            } catch (ClassCastException e){
                throw new UnsupportedOperationException("Operation unsupported for this camera " +
                        "type");
            }

        }
    }
370810
public synchronized void removeAllSceneObjects() {
        final GVRCameraRig rig = getMainCameraRig();
        final GVRSceneObject head = rig.getOwnerObject();
        rig.removeAllChildren();

        NativeScene.removeAllSceneObjects(getNative());
        for (final GVRSceneObject child : mSceneRoot.getChildren()) {
            child.getParent().removeChildObject(child);
        }

        if (null != head) {
            mSceneRoot.addChildObject(head);
        }

        final int numControllers = getGVRContext().getInputManager().clear();
        if (numControllers > 0)
        {
            getGVRContext().getInputManager().selectController();
        }

        getGVRContext().runOnGlThread(new Runnable() {
            @Override
            public void run() {
                NativeScene.deleteLightsAndDepthTextureOnRenderThread(getNative());
            }
        });
    }
893812
public void attachLeftCamera(GVRCamera camera) {
        if (camera.hasOwnerObject()) {
            camera.getOwnerObject().detachCamera();
        }

        leftCameraObject.attachCamera(camera);
        leftCamera = camera;
        NativeCameraRig.attachLeftCamera(getNative(), camera.getNative());
    }
178819
public void attachRightCamera(GVRCamera camera) {
        if (camera.hasOwnerObject()) {
            camera.getOwnerObject().detachCamera();
        }

        rightCameraObject.attachCamera(camera);
        rightCamera = camera;
        NativeCameraRig.attachRightCamera(getNative(), camera.getNative());
    }
244403
protected void AddLODSceneObject(GVRSceneObject currentSceneObject) {
    if (this.transformLODSceneObject != null) {
      GVRSceneObject levelOfDetailSceneObject = null;
      if ( currentSceneObject.getParent() == this.transformLODSceneObject) {
        levelOfDetailSceneObject = currentSceneObject;
      }
      else {
        GVRSceneObject lodSceneObj = root.getSceneObjectByName((currentSceneObject.getName() + TRANSFORM_TRANSLATION_));
        if ( lodSceneObj != null ) {
          if (lodSceneObj.getParent() == this.transformLODSceneObject) {
            levelOfDetailSceneObject = lodSceneObj;
          }
        }
        if (levelOfDetailSceneObject == null) {
          lodSceneObj = root.getSceneObjectByName((currentSceneObject.getName() + TRANSFORM_ROTATION_));
          if ( lodSceneObj != null ) {
            if (lodSceneObj.getParent() == this.transformLODSceneObject) {
              levelOfDetailSceneObject = lodSceneObj;
            }
          }
        }
        if (levelOfDetailSceneObject == null) {
          lodSceneObj = root.getSceneObjectByName((currentSceneObject.getName() + TRANSFORM_SCALE_));
          if ( lodSceneObj != null ) {
            if (lodSceneObj.getParent() == this.transformLODSceneObject) {
              levelOfDetailSceneObject = lodSceneObj;
            }
          }
        }

      }
      if ( levelOfDetailSceneObject != null) {
        final GVRLODGroup lodGroup = (GVRLODGroup) this.transformLODSceneObject.getComponent(GVRLODGroup.getComponentType());
        lodGroup.addRange(this.getMinRange(), levelOfDetailSceneObject);
        this.increment();
      }
    }
  }
1094914
public void setNodeSnapshots(java.util.Collection<NodeSnapshot> nodeSnapshots) {
        if (nodeSnapshots == null) {
            this.nodeSnapshots = null;
            return;
        }

        this.nodeSnapshots = new com.amazonaws.internal.SdkInternalList<NodeSnapshot>(nodeSnapshots);
    }
182899
public void copyDeepMask(BufferedImage pSrcBitmap,
                             BufferedImage pMaskBitmap,
                             Rectangle pSrcRect,
                             Rectangle pMaskRect,
                             Rectangle pDstRect,
                             int pSrcCopy,
                             Shape pMaskRgn) {
        throw new UnsupportedOperationException("Method copyDeepMask not implemented"); // TODO: Implement
    }
421671
private void ar2gvr(float scale) {
        // Real world scale
        Matrix.scaleM(mPoseMatrix, 0, scale, scale, scale);
        mPoseMatrix[12] = mPoseMatrix[12] * scale;
        mPoseMatrix[13] = mPoseMatrix[13] * scale;
        mPoseMatrix[14] = mPoseMatrix[14] * scale;
    }
943131
protected void setVisible(boolean visible) {
        GVRSceneObject sceneObject = gvrCursorController.getCursor();
        if (sceneObject != null && sceneObject.isEnabled() != visible) {
            sceneObject.setEnable(visible);
        }
    }
623919
@Override
    public void renderBranch( PositionedText target, double x, double y,
                              Size size, Collection<Diagram.Figure> branches, boolean forward )
    {
        throw new UnsupportedOperationException( "not implemented" );
    }
226249
public void rotateToFaceCamera(final GVRTransform transform) {
        //see http://stackoverflow.com/questions/5782658/extracting-yaw-from-a-quaternion
        final GVRTransform t = getMainCameraRig().getHeadTransform();
        final Quaternionf q = new Quaternionf(0, t.getRotationY(), 0, t.getRotationW()).normalize();

        transform.rotateWithPivot(q.w, q.x, q.y, q.z, 0, 0, 0);
    }
1118932
void load(Cursor cursor) {
        assetRoot = new GVRSceneObject(cursor.getGVRContext());
        assetRoot.attachComponent(new GVRSwitch(cursor.getGVRContext()));
        for (CursorAsset asset : assets.values()) {
            asset.load(cursor);
        }
    }
800338
public ReferencedEnvelope setLayers() throws Exception {
        ReferencedEnvelope maxExtent = null;

        // wms first
        if (wmsURL != null) {
            String[] split = wmsURL.split("#");
            WebMapServer server = new WebMapServer(new URL(split[0]));
            org.geotools.data.ows.Layer wmsLayer = getWMSLayer(server, split[1]);
            WMSLayer layer = new WMSLayer(server, wmsLayer);
            layers.add(layer);

            ReferencedEnvelope originalEnvelope = layer.getBounds();
            if (originalEnvelope != null) {
                if (maxExtent == null) {
                    maxExtent = new ReferencedEnvelope(originalEnvelope.getCoordinateReferenceSystem());
                }
                expandToIncludeEnvelope(maxExtent, originalEnvelope);
            }
        }

        // coverages
        monitor.beginTask("Reading raster maps...", coveragePaths.size());
        for( int r = 0; r < coveragePaths.size(); r++ ) {
            String coveragePath = coveragePaths.get(r);
            GridGeometry2D region = null;
            if (coverageRegions != null && coverageRegions.size() == coveragePaths.size()) {
                region = coverageRegions.get(r);
            }

            File file = new File(coveragePath);
            GridCoverage2D raster = null;
            AbstractGridCoverage2DReader reader = null;
            try {

                try {
                    // first try a format that gives back a reader
                    AbstractGridFormat format = GridFormatFinder.findFormat(file);
                    reader = format.getReader(file);
                    if (reader instanceof GrassCoverageReader) {
                        reader = null;
                    }
                } catch (Exception e1) {
                    // ignore and try others
                }
                if (reader == null) {

                    if (region == null) {
                        raster = OmsRasterReader.readRaster(coveragePath);
                    } else {
                        RegionMap regionMap = CoverageUtilities.gridGeometry2RegionParamsMap(region);
                        double n = regionMap.getNorth();
                        double s = regionMap.getSouth();
                        double w = regionMap.getWest();
                        double e = regionMap.getEast();
                        double xres = regionMap.getXres();
                        double yres = regionMap.getYres();
                        OmsRasterReader rreader = new OmsRasterReader();
                        rreader.file = coveragePath;
                        rreader.pNorth = n;
                        rreader.pSouth = s;
                        rreader.pWest = w;
                        rreader.pEast = e;
                        rreader.pXres = xres;
                        rreader.pYres = yres;
                        rreader.doLegacyGrass = doLegacyGrass;
                        rreader.process();
                        raster = rreader.outRaster;
                    }

                }
                // if (crs == null) {
                // crs = raster.getCoordinateReferenceSystem();
                // }
            } catch (Exception e) {
                monitor.errorMessage(e.getLocalizedMessage());
                monitor.errorMessage("Trying to find other coverage source...");
                // try with available readers
                try {
                    AbstractGridFormat format = GridFormatFinder.findFormat(file);
                    reader = format.getReader(file);
                    // if (crs == null) {
                    // crs = reader.getCrs();
                    // }
                } catch (Exception ex) {
                    throw ex;
                }
            }
            File styleFile = FileUtilities.substituteExtention(file, "sld");
            Style style;
            if (styleFile.exists()) {
                style = SldUtilities.getStyleFromFile(styleFile);
            } else {
                style = SldUtilities.getStyleFromRasterFile(styleFile);
            }

            if (raster != null) {
                GridCoverageLayer layer = new GridCoverageLayer(raster, style);
                layers.add(layer);

                org.opengis.geometry.Envelope envelope = raster.getEnvelope();
                if (maxExtent == null) {
                    maxExtent = new ReferencedEnvelope(envelope.getCoordinateReferenceSystem());
                }
                expandToIncludeEnvelope(maxExtent, envelope);
            }
            if (reader != null) {
                GridReaderLayer layer = new GridReaderLayer(reader, style);
                // SimpleFeatureSource featureSource = layer.getFeatureSource();
                layers.add(layer);

                org.opengis.geometry.Envelope envelope = reader.getOriginalEnvelope();
                if (maxExtent == null) {
                    maxExtent = new ReferencedEnvelope(envelope.getCoordinateReferenceSystem());
                }
                expandToIncludeEnvelope(maxExtent, envelope);
            }
            monitor.worked(1);
        }
        monitor.done();

        monitor.beginTask("Reading vector maps...", featurePaths.size());
        for( int i = 0; i < featurePaths.size(); i++ ) {
            String featurePath = featurePaths.get(i);
            String filter = featureFilter.get(i);
            FileDataStore store = FileDataStoreFinder.getDataStore(new File(featurePath));
            SimpleFeatureSource featureSource = store.getFeatureSource();
            SimpleFeatureCollection featureCollection;
            if (filter.length() == 0) {
                featureCollection = featureSource.getFeatures();
            } else {
                featureCollection = featureSource.getFeatures(ECQL.toFilter(filter));
            }
            // if (crs == null) {
            // crs = featureSource.getSchema().getCoordinateReferenceSystem();
            // }

            File styleFile = FileUtilities.substituteExtention(new File(featurePath), "sld");
            Style style;
            if (styleFile.exists()) {
                style = SldUtilities.getStyleFromFile(styleFile);
            } else {
                style = SLD.createSimpleStyle(featureSource.getSchema());
            }

            FeatureLayer layer = new FeatureLayer(featureCollection, style);
            layers.add(layer);

            if (maxExtent == null) {
                maxExtent = new ReferencedEnvelope(featureCollection.getSchema().getCoordinateReferenceSystem());
            }
            expandToIncludeEnvelope(maxExtent, featureCollection.getBounds());

            monitor.worked(1);
        }

        synchronizedLayers = Collections.synchronizedList(layers);

        monitor.done();
        return maxExtent;
    }
753749
public void setVpcs(java.util.Collection<ClassicLinkDnsSupport> vpcs) {
        if (vpcs == null) {
            this.vpcs = null;
            return;
        }

        this.vpcs = new com.amazonaws.internal.SdkInternalList<ClassicLinkDnsSupport>(vpcs);
    }
802745
private void ar2gvr(float[] poseMatrix, float scale) {
        // Real world scale
        Matrix.scaleM(poseMatrix, 0, scale, scale, scale);
        poseMatrix[12] = poseMatrix[12] * scale;
        poseMatrix[13] = poseMatrix[13] * scale;
        poseMatrix[14] = poseMatrix[14] * scale;
    }
952411
public void setSupportedCompressionTypes(java.util.Collection<String> supportedCompressionTypes) {
        if (supportedCompressionTypes == null) {
            this.supportedCompressionTypes = null;
            return;
        }

        this.supportedCompressionTypes = new java.util.ArrayList<String>(supportedCompressionTypes);
    }
1037117
@Override
	public void setSecondAxis(double x, double y, double z, double extent) {
		setSecondAxis(x, y, z, extent, CoordinateSystem3D.getDefaultCoordinateSystem());
	}