Beispiel #1
0
        private void UpdateEyeProperties()
        {
            var cameraResources = this.deviceResources.cameraResourcesDictionary.Values.FirstOrDefault();

            if (cameraResources != null)
            {
                int newWidth  = (int)cameraResources.RenderTargetSize.Width;
                int newHeight = (int)cameraResources.RenderTargetSize.Height;

                int backBufferPointer = (int)cameraResources.BackBufferTexture2D.NativePointer;

                VREyeTexture[] vrEyeTexture;
                if (this.backBufferHandles.TryGetValue(backBufferPointer, out vrEyeTexture))
                {
                    if (newWidth != this.adapter.Width || newHeight != this.adapter.Height)
                    {
                        // Free renderTarget
                        for (int r = 0; r < vrEyeTexture.Length; r++)
                        {
                            this.renderTargetManager.DestroyDepthTexture(vrEyeTexture[r].RenderTarget.DepthTexture);
                            this.renderTargetManager.DestroyRenderTarget(vrEyeTexture[r].RenderTarget);
                        }

                        this.CreateRenderTargets(cameraResources, newWidth, newHeight, backBufferPointer, this.adapter, this.renderTargetManager);

                        for (int r = 0; r < vrEyeTexture.Length; r++)
                        {
                            this.backBufferHandles[backBufferPointer][r] = this.eyesProperties[r].Texture;
                        }
                    }
                    else
                    {
                        var lenght = cameraResources.IsRenderingStereoscopic ? 2 : 1;

                        for (int i = 0; i < lenght; i++)
                        {
                            this.eyesProperties[i].Texture = vrEyeTexture[i];
                        }
                        var eyeRT = this.eyesProperties[0].Texture.RenderTarget;
                        var dxRT  = this.renderTargetManager.TargetFromHandle <DXRenderTarget>(eyeRT.TextureHandle);
                        this.adapter.GraphicsDevice.BackBuffer = dxRT.TargetView;
                    }
                }
                else
                {
                    this.CreateRenderTargets(cameraResources, newWidth, newHeight, backBufferPointer, this.adapter, this.renderTargetManager);

                    VREyeTexture[] textures = new VREyeTexture[]
                    {
                        this.eyesProperties[0].Texture,
                        this.eyesProperties[1].Texture
                    };

                    this.backBufferHandles.Add(backBufferPointer, textures);
                }
            }
        }
