private void UpdateCastingShadowLight() { int index = LightTypeComboBox.SelectedIndex; if (index == -1 || _shadowSpotLight == null) { return; } if (index == 0) // Spot light { // Enable shadow casting for spot light _shadowSpotLight.SetDXAttribute(DXAttributeType.IsCastingShadow, _isShadowEnabled); _directionalLight.SetDXAttribute(DXAttributeType.IsCastingShadow, false); // Use only _shadowSpotLight if (_lightsModel3DGroup.Children.Contains(_directionalLight)) { _lightsModel3DGroup.Children.Remove(_directionalLight); } if (!_lightsModel3DGroup.Children.Contains(_shadowSpotLight)) { _lightsModel3DGroup.Children.Add(_shadowSpotLight); } } else // Directional light { // Enable shadow casting for directional light _directionalLight.SetDXAttribute(DXAttributeType.IsCastingShadow, _isShadowEnabled); _shadowSpotLight.SetDXAttribute(DXAttributeType.IsCastingShadow, false); // Use only _directionalLight if (_lightsModel3DGroup.Children.Contains(_shadowSpotLight)) { _lightsModel3DGroup.Children.Remove(_shadowSpotLight); } if (!_lightsModel3DGroup.Children.Contains(_directionalLight)) { _lightsModel3DGroup.Children.Add(_directionalLight); } } }
private void InitializeOvrAndDirectX() { if (UseOculusRift) { // Initializing Oculus VR is very simple when using OculusWrapVirtualRealityProvider // First we create an instance of OculusWrapVirtualRealityProvider _oculusRiftVirtualRealityProvider = new OculusWrapVirtualRealityProvider(_ovr, multisamplingCount: 4); try { // Then we initialize Oculus OVR and create a new DXDevice that uses the same adapter (graphic card) as Oculus Rift _dxDevice = _oculusRiftVirtualRealityProvider.InitializeOvrAndDXDevice(requestedOculusSdkMinorVersion: 17); } catch (Exception ex) { MessageBox.Show("Failed to initialize the Oculus runtime library.\r\nError: " + ex.Message, "Oculus error", MessageBoxButton.OK, MessageBoxImage.Error); return; } string ovrVersionString = _ovr.GetVersionString(); _originalWindowTitle = string.Format("DXEngine OculusWrap Sample (OVR v{0})", ovrVersionString); this.Title = _originalWindowTitle; // Reset tracking origin at startup _ovr.RecenterTrackingOrigin(_oculusRiftVirtualRealityProvider.SessionPtr); } else { // Create DXDevice that will be used to create DXViewportView var dxDeviceConfiguration = new DXDeviceConfiguration(); dxDeviceConfiguration.DriverType = DriverType.Hardware; dxDeviceConfiguration.SupportedFeatureLevels = new FeatureLevel[] { FeatureLevel.Level_11_0 }; // Oculus requires at least feature level 11.0 _dxDevice = new DXDevice(dxDeviceConfiguration); _dxDevice.InitializeDevice(); _originalWindowTitle = this.Title; } // Create WPF's Viewport3D _viewport3D = new Viewport3D(); // Create DXViewportView - a control that will enable DirectX 11 rendering of standard WPF 3D content defined in Viewport3D. // We use a specified DXDevice that was created by the _oculusRiftVirtualRealityProvider.InitializeOvrAndDXDevice (this way the same adapter is used by Oculus and DXEngine). _dxViewportView = new DXViewportView(_dxDevice, _viewport3D); _dxViewportView.BackgroundColor = Colors.Aqua; // Currently DXEngine support showing Oculus mirror texture only with DirectXOverlay presentation type (not with DirectXImage) _dxViewportView.PresentationType = DXView.PresentationTypes.DirectXOverlay; if (UseOculusRift) { // The _dxViewportView will show Oculus mirrow window. // The mirror window can be any size, for this sample we use 1/2 the HMD resolution. _dxViewportView.Width = _oculusRiftVirtualRealityProvider.HmdDescription.Resolution.Width / 2.0; _dxViewportView.Height = _oculusRiftVirtualRealityProvider.HmdDescription.Resolution.Height / 2.0; } // When the DXViewportView is initialized, we set the _oculusRiftVirtualRealityProvider to the DXScene object _dxViewportView.DXSceneInitialized += delegate(object sender, EventArgs args) { if (_dxViewportView.UsedGraphicsProfile.DriverType != GraphicsProfile.DriverTypes.Wpf3D && _dxViewportView.DXScene != null && _oculusRiftVirtualRealityProvider != null) { // Initialize Virtual reality rendering _dxViewportView.DXScene.InitializeVirtualRealityRendering(_oculusRiftVirtualRealityProvider); // Initialized shadow rendering (see Ab3d.DXEngine.Wpf.Samples project - DXEngine/ShadowRenderingSample for more info _varianceShadowRenderingProvider = new VarianceShadowRenderingProvider() { ShadowMapSize = 1024, ShadowDepthBluringSize = 2, ShadowTreshold = 0.2f }; _dxViewportView.DXScene.InitializeShadowRendering(_varianceShadowRenderingProvider); } }; // Enable collecting rendering statistics (see _dxViewportView.DXScene.Statistics class) DXDiagnostics.IsCollectingStatistics = true; // Subscribe to SceneRendered to collect FPS statistics _dxViewportView.SceneRendered += DXViewportViewOnSceneRendered; // Add _dxViewportView to the RootGrid // Before that we resize the window to be big enough to show the mirrored texture this.Width = _dxViewportView.Width + 30; this.Height = _dxViewportView.Height + 50; RootGrid.Children.Add(_dxViewportView); // Create FirstPersonCamera _camera = new FirstPersonCamera() { TargetViewport3D = _viewport3D, Position = new Point3D(0, 1, 4), Heading = 0, Attitude = 0, ShowCameraLight = ShowCameraLightType.Never }; RootGrid.Children.Add(_camera); // Initialize XBOX controller that will control the FirstPersonCamera _xInputCameraController = new XInputCameraController(); _xInputCameraController.TargetCamera = _camera; _xInputCameraController.MovementSpeed = 0.02; _xInputCameraController.MoveVerticallyWithDPadButtons = true; // We handle the rotation by ourself to prevent rotating the camera up and down - this is done only by HMD _xInputCameraController.RightThumbChanged += delegate(object sender, XInputControllerThumbChangedEventArgs e) { // Apply only horizontal rotation _camera.Heading += e.NormalizedX * _xInputCameraController.RotationSpeed; // Mark the event as handled e.IsHandled = true; }; _xInputCameraController.StartCheckingController(); // Now we can create our sample 3D scene CreateSceneObjects(); // Add lights var lightsVisual3D = new ModelVisual3D(); var lightsGroup = new Model3DGroup(); var directionalLight = new DirectionalLight(Colors.White, new Vector3D(0.5, -0.3, -0.3)); directionalLight.SetDXAttribute(DXAttributeType.IsCastingShadow, true); // Set this light to cast shadow lightsGroup.Children.Add(directionalLight); var ambientLight = new AmbientLight(System.Windows.Media.Color.FromRgb(30, 30, 30)); lightsGroup.Children.Add(ambientLight); lightsVisual3D.Content = lightsGroup; _viewport3D.Children.Add(lightsVisual3D); // Start rendering if (RenderAt90Fps) { // WPF do not support rendering at more the 60 FPS. // But with a trick where a rendering loop is created in a background thread, it is possible to achieve more than 60 FPS. // In case of sumbiting frames to Oculus Rift, the ovr.SubmitFrame method will limit rendering to 90 FPS. // // NOTE: // When using DXEngine, it is also possible to render the scene in a background thread. // This requires that the 3D scene is also created in the background thread and that the events and other messages are // passed between UI and background thread in a thread safe way. This is too complicated for this simple sample project. // To see one possible implementation of background rendering, see the BackgroundRenderingSample in the Ab3d.DXEngine.Wpf.Samples project. var backgroundWorker = new BackgroundWorker(); backgroundWorker.DoWork += (object sender, DoWorkEventArgs args) => { // Create an action that will be called by Dispatcher var refreshDXEngineAction = new Action(() => { UpdateScene(); // Render DXEngine's 3D scene again if (_dxViewportView != null) { _dxViewportView.Refresh(); } }); while (_dxViewportView != null && !_dxViewportView.IsDisposed) // Render until window is closed { if (_oculusRiftVirtualRealityProvider != null && _oculusRiftVirtualRealityProvider.LastSessionStatus.ShouldQuit) // Stop rendering - this will call RunWorkerCompleted where we can quit the application { break; } // Sleep for 1 ms to allow WPF tasks to complete (for example handling XBOX controller events) System.Threading.Thread.Sleep(1); // Call Refresh to render the DXEngine's scene // This is a synchronous call and will wait until the scene is rendered. // Because Oculus is limited to 90 fps, the call to ovr.SubmitFrame will limit rendering to 90 FPS. Dispatcher.Invoke(refreshDXEngineAction); } }; backgroundWorker.RunWorkerCompleted += delegate(object sender, RunWorkerCompletedEventArgs args) { if (_oculusRiftVirtualRealityProvider != null && _oculusRiftVirtualRealityProvider.LastSessionStatus.ShouldQuit) { this.Close(); // Exit the application } }; backgroundWorker.RunWorkerAsync(); } else { // Subscribe to WPF rendering event (called approximately 60 times per second) CompositionTarget.Rendering += CompositionTargetOnRendering; } }