Beispiel #2
0
        /// <summary>
        /// Create Render targets
        /// </summary>
        /// <param name="cameraResources">camera Resources</param>
        /// <param name="newWidth">render width</param>
        /// <param name="newHeight">render height</param>
        /// <param name="backBufferPointer">target handle</param>
        /// <param name="adapter">adapter instance</param>
        /// <param name="renderTargetManager">render Target Manager</param>
        private void CreateRenderTargets(CameraResources cameraResources, int newWidth, int newHeight, int backBufferPointer, Adapter.Adapter adapter, RenderTargetManager renderTargetManager)
        {
            adapter.SetSize(newWidth, newHeight);

            DepthTexture depthTexture = renderTargetManager.CreateDepthTexture(newWidth, newHeight);

            var lenght = cameraResources.IsRenderingStereoscopic ? 2 : 1;

            for (int i = 0; i < lenght; i++)
            {
                RenderTargetViewDescription rtViewDescription = new RenderTargetViewDescription()
                {
                    Format         = cameraResources.BackBufferTexture2D.Description.Format,
                    Dimension      = RenderTargetViewDimension.Texture2DArray,
                    Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
                    {
                        FirstArraySlice = i,
                        ArraySize       = 1,
                        MipSlice        = 0
                    }
                };

                var renderTarget = renderTargetManager.CreateRenderTarget(cameraResources.BackBufferTexture2D, rtViewDescription);
                renderTarget.DepthTexture = depthTexture;

                var eyeTexture = new VREyeTexture()
                {
                    Viewport     = new Viewport(0, 0, 1, 1),
                    NearPlane    = 0.01f,
                    FarPlane     = 1000,
                    RenderTarget = renderTarget
                };

                this.eyesProperties[i].Texture = eyeTexture;
            }

            var eyeRT = this.eyesProperties[0].Texture.RenderTarget;
            var dxRT  = renderTargetManager.TargetFromHandle <DXRenderTarget>(eyeRT.TextureHandle);

            adapter.GraphicsDevice.BackBuffer = dxRT.TargetView;
        }
        private void UpdateEyeProperties()
        {
            var cameraResources = this.deviceResources.cameraResourcesDictionary.Values.FirstOrDefault();
            if (cameraResources != null)
            {
                int newWidth = (int)cameraResources.RenderTargetSize.Width;
                int newHeight = (int)cameraResources.RenderTargetSize.Height;

                var adapter = this.Adapter as Adapter.Adapter;

                if (newWidth != adapter.Width || newHeight != adapter.Height)
                {
                    adapter.SetSize(newWidth, newHeight);
                    RenderTargetManager renderTargetManager = this.Adapter.Graphics.RenderTargetManager as RenderTargetManager;

                    DepthTexture depthTexture = renderTargetManager.CreateDepthTexture(newWidth, newHeight);

                    this.eyeTextures = new VREyeTexture[cameraResources.IsRenderingStereoscopic ? 2 : 1];

                    for (int i = 0; i < this.eyeTextures.Length; i++)
                    {
                        RenderTargetViewDescription rtViewDescription = new RenderTargetViewDescription()
                        {
                            Format = cameraResources.BackBufferTexture2D.Description.Format,
                            Dimension = RenderTargetViewDimension.Texture2DArray,
                            Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource()
                            {
                                FirstArraySlice = i,
                                ArraySize = 1,
                                MipSlice = 0
                            }
                        };

                        var renderTarget = renderTargetManager.CreateRenderTarget(cameraResources.BackBufferTexture2D, rtViewDescription);
                        renderTarget.DepthTexture = depthTexture;

                        VREyeTexture eyeTexture = new VREyeTexture()
                        {
                            Viewport = new Viewport(0, 0, 1, 1),
                            NearPlane = 0.01f,
                            FarPlane = 1000,
                            RenderTarget = renderTarget
                        };

                        this.eyeTextures[i] = eyeTexture;
                    }

                    var dxRT = renderTargetManager.TargetFromHandle<DXRenderTarget>(this.EyeTextures[0].RenderTarget.TextureHandle);
                    adapter.GraphicsDevice.BackBuffer = dxRT.TargetView;
                }
            }
        }
        protected override void BaseInitialize()
        {
            if (this.HmdDetected)
            {
                var rtManager = this.adapter.Graphics.RenderTargetManager as RenderTargetManager;

                uint recommendedWidth  = 0;
                uint recommendedHeight = 0;
                this.Hmd.GetRecommendedRenderTargetSize(ref recommendedWidth, ref recommendedHeight);

                int rtWidth  = (int)recommendedWidth * 2;
                int rtHeight = (int)recommendedHeight;

                var eyeDepthTexture = rtManager.CreateDepthTexture(rtWidth, rtHeight, this.msaaSampleCount);

                if (this.msaaSampleCount > 1)
                {
                    // Create MSAA renderTarget
                    this.msaaRenderTarget = rtManager.CreateRenderTarget(rtWidth, rtHeight, PixelFormat.R8G8B8A8, this.msaaSampleCount);
                    this.msaaRenderTarget.DepthTexture = eyeDepthTexture;
                }

                this.swapRenderTarget = rtManager.CreateRenderTarget(rtWidth, rtHeight, PixelFormat.R8G8B8A8);

                if (this.msaaSampleCount == 1)
                {
                    this.swapRenderTarget.DepthTexture = eyeDepthTexture;
                }

                var swapDXRenderTarget = rtManager.TargetFromHandle <DXRenderTarget>(this.swapRenderTarget.TextureHandle);
                this.swapTexture = new Texture_t()
                {
                    handle      = swapDXRenderTarget.NativeTexture,
                    eColorSpace = EColorSpace.Auto,
                    eType       = ETextureType.DirectX
                };

                this.leftEyeTextureBounds = new VRTextureBounds_t()
                {
                    uMin = 0,
                    uMax = 0.5f,
                    vMin = 0,
                    vMax = 1f
                };

                this.rightEyeTextureBounds = new VRTextureBounds_t()
                {
                    uMin = 0.5f,
                    uMax = 1f,
                    vMin = 0,
                    vMax = 1f
                };

                // Create a set of layers to submit.
                this.EyeTextures = new VREyeTexture[2];

                for (int eyeIndex = 0; eyeIndex < 2; eyeIndex++)
                {
                    var eyeTexture = new VREyeTexture();
                    this.EyeTextures[eyeIndex] = eyeTexture;

                    // Retrieve size and position of the texture for the current eye.
                    eyeTexture.Viewport = new Viewport(
                        recommendedWidth * eyeIndex / (float)this.swapRenderTarget.Width,
                        0,
                        recommendedWidth / (float)this.swapRenderTarget.Width,
                        recommendedHeight / (float)this.swapRenderTarget.Height);

                    eyeTexture.RenderTarget = (this.msaaSampleCount > 1) ? this.msaaRenderTarget : this.swapRenderTarget;
                }

                this.HMDMirrorRenderTarget = this.swapRenderTarget;
            }

            WaveServices.RegisterService(new OpenVRService());

            this.IsConnected = this.Hmd != null;

            base.BaseInitialize();
        }