Exemple #1
0
        public void Draw(DeviceContextHolder holder, ShaderResourceView view, RenderTargetView target, 
                TargetResourceTexture temporaryEdges, TargetResourceTexture temporaryBlending) {
            holder.PrepareQuad(_effect.LayoutPT);
            holder.DeviceContext.OutputMerger.BlendState = null;

            // edges
            holder.DeviceContext.OutputMerger.SetTargets(temporaryEdges.TargetView);
            holder.DeviceContext.ClearRenderTargetView(temporaryEdges.TargetView, new Color4(0f, 0f, 0f, 0f));

            _effect.FxScreenSizeSpec.Set(new Vector4(1f / holder.Width, 1f / holder.Height, holder.Width, holder.Height));
            _effect.FxInputMap.SetResource(view);

            _effect.TechSmaa.DrawAllPasses(holder.DeviceContext, 6);

            // blending
            holder.DeviceContext.OutputMerger.SetTargets(temporaryBlending.TargetView);
            holder.DeviceContext.ClearRenderTargetView(temporaryBlending.TargetView, new Color4(0f, 0f, 0f, 0f));

            _effect.FxEdgesMap.SetResource(temporaryEdges.View);
            _effect.FxAreaTexMap.SetResource(_areasTexMap);
            _effect.FxSearchTexMap.SetResource(_searchTexMap);

            _effect.TechSmaaB.DrawAllPasses(holder.DeviceContext, 6);

            // final part
            holder.DeviceContext.OutputMerger.SetTargets(target);
            _effect.FxBlendMap.SetResource(temporaryBlending.View);
            _effect.TechSmaaN.DrawAllPasses(holder.DeviceContext, 6);
        }
        public override void Resize(DeviceContextHolder holder, int width, int height) {
            if (width == Width && height == Height) return;
            base.Resize(holder, width, height);

            TargetView = new RenderTargetView(holder.Device, Texture);
            View = new ShaderResourceView(holder.Device, Texture);
        }
        /// <summary>
        /// Create Direct3D device and swap chain
        /// </summary>
        public void InitDevice()
        {
            device = D3DDevice.CreateDeviceAndSwapChain(host.Handle, out swapChain);

            // Create a render target view
            using (Texture2D pBuffer = swapChain.GetBuffer<Texture2D>(0))
            {
                renderTargetView = device.CreateRenderTargetView(pBuffer);
            }

            device.OM.SetRenderTargets(new RenderTargetView[] { renderTargetView }, null);

            // Setup the viewport
            Viewport vp = new Viewport()
            {
                Width = (uint)host.ActualWidth,
                Height = (uint)host.ActualHeight,
                MinDepth = 0.0f,
                MaxDepth = 1.0f,
                TopLeftX = 0,
                TopLeftY = 0
            };

            device.RS.SetViewports(new Viewport[] { vp });
        } 
        public void InitializeD3D()
        {
            var description = new SwapChainDescription()
            {
                BufferCount = 2,
                Usage = Usage.RenderTargetOutput,
                OutputHandle = form.Handle,
                IsWindowed = true,
                ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
                SampleDescription = new SampleDescription(1, 0),
                Flags = SwapChainFlags.AllowModeSwitch,
                SwapEffect = SwapEffect.Discard
            };

            //Create swap chain
            Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, description, out this.device, out swapChain);
            // create a view of our render target, which is the backbuffer of the swap chain we just created
            // setting a viewport is required if you want to actually see anything
            var resource = Resource.FromSwapChain<Texture2D>(swapChain, 0);
            renderTarget = new RenderTargetView(device, resource);
            var context = device.ImmediateContext;
            var viewport = new Viewport(0.0f, 0.0f, form.ClientSize.Width, form.ClientSize.Height);
            context.OutputMerger.SetTargets(renderTarget);
            context.Rasterizer.SetViewports(viewport);
        }
Exemple #5
0
		public void LoadResources()
		{
			if (m_Disposed == true)
			{
				Buffer = new Texture2D(GameEnvironment.Device, new Texture2DDescription()
				{
					Format = m_Format,
					Width = m_Width,
					Height = m_Height,
					OptionFlags = ResourceOptionFlags.None,
					MipLevels = 1,
					ArraySize = 1,
					BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
					CpuAccessFlags = CpuAccessFlags.None,
					SampleDescription = new SampleDescription(1, 0),
					Usage = ResourceUsage.Default
				});

				View = new RenderTargetView(GameEnvironment.Device, Buffer);
				ResourceView = new ShaderResourceView(GameEnvironment.Device, Buffer);
				Viewport = new Viewport(0, 0, Buffer.Description.Width, Buffer.Description.Height);

				m_Disposed = false;
			}
		}
        //void Update()
        //{
        //    stereoCamera.Update();
        //    SceneTree.Update();
        //    isDirty = false;
        //}
        public override void Execute()
        {
            //Game.RenderEvent.Wait();

            //if (isDirty)
            //    Update();

            //stereoCamera.Update();
            //SceneTree.Update();

            lTexture = new Texture2D(Game.Context.Device, RenderTextureDesc);
            rTexture = new Texture2D(Game.Context.Device, RenderTextureDesc);

            rTargetViewLeft = new SlimDX.Direct3D11.RenderTargetView(Game.Context.Device, lTexture);
            rTargetViewRight = new SlimDX.Direct3D11.RenderTargetView(Game.Context.Device, rTexture);

            stereoCamera.EnableLeftStereoProjection();
            RenderSceneImage(lTexture, rTargetViewLeft);
            stereoCamera.EnableRightStereoProjection();
            RenderSceneImage(rTexture, rTargetViewRight);
            Texture2D newTexture = Stereo.Make3D(lTexture, rTexture);

            FreeResources();
            Texture = newTexture;
        }
Exemple #7
0
		private void InitalizeGraphics()
		{
			if (Window.RenderCanvasHandle == IntPtr.Zero)
				throw new InvalidOperationException("Window handle cannot be zero");

			SwapChainDescription swapChainDesc = new SwapChainDescription()
			{
				BufferCount = 1,
				Flags = SwapChainFlags.None,
				IsWindowed = true,
				OutputHandle = Window.RenderCanvasHandle,
				SwapEffect = SwapEffect.Discard,
				Usage = Usage.RenderTargetOutput,
				ModeDescription = new ModeDescription()
				{
					Format = SlimDX.DXGI.Format.R8G8B8A8_UNorm,
					//Format = SlimDX.DXGI.Format.B8G8R8A8_UNorm,
					Width = Window.ClientSize.Width,
					Height = Window.ClientSize.Height,
					RefreshRate = new Rational(60, 1),
					Scaling = DisplayModeScaling.Unspecified,
					ScanlineOrdering = DisplayModeScanlineOrdering.Unspecified
				},
				SampleDescription = new SampleDescription(1, 0)
			};

			var giFactory = new SlimDX.DXGI.Factory();
			var adapter = giFactory.GetAdapter(0);

			Device device;
			SwapChain swapChain;
			Device.CreateWithSwapChain(adapter, DriverType.Hardware, DeviceCreationFlags.None, swapChainDesc, out device, out swapChain);
			_swapChain = swapChain;
			GraphicsDevice = device;

			// create a view of our render target, which is the backbuffer of the swap chain we just created
			using (var resource = SlimDX.Direct3D10.Resource.FromSwapChain<Texture2D>(swapChain, 0))
			{
				_backBuffer = new RenderTargetView(device, resource);
			}

			// setting a viewport is required if you want to actually see anything
			var viewport = new Viewport(0, 0, Window.ClientSize.Width, Window.ClientSize.Height);
			device.OutputMerger.SetTargets(_backBuffer);
			device.Rasterizer.SetViewports(viewport);

			CreateDepthStencil();
			LoadVisualizationEffect();

			// Allocate a large buffer to write the PhysX visualization vertices into
			// There's more optimized ways of doing this, but for this sample a large buffer will do
			_userPrimitivesBuffer = new SlimDX.Direct3D10.Buffer(GraphicsDevice, VertexPositionColor.SizeInBytes * 50000, ResourceUsage.Dynamic, BindFlags.VertexBuffer, CpuAccessFlags.Write, ResourceOptionFlags.None);

			var elements = new[]
			{
				new InputElement("Position", 0, Format.R32G32B32A32_Float, 0, 0),
				new InputElement("Color", 0, Format.R32G32B32A32_Float, 16, 0)
			};
			_inputLayout = new InputLayout(GraphicsDevice, _visualizationEffect.RenderScenePass0.Description.Signature, elements);
		}
Exemple #8
0
        protected D3DApp(IntPtr hInstance)
        {
            AppInst = hInstance;
            MainWindowCaption = "D3D11 Application";
            DriverType = DriverType.Hardware;
            ClientWidth = 800;
            ClientHeight = 600;
            Enable4XMsaa = false;
            Window = null;
            AppPaused = false;
            Minimized = false;
            Maximized = false;
            Resizing = false;
            Msaa4XQuality = 0;
            Device = null;
            ImmediateContext = null;
            SwapChain = null;
            DepthStencilBuffer = null;
            RenderTargetView = null;
            DepthStencilView = null;
            Viewport = new Viewport();
            Timer = new GameTimer();

            GD3DApp = this;
        }
Exemple #9
0
 protected override void OnLoad(EventArgs e)
 {
     base.OnLoad(e);
     SwapChainDescription desc=new SwapChainDescription()
     {
         BufferCount = 2,
         Flags = SwapChainFlags.AllowModeSwitch,
         IsWindowed = true,
         ModeDescription = new ModeDescription()
         {
             Format = Format.R8G8B8A8_UNorm,
             Height = Height,
             Width = Width,
             RefreshRate = new Rational(1,60),
             Scaling = DisplayModeScaling.Centered,
             ScanlineOrdering = DisplayModeScanlineOrdering.Progressive
         },
         OutputHandle = Handle,
         SampleDescription = new SampleDescription(1,0),
         SwapEffect = SwapEffect.Discard,
         Usage = Usage.RenderTargetOutput
     };
     Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None,
         new FeatureLevel[1] {FeatureLevel.Level_11_0}, desc, out device, out swapChain);
     using (Texture2D tex=Texture2D.FromSwapChain<Texture2D>(swapChain,0))
     {
         renderTarget=new RenderTargetView(device,tex);
     }
 }
        protected override void OnResourceLoad()
        {
            using (Texture2D texture = Texture2D.FromSwapChain<Texture2D>(Context10.SwapChain, 0))
            {
                renderTargetView = new RenderTargetView(Context10.Device, texture);
            }

            effect = Effect.FromFile(Context10.Device, "SimpleTriangle10.fx", "fx_4_0");
            technique = effect.GetTechniqueByIndex(0);
            pass = technique.GetPassByIndex(0);

            ShaderSignature signature = pass.Description.Signature;
            inputLayout = new InputLayout(Context10.Device, signature, new[] {
				new InputElement("POSITION", 0, SlimDX.DXGI.Format.R32G32B32A32_Float, 0, 0),
				new InputElement("COLOR", 0, SlimDX.DXGI.Format.R32G32B32A32_Float, 16, 0) 
			});

            vertexBuffer = new Buffer(
                    Context10.Device,
                    3 * 32,
                    ResourceUsage.Dynamic,
                    BindFlags.VertexBuffer,
                    CpuAccessFlags.Write,
                    ResourceOptionFlags.None
            );

            DataStream stream = vertexBuffer.Map(MapMode.WriteDiscard, MapFlags.None);
            stream.WriteRange(new[] {
				new Vector4(0.0f, 0.5f, 0.5f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
				new Vector4(0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
				new Vector4(-0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f)
			});
            vertexBuffer.Unmap();
        }
        public DX11RenderTexture3D(DX11RenderContext context, int w, int h, int d, Format format)
            : base(context)
        {
            Texture3DDescription desc = new Texture3DDescription()
            {
                BindFlags = BindFlags.UnorderedAccess | BindFlags.ShaderResource | BindFlags.RenderTarget,
                CpuAccessFlags = CpuAccessFlags.None,
                Depth = d,
                Format = format,
                Height = h,
                MipLevels = 1,
                OptionFlags = ResourceOptionFlags.None,
                Usage = ResourceUsage.Default,
                Width = w
            };

            RenderTargetViewDescription rtvd = new RenderTargetViewDescription();
            rtvd.Format = format;
            rtvd.Dimension = RenderTargetViewDimension.Texture3D;
            rtvd.MipSlice = 0;
            rtvd.FirstDepthSlice = 0;
            rtvd.DepthSliceCount = d;

            this.Resource = new Texture3D(context.Device, desc);
            this.SRV = new ShaderResourceView(context.Device, this.Resource);
            this.UAV = new UnorderedAccessView(context.Device, this.Resource);
            this.RTV = new RenderTargetView(context.Device, this.Resource, rtvd);

            this.Width = desc.Width;
            this.Height = desc.Height;
            this.Format = desc.Format;
            this.Depth = desc.Depth;
        }
        /// <summary>
        /// Constructor
        /// Creates the texture we will render to based on the supplied width and height
        /// </summary>
        /// <param name="device">The device we will create the texture with</param>
        /// <param name="texWidth"></param>
        /// <param name="texHeight"></param>
        public RenderTexture(Device device, int texWidth, int texHeight)
        {
            Texture2DDescription textureDescription = new Texture2DDescription()
                {
                    Width = texWidth,
                    Height = texHeight,
                    MipLevels = 1,
                    ArraySize = 1,
                    Format = SlimDX.DXGI.Format.R32G32B32A32_Float,
                    SampleDescription = new SlimDX.DXGI.SampleDescription(1, 0),
                    BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
                    CpuAccessFlags = CpuAccessFlags.None,
                    OptionFlags = ResourceOptionFlags.None,
                    Usage = ResourceUsage.Default,
                };
            Texture = new Texture2D(device, textureDescription);
            RenderTargetViewDescription renderTargetViewDescription = new RenderTargetViewDescription()
            {
                Format = textureDescription.Format,
                Dimension = RenderTargetViewDimension.Texture2D,
                MipSlice = 0,
            };

            renderTargetView = new RenderTargetView(device, Texture, renderTargetViewDescription);

            ShaderResourceViewDescription shaderResourceViewDescription = new ShaderResourceViewDescription()
            {
                Format = textureDescription.Format,
                Dimension = ShaderResourceViewDimension.Texture2D,
                MostDetailedMip = 0,
                MipLevels = 1
            };

            shaderResourceView = new ShaderResourceView(device, Texture, shaderResourceViewDescription);
        }
        /// <summary>
        /// Create Direct3D device and swap chain
        /// </summary>
        protected void InitDevice()
        {
            device = D3DDevice.CreateDeviceAndSwapChain(directControl.Handle, out swapChain);

            // Create a render target view
            using (Texture2D pBuffer = swapChain.GetBuffer<Texture2D>(0))
            {
                renderTargetView = device.CreateRenderTargetView(pBuffer);
            }

            device.OM.SetRenderTargets(new RenderTargetView[] { renderTargetView });

            // Setup the viewport
            Viewport vp = new Viewport()
            {
                Width = (uint)directControl.ClientSize.Width,
                Height = (uint)directControl.ClientSize.Height,
                MinDepth = 0.0f,
                MaxDepth = 1.0f,
                TopLeftX = 0,
                TopLeftY = 0
            };

            device.RS.SetViewports(new Viewport[] { vp });
        } 
Exemple #14
0
        public static void CreateDeviceSwapChainAndRenderTarget(Form form,
            out Device device, out SwapChain swapChain, out RenderTargetView renderTarget)
        {
            try
            {
                // the debug mode requires the sdk to be installed otherwise an exception is thrown
                device = new Device(DeviceCreationFlags.Debug);
            }
            catch (Direct3D10Exception)
            {
                device = new Device(DeviceCreationFlags.None);
            }

            var swapChainDescription = new SwapChainDescription();
            var modeDescription = new ModeDescription();
            var sampleDescription = new SampleDescription();

            modeDescription.Format = Format.R8G8B8A8_UNorm;
            modeDescription.RefreshRate = new Rational(60, 1);
            modeDescription.Scaling = DisplayModeScaling.Unspecified;
            modeDescription.ScanlineOrdering = DisplayModeScanlineOrdering.Unspecified;

            modeDescription.Width = WIDTH;
            modeDescription.Height = HEIGHT;

            sampleDescription.Count = 1;
            sampleDescription.Quality = 0;

            swapChainDescription.ModeDescription = modeDescription;
            swapChainDescription.SampleDescription = sampleDescription;
            swapChainDescription.BufferCount = 1;
            swapChainDescription.Flags = SwapChainFlags.None;
            swapChainDescription.IsWindowed = true;
            swapChainDescription.OutputHandle = form.Handle;
            swapChainDescription.SwapEffect = SwapEffect.Discard;
            swapChainDescription.Usage = Usage.RenderTargetOutput;

            using (var factory = new Factory())
            {
                swapChain = new SwapChain(factory, device, swapChainDescription);
            }

            using (var resource = swapChain.GetBuffer<Texture2D>(0))
            {
                renderTarget = new RenderTargetView(device, resource);
            }

            var viewport = new Viewport
            {
                X = 0,
                Y = 0,
                Width = WIDTH,
                Height = HEIGHT,
                MinZ = 0.0f,
                MaxZ = 1.0f
            };

            device.Rasterizer.SetViewports(viewport);
            device.OutputMerger.SetTargets(renderTarget);
        }
Exemple #15
0
        public void Draw(DeviceContextHolder holder, ShaderResourceView view, RenderTargetView target) {
            holder.DeviceContext.OutputMerger.SetTargets(target);
            holder.QuadBuffers.Prepare(holder.DeviceContext, _effect.LayoutPT);

            _effect.FxScreenSize.Set(new Vector4(holder.Width, holder.Height, 1f / holder.Width, 1f / holder.Height));
            _effect.FxInputMap.SetResource(view);
            _effect.TechFxaa.DrawAllPasses(holder.DeviceContext, 6);
        }
        public override void Dispose() {
            base.Dispose();

            if (TargetView != null) {
                TargetView.Dispose();
                TargetView = null;
            }
        }
 public RenderTargetTexture(Device device, 
                            int width, 
                            int height, 
                            Format format = Format.B8G8R8A8_UNorm, 
                            ResourceOptionFlags optionFlags = ResourceOptionFlags.None)
     : base(new Texture2D(device, CreateTextureDescription(width, height, format, optionFlags)))
 {
     InternalRenderTargetView = new RenderTargetView(device, InternalTexture2D);
 }
        public DX11RenderTarget2D(DX11RenderContext context, Texture2D tex)
        {
            this.context = context;
            this.Resource = tex;

            this.SRV = new ShaderResourceView(context.Device, tex);

            this.RTV = new RenderTargetView(context.Device, tex);
        }
Exemple #19
0
        public View(Viewer viewer, Viewport viewport, RenderTargetView target)
        {
            if (viewer == null)
                throw new ArgumentNullException("viewer");
            if (target == null)
                throw new ArgumentNullException("target");

            Viewer = viewer;
            Viewport = viewport;
            Target = target;
        }
Exemple #20
0
        public void Render( DeviceContext deviceContext, Viewport viewport, RenderTargetView renderTargetView, DepthStencilView depthStencilView )
        {
            deviceContext.ClearRenderTargetView( renderTargetView, Constants.CLEAR_COLOR );
            deviceContext.ClearDepthStencilView( depthStencilView, DepthStencilClearFlags.Depth | DepthStencilClearFlags.Stencil, 1.0f, 0x00 );

            //mTinyTextContext.Print( viewport, "Frame Time: " + FrameTimeString, 10, 10 );
            //mTinyTextContext.Render();

            mStopwatch.Reset();
            mStopwatch.Start();
        }
        private void CreateRenderTargetView()
        {
            var renderTargetViewDesc = new RenderTargetViewDescription();
            renderTargetViewDesc.ArraySize = layerCount;
            renderTargetViewDesc.Dimension = RenderTargetViewDimension.Texture2DArray;
            renderTargetViewDesc.FirstArraySlice = 0;
            renderTargetViewDesc.Format = format;
            renderTargetViewDesc.MipSlice = 0;

            renderTargetViewAsArray = new RenderTargetView(device, texture, renderTargetViewDesc);
        }
        void InitDevice()
        {
            // create Direct 3D device
            device = D3DDevice.CreateDeviceAndSwapChain(renderHost.Handle);
            swapChain = device.SwapChain;

            // Create a render target view
            using (Texture2D pBuffer = swapChain.GetBuffer<Texture2D>(0))
            {
                renderTargetView = device.CreateRenderTargetView(pBuffer);
            }

            // Create depth stencil texture
            Texture2DDescription descDepth = new Texture2DDescription()
            {
                Width = (uint)renderHost.ActualWidth,
                Height = (uint)renderHost.ActualHeight,
                MipLevels = 1,
                ArraySize = 1,
                Format = Format.D32Float,
                SampleDescription = new SampleDescription()
                {
                    Count = 1,
                    Quality = 0
                },
                BindingOptions = BindingOptions.DepthStencil,
            };

            depthStencil = device.CreateTexture2D(descDepth);

            // Create the depth stencil view
            DepthStencilViewDescription depthStencilViewDesc = new DepthStencilViewDescription()
            {
                Format = descDepth.Format,
                ViewDimension = DepthStencilViewDimension.Texture2D
            };
            depthStencilView = device.CreateDepthStencilView(depthStencil, depthStencilViewDesc);

            // bind the views to the device
            device.OM.RenderTargets = new OutputMergerRenderTargets(new RenderTargetView[] { renderTargetView }, depthStencilView);

            // Setup the viewport
            Viewport vp = new Viewport()
            {
                Width = (uint)renderHost.ActualWidth,
                Height = (uint)renderHost.ActualHeight,
                MinDepth = 0.0f,
                MaxDepth = 1.0f,
                TopLeftX = 0,
                TopLeftY = 0
            };
            
            device.RS.Viewports = new Viewport[] { vp };
        }
 public void Apply()
 {
     if (stack.Count > 0)
     {
         stack.Peek().Apply(context.CurrentDeviceContext);
     }
     else
     {
         RenderTargetView[] zero = new RenderTargetView[] { null,null,null,null,null,null,null,null };
         context.CurrentDeviceContext.OutputMerger.SetTargets(null, zero);
     }
 }
 private void CreateRenderTargetViews()
 {
     var renderTargetViewDesc = new RenderTargetViewDescription();
     renderTargetViewDesc.Format = texture.Description.Format;
     renderTargetViewDesc.Dimension = RenderTargetViewDimension.Texture2DArray;
     renderTargetViewDesc.ArraySize = 1;
     renderTargetViewDesc.MipSlice = 0;
     for (int i = 0; i < deferredShadingConfiguration.LayerCount; ++i)
     {
         renderTargetViewDesc.FirstArraySlice = i;
         var renderTargetView = new RenderTargetView(device, texture, renderTargetViewDesc);
         renderTargetViews.Add(renderTargetView);
     }
 }
        // Functions
        public TextureObject()
        {
            m_Width = m_Height = 1;
            m_Mips = 1;
            m_Depth = 1;
            m_ArraySize = 1;
            m_IsCube = false;
            m_TexFormat = Format.Unknown;
            m_TextureObject2D = null;
            m_TextureObject3D = null;
            m_RenderTargetView = null;
            m_ShaderResourceView = null;
            m_DepthStencilView = null;
            m_UnorderedAccessView = null;

            m_ArrayRenderTargetViews = null;
            m_ArrayShaderResourceViews = null;
            m_ArrayDepthStencilViews = null;
            m_ArrayUnorderedAccessViews = null;
        }
        public RenderToTextureCommand(int width, int height, SceneManager sceneTree)
            : base(CommandType.Action)
        {
            SceneTree = sceneTree;
            RenderTextureDesc = new Texture2DDescription
            {
                ArraySize = 1,
                BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
                CpuAccessFlags = CpuAccessFlags.None,
                Format = Format.R8G8B8A8_UNorm,
                Width = width,
                Height = height,
                MipLevels = 1,
                OptionFlags = ResourceOptionFlags.None,
                SampleDescription = new SampleDescription(1, 0),
                Usage = ResourceUsage.Default
            };

            texture = new Texture2D(Game.Context.Device, RenderTextureDesc);

            Texture2DDescription depthBufferDesc = new Texture2DDescription
            {
                ArraySize = 1,
                BindFlags = BindFlags.DepthStencil,
                CpuAccessFlags = CpuAccessFlags.None,
                Format = Format.D32_Float,
                Width = width,
                Height = height,
                MipLevels = 1,
                OptionFlags = ResourceOptionFlags.None,
                SampleDescription = new SampleDescription(1, 0),
                Usage = ResourceUsage.Default
            };

            using (Texture2D depthBuffer = new Texture2D(Game.Context.Device, depthBufferDesc))
            {
                DepthStencilView = new DepthStencilView(Game.Context.Device, depthBuffer);
            }

            RenderTargetView = new RenderTargetView(Game.Context.Device, texture);
        }
Exemple #27
0
        public void Initialize()
        {
            var description = new SwapChainDescription
                                  {
                                      BufferCount = 1,
                                      Usage = Usage.RenderTargetOutput,
                                      OutputHandle = _form.Handle,
                                      IsWindowed = true,
                                      ModeDescription = new ModeDescription
                                                            {
                                                                Width = 0,
                                                                Height = 0,
                                                                Format = Format.R8G8B8A8_UNorm,
                                                                RefreshRate = new Rational(60, 1),
                                                                Scaling = DisplayModeScaling.Unspecified,
                                                                ScanlineOrdering = DisplayModeScanlineOrdering.Unspecified
                                                            },
                                      SampleDescription = new SampleDescription
                                                              {
                                                                  Count = 1,
                                                                  Quality = 0
                                                              },
                                      Flags = SwapChainFlags.AllowModeSwitch,
                                      SwapEffect = SwapEffect.Discard
                                  };

            // Create device
            SlimDX.Direct3D10_1.Device1.CreateWithSwapChain(null, DriverType.Hardware, DeviceCreationFlags.None,
                                                            description, out _device, out _swapChain);

            using (var resource = Resource.FromSwapChain<Texture2D>(_swapChain, 0))
            {
                _renderTargetView = new RenderTargetView(_device, resource);
            }

            _viewport = new Viewport(0, 0, _form.ClientSize.Width, _form.ClientSize.Height, 0.0f, 1.0f);
            _device.Rasterizer.SetViewports(_viewport);
            _device.OutputMerger.SetTargets(_renderTargetView);
        }
Exemple #28
0
        private void MainForm_Load(object sender, System.EventArgs e)
        {
            // Creating device (we accept dx10 cards or greater)
            FeatureLevel[] levels = {
                                        FeatureLevel.Level_11_0,
                                        FeatureLevel.Level_10_1,
                                        FeatureLevel.Level_10_0
                                    };

            // Defining our swap chain
            SwapChainDescription desc = new SwapChainDescription();
            desc.BufferCount = 1;
            desc.Usage = Usage.BackBuffer | Usage.RenderTargetOutput;
            desc.ModeDescription = new ModeDescription(0, 0, new Rational(0, 0), Format.R8G8B8A8_UNorm);
            desc.SampleDescription = new SampleDescription(1, 0);
            desc.OutputHandle = Handle;
            desc.IsWindowed = true;
            desc.SwapEffect = SwapEffect.Discard;

            Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, levels, desc, out device11, out swapChain);

            // Getting back buffer
            backBuffer = Resource.FromSwapChain<Texture2D>(swapChain, 0);

            // Defining render view
            renderTargetView = new RenderTargetView(device11, backBuffer);
            device11.ImmediateContext.OutputMerger.SetTargets(renderTargetView);
            device11.ImmediateContext.Rasterizer.SetViewports(new Viewport(0, 0, ClientSize.Width, ClientSize.Height, 0.0f, 1.0f));

            // Preparing shaders
            PrepareShaders();

            // Creating geometry
            CreateGeometry();

            // Setting constants
            AffectConstants();
        }
        public override void Resize(DeviceContextHolder holder, int width, int height) {
            base.Resize(holder, width, height);

            StencilView = new DepthStencilView(holder.Device, Texture, new DepthStencilViewDescription {
                Flags = DepthStencilViewFlags.None,
                Format = Format.D24_UNorm_S8_UInt,
                Dimension = DepthStencilViewDimension.Texture2D,
                MipSlice = 0
            });

            TargetView = new RenderTargetView(holder.Device, Texture, new RenderTargetViewDescription {
                MipSlice = 0,
                Dimension = RenderTargetViewDimension.Texture2D,
                Format = Format.D24_UNorm_S8_UInt
            });

            View = new ShaderResourceView(holder.Device, Texture, new ShaderResourceViewDescription {
                Format = Format.R24_UNorm_X8_Typeless,
                Dimension = ShaderResourceViewDimension.Texture2D,
                MipLevels = 1,
                MostDetailedMip = 0
            });
        }
Exemple #30
0
        public void Shutdown()
        {
            // Before shutting down set to windowed mode or when you release the swap chain it will throw an exception.
            if (SwapChain != null)
            {
                SwapChain.SetFullscreenState(false, null);
            }

            if (AlphaEnableBlendingState != null)
            {
                AlphaEnableBlendingState.Dispose();
                AlphaEnableBlendingState = null;
            }

            if (AlphaDisableBlendingState != null)
            {
                AlphaDisableBlendingState.Dispose();
                AlphaDisableBlendingState = null;
            }

            if (DepthDisabledStencilState != null)
            {
                DepthDisabledStencilState.Dispose();
                DepthDisabledStencilState = null;
            }

            if (RasterState != null)
            {
                RasterState.Dispose();
                RasterState = null;
            }

            if (DepthStencilView != null)
            {
                DepthStencilView.Dispose();
                DepthStencilView = null;
            }

            if (DepthStencilState != null)
            {
                DepthStencilState.Dispose();
                DepthStencilState = null;
            }

            if (DepthStencilBuffer != null)
            {
                DepthStencilBuffer.Dispose();
                DepthStencilBuffer = null;
            }

            if (RenderTargetView != null)
            {
                RenderTargetView.Dispose();
                RenderTargetView = null;
            }

            if (Device != null)
            {
                Device.Dispose();
                Device = null;
            }

            if (SwapChain != null)
            {
                SwapChain.Dispose();
                SwapChain = null;
            }
        }
Exemple #31
0
 public void Draw(DeviceContextHolder holder, ShaderResourceView view, RenderTargetView target)
 {
     Draw(holder, view, target, false);
 }
Exemple #32
0
        private void Initialize()
        {
            factory2d = new Factory2D(SharpDX.Direct2D1.FactoryType.MultiThreaded, DebugLevel.Information);

            HookControl         = Control.FromHandle(HookHandle);
            HookControl.Resize += HookResized;

            var desc = new SwapChainDescription()
            {
                BufferCount       = 1,
                ModeDescription   = new ModeDescription(0, 0, new Rational(0, 0), Format.B8G8R8A8_UNorm),   // BGRA | Required for Direct2D/DirectWrite (<Win8)
                IsWindowed        = true,
                OutputHandle      = HookHandle,
                SampleDescription = new SampleDescription(1, 0),
                SwapEffect        = SwapEffect.Discard,
                Usage             = Usage.RenderTargetOutput
            };

            /* [Enable Debug Layer]
             *
             * https://docs.microsoft.com/en-us/windows/win32/direct3d11/using-the-debug-layer-to-test-apps
             * To use this flag, you must have D3D11*SDKLayers.dll installed; otherwise, device creation fails. To get D3D11_1SDKLayers.dll, install the SDK for Windows 8.
             */

            // Enable on-demand to avoid "Failed to create device issue"
            //#if DEBUG
            //    Device.CreateWithSwapChain(SharpDX.Direct3D.DriverType.Hardware, DeviceCreationFlags.Debug | DeviceCreationFlags.BgraSupport, desc, out device, out swapChain);
            //#else
            Device.CreateWithSwapChain(SharpDX.Direct3D.DriverType.Hardware, DeviceCreationFlags.BgraSupport, desc, out device, out swapChain);
            //#endif

            var factory = swapChain.GetParent <FactoryDX>();

            factory.MakeWindowAssociation(HookHandle, WindowAssociationFlags.IgnoreAll);

            backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
            rtv        = new RenderTargetView(device, backBuffer);
            context    = device.ImmediateContext;

            factoryWrite = new FactoryDW();
            surface      = backBuffer.QueryInterface <Surface>();
            rtv2d        = new RenderTarget(factory2d, surface, new RenderTargetProperties(new SharpDX.Direct2D1.PixelFormat(Format.Unknown, SharpDX.Direct2D1.AlphaMode.Premultiplied)));
            brush2d      = new SolidColorBrush(rtv2d, Color.White);

            var VertexShaderByteCode = ShaderBytecode.Compile(Properties.Resources.VertexShader, "main", "vs_5_0", ShaderFlags.Debug);

            vertexLayout = new InputLayout(device, VertexShaderByteCode, new[]
            {
                new InputElement("POSITION", 0, Format.R32G32B32_Float, 0, 0, InputClassification.PerVertexData, 0),
                new InputElement("TEXCOORD", 0, Format.R32G32_Float, 12, 0, InputClassification.PerVertexData, 0),
            });
            vertexShader = new VertexShader(device, VertexShaderByteCode);

            var PixelShaderByteCode = ShaderBytecode.Compile(Properties.Resources.PixelShader, "main", "ps_5_0", ShaderFlags.Debug);

            pixelShader = new PixelShader(device, PixelShaderByteCode);

            var PixelShaderByteCodeYUV = ShaderBytecode.Compile(Properties.Resources.PixelShader_YUV, "main", "ps_5_0", ShaderFlags.Debug);

            pixelShaderYUV = new PixelShader(device, PixelShaderByteCodeYUV);

            vertexBuffer = Buffer.Create(device, BindFlags.VertexBuffer, new[]
            {
                -1.0f, -1.0f, 0, 0.0f, 1.0f,
                -1.0f, 1.0f, 0, 0.0f, 0.0f,
                1.0f, -1.0f, 0, 1.0f, 1.0f,

                1.0f, -1.0f, 0, 1.0f, 1.0f,
                -1.0f, 1.0f, 0, 0.0f, 0.0f,
                1.0f, 1.0f, 0, 1.0f, 0.0f
            });

            SamplerState textureSampler = new SamplerState(device, new SamplerStateDescription()
            {
                AddressU           = TextureAddressMode.Clamp,
                AddressV           = TextureAddressMode.Clamp,
                AddressW           = TextureAddressMode.Clamp,
                ComparisonFunction = Comparison.Never,
                Filter             = Filter.MinMagMipLinear,
                MaximumAnisotropy  = 1,
                MaximumLod         = float.MaxValue,
                MinimumLod         = 0,
                MipLodBias         = 0.0f
            });

            context.InputAssembler.InputLayout       = vertexLayout;
            context.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
            context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, Utilities.SizeOf <float>() * 5, 0));

            context.VertexShader.Set(vertexShader);
            context.PixelShader.SetSampler(0, textureSampler);

            textureRGB = new Texture2D(device, new Texture2DDescription()
            {
                Usage  = ResourceUsage.Default,
                Format = Format.R8G8B8A8_UNorm,

                Width  = HookControl.Width,
                Height = HookControl.Height,

                BindFlags      = BindFlags.ShaderResource | BindFlags.RenderTarget,
                CpuAccessFlags = CpuAccessFlags.None,
                OptionFlags    = ResourceOptionFlags.None,

                SampleDescription = new SampleDescription(1, 0),
                ArraySize         = 1,
                MipLevels         = 1
            });

            srvDescYUV           = new ShaderResourceViewDescription();
            srvDescYUV.Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D;
            srvDescYUV.Format    = Format.R8_UNorm;
            srvDescYUV.Texture2D.MostDetailedMip = 0;
            srvDescYUV.Texture2D.MipLevels       = 1;

            videoDevice1  = device.QueryInterface <VideoDevice1>();
            videoContext1 = device.ImmediateContext.QueryInterface <VideoContext1>();

            vpcd = new VideoProcessorContentDescription()
            {
                Usage            = VideoUsage.PlaybackNormal,
                InputFrameFormat = VideoFrameFormat.Progressive,
                InputFrameRate   = new Rational(1, 1),
                OutputFrameRate  = new Rational(1, 1),
                InputWidth       = 1,
                OutputWidth      = 1,
                InputHeight      = 1,
                OutputHeight     = 1
            };
            videoDevice1.CreateVideoProcessorEnumerator(ref vpcd, out vpe);
            videoDevice1.CreateVideoProcessor(vpe, 0, out videoProcessor);

            vpivd = new VideoProcessorInputViewDescription()
            {
                FourCC    = 0,
                Dimension = VpivDimension.Texture2D,
                Texture2D = new Texture2DVpiv()
                {
                    MipSlice = 0, ArraySlice = 0
                }
            };
            vpovd = new VideoProcessorOutputViewDescription()
            {
                Dimension = VpovDimension.Texture2D
            };
            vpsa = new VideoProcessorStream[1];

            SetViewport();

            //foreach (var osdsurf in osd)
            //osdsurf.Value.Init();
        }
        public DepthAndColorShader(Device device)
        {
            shaderByteCode  = new ShaderBytecode(File.ReadAllBytes("Content/DepthAndColorFloatVS.cso"));
            depthAndColorVS = new VertexShader(device, shaderByteCode);
            depthAndColorGS = new GeometryShader(device, new ShaderBytecode(File.ReadAllBytes("Content/DepthAndColorGS.cso")));
            depthAndColorPS = new PixelShader(device, new ShaderBytecode(File.ReadAllBytes("Content/DepthAndColorPS.cso")));

            // depth stencil state
            var depthStencilStateDesc = new DepthStencilStateDescription()
            {
                IsDepthEnabled   = true,
                DepthWriteMask   = DepthWriteMask.All,
                DepthComparison  = Comparison.LessEqual,
                IsStencilEnabled = false,
            };

            depthStencilState = new DepthStencilState(device, depthStencilStateDesc);

            // rasterizer state
            var rasterizerStateDesc = new RasterizerStateDescription()
            {
                CullMode                = CullMode.None,
                FillMode                = FillMode.Solid,
                IsDepthClipEnabled      = true,
                IsFrontCounterClockwise = true,
                IsMultisampleEnabled    = true,
            };

            rasterizerState = new RasterizerState(device, rasterizerStateDesc);

            // color sampler state
            var colorSamplerStateDesc = new SamplerStateDescription()
            {
                Filter   = Filter.MinMagMipLinear,
                AddressU = TextureAddressMode.Border,
                AddressV = TextureAddressMode.Border,
                AddressW = TextureAddressMode.Border,
                //BorderColor = new SharpDX.Color4(0.5f, 0.5f, 0.5f, 1.0f),
                BorderColor = new SharpDX.Color4(0, 0, 0, 1.0f),
            };

            colorSamplerState = new SamplerState(device, colorSamplerStateDesc);

            //// Kinect depth image
            //var depthImageTextureDesc = new Texture2DDescription()
            //{
            //    Width = depthImageWidth,
            //    Height = depthImageHeight,
            //    MipLevels = 1,
            //    ArraySize = 1,
            //    Format = SharpDX.DXGI.Format.R16_UInt, // R32_Float
            //    SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
            //    Usage = ResourceUsage.Dynamic,
            //    BindFlags = BindFlags.ShaderResource,
            //    CpuAccessFlags = CpuAccessFlags.Write,
            //};
            //depthImageTexture = new Texture2D(device, depthImageTextureDesc);
            //depthImageTextureRV = new ShaderResourceView(device, depthImageTexture);

            // filtered depth image
            var filteredDepthImageTextureDesc = new Texture2DDescription()
            {
                Width             = depthImageWidth * 3,
                Height            = depthImageHeight * 3,
                MipLevels         = 1,
                ArraySize         = 1,
                Format            = SharpDX.DXGI.Format.R32G32_Float,
                SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
                Usage             = ResourceUsage.Default,
                BindFlags         = BindFlags.RenderTarget | BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
            };

            filteredDepthImageTexture = new Texture2D(device, filteredDepthImageTextureDesc);
            filteredRenderTargetView  = new RenderTargetView(device, filteredDepthImageTexture);
            filteredDepthImageSRV     = new ShaderResourceView(device, filteredDepthImageTexture);

            filteredDepthImageTexture2 = new Texture2D(device, filteredDepthImageTextureDesc);
            filteredRenderTargetView2  = new RenderTargetView(device, filteredDepthImageTexture2);
            filteredDepthImageSRV2     = new ShaderResourceView(device, filteredDepthImageTexture2);



            //// Kinect color image
            //var colorImageStagingTextureDesc = new Texture2DDescription()
            //{
            //    Width = colorImageWidth,
            //    Height = colorImageHeight,
            //    MipLevels = 1,
            //    ArraySize = 1,
            //    Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
            //    //Format = SharpDX.DXGI.Format.YUY2
            //    SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
            //    Usage = ResourceUsage.Dynamic,
            //    BindFlags = BindFlags.ShaderResource,
            //    CpuAccessFlags = CpuAccessFlags.Write
            //};
            //colorImageStagingTexture = new Texture2D(device, colorImageStagingTextureDesc);

            //var colorImageTextureDesc = new Texture2DDescription()
            //{
            //    Width = colorImageWidth,
            //    Height = colorImageHeight,
            //    MipLevels = 0,
            //    ArraySize = 1,
            //    Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
            //    SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
            //    Usage = ResourceUsage.Default,
            //    BindFlags = BindFlags.ShaderResource | BindFlags.RenderTarget,
            //    CpuAccessFlags = CpuAccessFlags.None,
            //    OptionFlags = ResourceOptionFlags.GenerateMipMaps
            //};
            //colorImageTexture = new Texture2D(device, colorImageTextureDesc);
            //colorImageTextureRV = new ShaderResourceView(device, colorImageTexture);

            // constant buffer
            var constantBufferDesc = new BufferDescription()
            {
                Usage               = ResourceUsage.Dynamic,
                BindFlags           = BindFlags.ConstantBuffer,
                SizeInBytes         = ConstantBuffer.size,
                CpuAccessFlags      = CpuAccessFlags.Write,
                StructureByteStride = 0,
                OptionFlags         = 0,
            };

            constantBuffer = new SharpDX.Direct3D11.Buffer(device, constantBufferDesc);

            bilateralFilter = new BilateralFilter(device, depthImageWidth, depthImageHeight);

            vertexInputLayout = new InputLayout(device, shaderByteCode.Data, new[]
            {
                new InputElement("SV_POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
            });
        }
Exemple #34
0
 public void SetRenderTarget(RenderTargetView rtv)
 {
     deviceContext.OutputMerger.SetRenderTargets(null, rtv);
 }
        private void CreateCharTable(byte bytePrefix)
        {
            var TableDesc = new CharTableDescription();

            //Get appropriate texture size
            int sizeX = (int)(Font.FontSize * 12);

            sizeX = (int)Math.Pow(2, Math.Ceiling(Math.Log(sizeX, 2)));
            //Try how many lines are needed:
            var tl = new TextLayout[256];
            int line = 0, xPos = 0, yPos = 0;

            for (int i = 0; i < 256; ++i)
            {
                tl[i] = new TextLayout(ModelEx.FontManager.Instance.WriteFactory, Convert.ToChar(i + (bytePrefix << 8)).ToString(), Font);
                int charWidth  = 2 + (int)Math.Ceiling(tl[i].Metrics.LayoutWidth + tl[i].OverhangMetrics.Left + tl[i].OverhangMetrics.Right);
                int charHeight = 2 + (int)Math.Ceiling(tl[i].Metrics.LayoutHeight + tl[i].OverhangMetrics.Top + tl[i].OverhangMetrics.Bottom);
                line = Math.Max(line, charHeight);
                if (xPos + charWidth >= sizeX)
                {
                    xPos  = 0;
                    yPos += line;
                    line  = 0;
                }
                xPos += charWidth;
            }
            int sizeY = (int)(line + yPos);

            sizeY = (int)Math.Pow(2, Math.Ceiling(Math.Log(sizeY, 2)));

            //Create Texture
            var TexDesc = new Texture2DDescription()
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.ShaderResource | BindFlags.RenderTarget,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.R8G8B8A8_UNorm,
                Height            = sizeY,
                Width             = sizeX,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.Shared,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default
            };
            var texture = new Texture2D(ModelEx.FontManager.Instance.D3DDevice10, TexDesc);

            var rtv = new RenderTargetView(ModelEx.FontManager.Instance.D3DDevice10, texture);

            ModelEx.FontManager.Instance.D3DDevice10.ClearRenderTargetView(rtv, new SlimDX.Color4(0, 1, 1, 1));
            //D3DDevice10.ClearRenderTargetView(rtv, new SlimDX.Color4(1, 0, 0, 0));
            Surface surface = texture.AsSurface();
            var     target  = RenderTarget.FromDXGI(ModelEx.FontManager.Instance.D2DFactory, surface, rtp);
            var     color   = new SolidColorBrush(target, new SlimDX.Color4(1, 1, 1, 1));

            target.BeginDraw();
            line = 0; xPos = 0; yPos = 0;
            //for (int i = 0; i < 256; ++i)
            for (int i = 0; i < 256; ++i)
            {
                //1 additional pixel on each side
                int charWidth  = 2 + (int)Math.Ceiling(tl[i].Metrics.LayoutWidth + tl[i].OverhangMetrics.Left + tl[i].OverhangMetrics.Right);
                int charHeight = 2 + (int)Math.Ceiling(tl[i].Metrics.LayoutHeight + tl[i].OverhangMetrics.Top + tl[i].OverhangMetrics.Bottom);
                line = Math.Max(line, charHeight);
                if (xPos + charWidth >= sizeX)
                {
                    xPos  = 0;
                    yPos += line;
                    line  = 0;
                }
                var charDesc = new CharDescription();

                charDesc.CharSize     = new Vector2(tl[i].Metrics.WidthIncludingTrailingWhitespace, tl[i].Metrics.Height);
                charDesc.OverhangLeft = tl[i].OverhangMetrics.Left + 1;
                charDesc.OverhangTop  = tl[i].OverhangMetrics.Top + 1;
                //Make XPos + CD.Overhang.Left an integer number in order to draw at integer positions
                charDesc.OverhangLeft += (float)Math.Ceiling(xPos + charDesc.OverhangLeft) - (xPos + charDesc.OverhangLeft);
                //Make YPos + CD.Overhang.Top an integer number in order to draw at integer positions
                charDesc.OverhangTop += (float)Math.Ceiling(yPos + charDesc.OverhangTop) - (yPos + charDesc.OverhangTop);

                charDesc.OverhangRight  = charWidth - charDesc.CharSize.X - charDesc.OverhangLeft;
                charDesc.OverhangBottom = charHeight - charDesc.CharSize.Y - charDesc.OverhangTop;

                charDesc.TexCoordsStart = new Vector2(((float)xPos / sizeX), ((float)yPos / sizeY));
                charDesc.TexCoordsSize  = new Vector2((float)charWidth / sizeX, (float)charHeight / sizeY);

                charDesc.TableDescription = TableDesc;

                TableDesc.Chars[i] = charDesc;

                target.DrawTextLayout(new PointF(xPos + charDesc.OverhangLeft, yPos + charDesc.OverhangTop), tl[i], color);
                xPos += charWidth;
                tl[i].Dispose();
            }
            target.EndDraw();

            color.Dispose();

            //This is a workaround for Windows 8.1 machines.
            //If these lines would not be present, the shared resource would be empty.
            //TODO: find a nicer solution
            using (var ms = new MemoryStream())
                Texture2D.ToStream(texture, ImageFileFormat.Bmp, ms);

            System.Threading.Monitor.Enter(D3DDevice11);
            var dxgiResource = new SlimDX.DXGI.Resource(texture);

            SlimDX.Direct3D11.Texture2D Texture11;
            if (PixCompatible)
            {
                Texture11 = new SlimDX.Direct3D11.Texture2D(D3DDevice11, new SlimDX.Direct3D11.Texture2DDescription()
                {
                    ArraySize         = 1,
                    BindFlags         = SlimDX.Direct3D11.BindFlags.ShaderResource | SlimDX.Direct3D11.BindFlags.RenderTarget,
                    CpuAccessFlags    = SlimDX.Direct3D11.CpuAccessFlags.None,
                    Format            = Format.R8G8B8A8_UNorm,
                    Height            = sizeY,
                    Width             = sizeX,
                    MipLevels         = 1,
                    OptionFlags       = SlimDX.Direct3D11.ResourceOptionFlags.Shared,
                    SampleDescription = new SampleDescription(1, 0),
                    Usage             = SlimDX.Direct3D11.ResourceUsage.Default
                });
            }
            else
            {
                Texture11 = D3DDevice11.OpenSharedResource <SlimDX.Direct3D11.Texture2D>(dxgiResource.SharedHandle);
            }
            var srv = new SlimDX.Direct3D11.ShaderResourceView(D3DDevice11, Texture11);

            TableDesc.Texture = Texture11;
            TableDesc.SRV     = srv;
            rtv.Dispose();
            System.Threading.Monitor.Exit(D3DDevice11);

            System.Diagnostics.Debug.WriteLine("Created Char Table " + bytePrefix + " in " + sizeX + " x " + sizeY);

            //System.Threading.Monitor.Enter(D3DDevice11);
            //SlimDX.Direct3D11.Texture2D.SaveTextureToFile(Sprite.Device.ImmediateContext, Texture11, SlimDX.Direct3D11.ImageFileFormat.Png, Font.FontFamilyName + "Table" + BytePrefix + ".png");
            //System.Threading.Monitor.Exit(D3DDevice11);

            CharTables.Add(bytePrefix, TableDesc);

            dxgiResource.Dispose();
            target.Dispose();
            surface.Dispose();
            texture.Dispose();
        }
Exemple #36
0
        private void SetupBuffers()
        {
            // Dispose all previous allocated resources
            Utilities.Dispose(ref backBuffer);
            Utilities.Dispose(ref renderView);
            Utilities.Dispose(ref depthBuffer);
            Utilities.Dispose(ref depthView);
            Utilities.Dispose(ref resolutionBuffer);

            // Resize the backbuffer
            swapChain.ResizeBuffers(swapChainDescription.BufferCount, (int)RenderContext.ViewportSize.X, (int)RenderContext.ViewportSize.Y, Format.Unknown, SwapChainFlags.None);

            // Get the backbuffer from the swapchain
            backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);

            // Renderview on the backbuffer
            renderView = new RenderTargetView(device, backBuffer);

            // Create the depth buffer
            depthBuffer = new Texture2D(device, new Texture2DDescription()
            {
                Format            = Format.D32_Float_S8X24_UInt,
                ArraySize         = 1,
                MipLevels         = 1,
                Width             = (int)RenderContext.ViewportSize.X,
                Height            = (int)RenderContext.ViewportSize.Y,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default,
                BindFlags         = BindFlags.DepthStencil,
                CpuAccessFlags    = CpuAccessFlags.None,
                OptionFlags       = ResourceOptionFlags.None
            });

            // Create the depth buffer view
            depthView = new DepthStencilView(device, depthBuffer);

            // Setup targets and viewport for rendering
            context.Rasterizer.State = new RasterizerState(device, new RasterizerStateDescription()
            {
                CullMode                 = CullMode.None,
                DepthBias                = 0,
                DepthBiasClamp           = 0,
                FillMode                 = FillMode.Solid,
                IsAntialiasedLineEnabled = false,
                IsDepthClipEnabled       = true,
                IsFrontCounterClockwise  = false,
                IsMultisampleEnabled     = true,
                IsScissorEnabled         = false,
                SlopeScaledDepthBias     = 0
            });
            context.Rasterizer.SetViewport(new Viewport(0, 0, (int)RenderContext.ViewportSize.X, (int)RenderContext.ViewportSize.Y, 0.0f, 1.0f));
            context.OutputMerger.SetTargets(depthView, renderView);

            context.OutputMerger.SetDepthStencilState(new DepthStencilState(device, new DepthStencilStateDescription()
            {
                IsDepthEnabled = false,
            }), 0);

            Vector4 iResolution = new Vector4(RenderContext.ViewportSize, 0, 0);

            resolutionBuffer           = Buffer.Create(device, BindFlags.ConstantBuffer, ref iResolution);
            resolutionBuffer.DebugName = "ResolutionBuffer";
        }
Exemple #37
0
 public void ClearRenderTargetView(RenderTargetView renderTargetViewRef, Color4 colorRGBA)
 {
     deviceContext.ClearRenderTargetView(renderTargetViewRef, colorRGBA);
 }
Exemple #38
0
        void DxResize()
        {
            if (_renderTarget != null)
            {
                _renderTarget.Dispose();
                _renderTargetTexture.Dispose();
                _depthState.Dispose();
                _depthStencilView.Dispose();
                _depthStencilTexture.Dispose();
            }

            _renderTargetTexture = new Texture2D(CurrentDevice, new Texture2DDescription {
                Width             = _width,
                Height            = _height,
                MipLevels         = 1,
                ArraySize         = 1,
                Format            = Format.R8G8B8A8_UNorm,
                SampleDescription = _sampleDesc,
                Usage             = ResourceUsage.Default,
                BindFlags         = BindFlags.ShaderResource | BindFlags.RenderTarget,
                CpuAccessFlags    = CpuAccessFlags.None,
                OptionFlags       = ResourceOptionFlags.None
            });
            _renderTarget         = new RenderTargetView(CurrentDevice, _renderTargetTexture);
            _renderTargetResource = new ShaderResourceView(CurrentDevice, _renderTargetTexture);

            _depthStencilTexture = new Texture2D(CurrentDevice, new Texture2DDescription {
                Width             = _width,
                Height            = _height,
                MipLevels         = 1,
                ArraySize         = 1,
                Format            = Format.R24G8_Typeless,
                SampleDescription = _sampleDesc,
                Usage             = ResourceUsage.Default,
                BindFlags         = BindFlags.ShaderResource | BindFlags.DepthStencil,
                CpuAccessFlags    = CpuAccessFlags.None,
                OptionFlags       = ResourceOptionFlags.None
            })
            {
                DebugName = "DepthStencilBuffer"
            };
            _depthStencilView = new DepthStencilView(CurrentDevice, _depthStencilTexture, new DepthStencilViewDescription {
                Flags     = DepthStencilViewFlags.None,
                Format    = Format.D24_UNorm_S8_UInt,
                Dimension = DepthStencilViewDimension.Texture2DMultisampled,
                MipSlice  = 0
            });

            _depthState = DepthStencilState.FromDescription(CurrentDevice, new DepthStencilStateDescription()
            {
                IsDepthEnabled   = true,
                IsStencilEnabled = false,
                DepthWriteMask   = DepthWriteMask.All,
                DepthComparison  = Comparison.Less,
            });

            _viewport = new Viewport(0, 0, _width, _height, 0.0f, 1.0f);
            _context.Rasterizer.SetViewports(_viewport);

            _camera.SetLens(AspectRatio);
        }
        /// <summary>
        /// Creates the texture and necessary structures for 256 chars whose unicode number starts with the given byte.
        /// The table containing ASCII has a prefix of 0 (0x00/00 - 0x00/FF).
        /// </summary>
        /// <param name="BytePrefix">The byte prefix of characters.</param>
        private void CreateCharTable(byte BytePrefix)
        {
            var TableDesc = new CharTableDescription();

            //Get appropriate texture size
            int SizeX = (int)(Font.FontSize * 12);

            SizeX = (int)Math.Pow(2, Math.Ceiling(Math.Log(SizeX, 2)));
            //Try how many lines are needed:
            var   TL = new TextLayout[256];
            float Line = 0, XPos = 0, YPos = 0;

            for (int i = 0; i < 256; ++i)
            {
                TL[i] = new TextLayout(WriteFactory, Convert.ToChar(i + (BytePrefix << 8)).ToString(), Font);
                float CharWidth  = 2 + (float)Math.Ceiling(TL[i].Metrics.LayoutWidth + Math.Max(0, TL[i].OverhangMetrics.Left) + Math.Max(0, TL[i].OverhangMetrics.Right));
                float CharHeight = 2 + (float)Math.Ceiling(TL[i].Metrics.LayoutHeight + Math.Max(0, TL[i].OverhangMetrics.Top) + Math.Max(0, TL[i].OverhangMetrics.Bottom));
                Line = Math.Max(Line, CharHeight);
                if (XPos + CharWidth >= SizeX)
                {
                    XPos  = 0;
                    YPos += Line;
                    Line  = 0;
                }
                XPos += CharWidth;
            }
            int SizeY = (int)(Line + YPos);

            SizeY = (int)Math.Pow(2, Math.Ceiling(Math.Log(SizeY, 2)));

            //Create Texture
            var TexDesc = new Texture2DDescription()
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.ShaderResource | BindFlags.RenderTarget,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.B8G8R8A8_UNorm,
                Height            = SizeY,
                Width             = SizeX,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.KeyedMutex,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default
            };
            var Texture = new Texture2D(D3DDevice10, TexDesc);
            var rtv     = new RenderTargetView(D3DDevice10, Texture);

            D3DDevice10.ClearRenderTargetView(rtv, new global::SlimDX.Color4(0, 1, 1, 1));
            //D3DDevice10.ClearRenderTargetView(rtv, new SlimDX.Color4(1, 0, 0, 0));
            Surface  Surface = Texture.AsSurface();
            Surface1 s1;

            var Target = RenderTarget.FromDXGI(D2DFactory, Surface, rtp);
            var Color  = new SolidColorBrush(Target, new global::SlimDX.Color4(1, 1, 1, 1));

            Target.BeginDraw();
            Line = 0; XPos = 0; YPos = 0;
            for (int i = 0; i < 256; ++i)
            {
                float CharWidth  = 2 + (float)Math.Ceiling(TL[i].Metrics.LayoutWidth + Math.Max(0, TL[i].OverhangMetrics.Left) + Math.Max(0, TL[i].OverhangMetrics.Right));
                float CharHeight = 2 + (float)Math.Ceiling(TL[i].Metrics.LayoutHeight + Math.Max(0, TL[i].OverhangMetrics.Top) + Math.Max(0, TL[i].OverhangMetrics.Bottom));
                Line = Math.Max(Line, CharHeight);
                if (XPos + CharWidth >= SizeX)
                {
                    XPos  = 0;
                    YPos += Line;
                    Line  = 0;
                }
                var CD = new CharDescription();

                CD.CharSize       = new Vector2(TL[i].Metrics.WidthIncludingTrailingWhitespace, TL[i].Metrics.Height);
                CD.OverhangLeft   = TL[i].OverhangMetrics.Left;
                CD.OverhangTop    = TL[i].OverhangMetrics.Top;
                CD.OverhangRight  = TL[i].Metrics.LayoutWidth + TL[i].OverhangMetrics.Right - TL[i].Metrics.WidthIncludingTrailingWhitespace;
                CD.OverhangBottom = TL[i].Metrics.LayoutHeight + TL[i].OverhangMetrics.Bottom - TL[i].Metrics.Height;
                //Safety space around chars that are not unvisible
                if (CD.CharSize.X + CD.OverhangLeft + CD.OverhangRight > 0 && CD.CharSize.Y + CD.OverhangTop + CD.OverhangBottom > 0)
                {
                    CD.OverhangBottom += 1;
                    CD.OverhangTop    += 1;
                    CD.OverhangRight  += 1;
                    CD.OverhangLeft   += 1;
                }

                //Correct overhangs, so size in pixels will be integer numbers
                //this avoids incorrect filtering results
                CD.OverhangRight  += (float)Math.Ceiling(CD.OverhangLeft + CD.CharSize.X + CD.OverhangRight) - (CD.OverhangLeft + CD.CharSize.X + CD.OverhangRight);
                CD.OverhangBottom += (float)Math.Ceiling(CD.OverhangTop + CD.CharSize.Y + CD.OverhangBottom) - (CD.OverhangTop + CD.CharSize.Y + CD.OverhangBottom);

                CD.TexCoordsStart = new Vector2((XPos / SizeX), (YPos / SizeY));
                CD.TexCoordsSize  = new Vector2((CD.OverhangLeft + CD.CharSize.X + CD.OverhangRight) / SizeX, (CD.OverhangTop + CD.CharSize.Y + CD.OverhangBottom) / SizeY);

                CD.TableDescription = TableDesc;

                TableDesc.Chars[i] = CD;

                Target.DrawTextLayout(new PointF(XPos + CD.OverhangLeft, YPos + CD.OverhangTop), TL[i], Color);
                XPos += CharWidth;
                TL[i].Dispose();
            }
            Target.EndDraw();
            Color.Dispose();

            System.Threading.Monitor.Enter(D3DDevice11);
            var DXGIResource = new global::SlimDX.DXGI.Resource(Texture);

            global::SlimDX.Direct3D11.Texture2D Texture11;
            if (PixCompatible)
            {
                Texture11 = new global::SlimDX.Direct3D11.Texture2D(D3DDevice11, new global::SlimDX.Direct3D11.Texture2DDescription()
                {
                    ArraySize         = 1,
                    BindFlags         = global::SlimDX.Direct3D11.BindFlags.ShaderResource | global::SlimDX.Direct3D11.BindFlags.RenderTarget,
                    CpuAccessFlags    = global::SlimDX.Direct3D11.CpuAccessFlags.None,
                    Format            = Format.R8G8B8A8_UNorm,
                    Height            = SizeY,
                    Width             = SizeX,
                    MipLevels         = 1,
                    OptionFlags       = global::SlimDX.Direct3D11.ResourceOptionFlags.Shared,
                    SampleDescription = new SampleDescription(1, 0),
                    Usage             = global::SlimDX.Direct3D11.ResourceUsage.Default
                });
            }
            else
            {
                Texture11 = D3DDevice11.OpenSharedResource <global::SlimDX.Direct3D11.Texture2D>(DXGIResource.SharedHandle);
            }
            var SRV = new global::SlimDX.Direct3D11.ShaderResourceView(D3DDevice11, Texture11);

            TableDesc.Texture = Texture11;
            TableDesc.SRV     = SRV;
            rtv.Dispose();
            System.Threading.Monitor.Exit(D3DDevice11);

            System.Diagnostics.Debug.WriteLine("Created Char Table " + BytePrefix + " in " + SizeX + " x " + SizeY);

            //System.Threading.Monitor.Enter(D3DDevice11);
            //SlimDX.Direct3D11.Texture2D.SaveTextureToFile(Sprite.Device.ImmediateContext, Texture11, SlimDX.Direct3D11.ImageFileFormat.Png, Font.FontFamilyName + "Table" + BytePrefix + ".png");
            //System.Threading.Monitor.Exit(D3DDevice11);

            CharTables.Add(BytePrefix, TableDesc);

            DXGIResource.Dispose();
            Target.Dispose();
            Surface.Dispose();
            Texture.Dispose();
        }
Exemple #40
0
 void DrawPreviousFrameTo(RenderTargetView target)
 {
     DrawSomethingFromTo(_renderTargetResource, target, _effectScreen.TechCopy);
 }
Exemple #41
0
 public void DrawSomethingFromTo(ShaderResourceView res, RenderTargetView target, EffectTechnique tech, RasterizerState rast = null)
 {
     DrawSomethingFromTo(res, target, _effectScreen.LayoutPT, _effectScreen.FxInputImage, tech, rast);
 }
        public DeferredRenderer(DX11Game game)
        {
            this.game = game;
            var device = game.Device;

            context = device.ImmediateContext;

            screenWidth  = game.Form.Form.ClientSize.Width;
            screenHeight = game.Form.Form.ClientSize.Height;
            int width  = screenWidth;
            int height = screenHeight;

            gBuffer     = new GBuffer(game.Device, width, height);
            texturePool = new TexturePool(game);

            meshesRenderer = new DeferredMeshesRenderer(game, gBuffer, TexturePool);

            directionalLightRenderer = new DirectionalLightRenderer(game, GBuffer);
            spotLightRenderer        = new SpotLightRenderer(game, GBuffer);
            pointLightRenderer       = new PointLightRenderer(game, GBuffer);

            combineFinalRenderer = new CombineFinalRenderer(game, GBuffer);

            var desc = new Texture2DDescription
            {
                BindFlags =
                    BindFlags.RenderTarget | BindFlags.ShaderResource,
                Format            = Format.R16G16B16A16_Float,
                Width             = screenWidth,
                Height            = screenHeight,
                ArraySize         = 1,
                SampleDescription = new SampleDescription(1, 0),
                MipLevels         = 1
            };

            hdrImage = new Texture2D(device, desc);

            hdrImageRtv = new RenderTargetView(device, hdrImage);
            hdrImageRV  = new ShaderResourceView(device, hdrImage);

            calculater = new AverageLuminanceCalculater(game, hdrImageRV);

            toneMap = new ToneMapRenderer(game);


            var tempDesc = new Texture2DDescription
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.None,
                CpuAccessFlags    = CpuAccessFlags.Read,
                Format            = Format.R32_Float,
                Height            = 1,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.None,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Staging,
                Width             = 1
            };

            tempTex = new Texture2D(device, tempDesc);



            ssao = new HorizonSSAORenderer(game, screenWidth, screenHeight);



            Vector3 radius = new Vector3(500, 1000, 500);

            frustumCuller = new FrustumCuller(new BoundingBox(-radius, radius), 1);

            gbufferView           = frustumCuller.CreateView();
            meshesRenderer.Culler = frustumCuller;

            Texture2D skyColorTexture;// = Texture2D.FromFile(game.Device, TWDir.GameData.CreateSubdirectory("Core") + "\\skyColor.bmp");

            var strm = new DataStream(16 * 4, true, true);

            var multiplier = 2;

            strm.Write(new Half4(new Half(135f / 255f * multiplier), new Half(206f / 255f * multiplier), new Half(235 / 255f * multiplier), new Half(1)));
            strm.Position = 0;
            var dataRectangle = new DataRectangle(16 * 4, strm);

            skyColorTexture = new Texture2D(game.Device, new Texture2DDescription
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.R16G16B16A16_Float,
                Height            = 1,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.None,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default,
                Width             = 1
            }, dataRectangle);

            skyColorRV = new ShaderResourceView(game.Device, skyColorTexture);


            postProcessRT1 = CreateBackbufferLikeRT();
            postProcessRT2 = CreateBackbufferLikeRT();

            fogRenderer = new FogEffect(game);

            backgroundDepthStencilState = DepthStencilState.FromDescription(game.Device, new DepthStencilStateDescription()
            {
                IsDepthEnabled  = true,
                DepthComparison = Comparison.LessEqual,
                DepthWriteMask  = DepthWriteMask.Zero,
            });

            lineManager = new LineManager3D(game.Device);
            updateRasterizerState();
        }
Exemple #43
0
        public D3D11Framebuffer(Device device, ref FramebufferDescription description)
            : base(description.DepthTarget, description.ColorTargets)
        {
            if (description.DepthTarget != null)
            {
                D3D11Texture d3dDepthTarget         = Util.AssertSubtype <Texture, D3D11Texture>(description.DepthTarget.Value.Target);
                DepthStencilViewDescription dsvDesc = new DepthStencilViewDescription()
                {
                    Format = D3D11Formats.GetDepthFormat(d3dDepthTarget.Format),
                };
                if (d3dDepthTarget.ArrayLayers == 1)
                {
                    if (d3dDepthTarget.SampleCount == TextureSampleCount.Count1)
                    {
                        dsvDesc.Dimension          = DepthStencilViewDimension.Texture2D;
                        dsvDesc.Texture2D.MipSlice = (int)description.DepthTarget.Value.MipLevel;
                    }
                    else
                    {
                        dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
                    }
                }
                else
                {
                    if (d3dDepthTarget.SampleCount == TextureSampleCount.Count1)
                    {
                        dsvDesc.Dimension = DepthStencilViewDimension.Texture2DArray;
                        dsvDesc.Texture2DArray.FirstArraySlice = (int)description.DepthTarget.Value.ArrayLayer;
                        dsvDesc.Texture2DArray.ArraySize       = 1;
                        dsvDesc.Texture2DArray.MipSlice        = (int)description.DepthTarget.Value.MipLevel;
                    }
                    else
                    {
                        dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampledArray;
                        dsvDesc.Texture2DMSArray.FirstArraySlice = (int)description.DepthTarget.Value.ArrayLayer;
                        dsvDesc.Texture2DMSArray.ArraySize       = 1;
                    }
                }

                DepthStencilView = new DepthStencilView(device, d3dDepthTarget.DeviceTexture, dsvDesc);
            }

            if (description.ColorTargets != null && description.ColorTargets.Length > 0)
            {
                RenderTargetViews = new RenderTargetView[description.ColorTargets.Length];
                for (int i = 0; i < RenderTargetViews.Length; i++)
                {
                    D3D11Texture d3dColorTarget         = Util.AssertSubtype <Texture, D3D11Texture>(description.ColorTargets[i].Target);
                    RenderTargetViewDescription rtvDesc = new RenderTargetViewDescription
                    {
                        Format = D3D11Formats.ToDxgiFormat(d3dColorTarget.Format, false),
                    };
                    if (d3dColorTarget.ArrayLayers > 1 || (d3dColorTarget.Usage & TextureUsage.Cubemap) != 0)
                    {
                        if (d3dColorTarget.SampleCount == TextureSampleCount.Count1)
                        {
                            rtvDesc.Dimension      = RenderTargetViewDimension.Texture2DArray;
                            rtvDesc.Texture2DArray = new RenderTargetViewDescription.Texture2DArrayResource
                            {
                                ArraySize       = 1,
                                FirstArraySlice = (int)description.ColorTargets[i].ArrayLayer,
                                MipSlice        = (int)description.ColorTargets[i].MipLevel
                            };
                        }
                        else
                        {
                            rtvDesc.Dimension        = RenderTargetViewDimension.Texture2DMultisampledArray;
                            rtvDesc.Texture2DMSArray = new RenderTargetViewDescription.Texture2DMultisampledArrayResource
                            {
                                ArraySize       = 1,
                                FirstArraySlice = (int)description.ColorTargets[i].ArrayLayer
                            };
                        }
                    }
                    else
                    {
                        if (d3dColorTarget.SampleCount == TextureSampleCount.Count1)
                        {
                            rtvDesc.Dimension          = RenderTargetViewDimension.Texture2D;
                            rtvDesc.Texture2D.MipSlice = (int)description.ColorTargets[i].MipLevel;
                        }
                        else
                        {
                            rtvDesc.Dimension = RenderTargetViewDimension.Texture2DMultisampled;
                        }
                    }
                    RenderTargetViews[i] = new RenderTargetView(device, d3dColorTarget.DeviceTexture, rtvDesc);
                }
            }
            else
            {
                RenderTargetViews = Array.Empty <RenderTargetView>();
            }
        }
Exemple #44
0
        /// <summary>
        /// Initializes a new instance of the <see cref="RenderTargetCube"/> class.
        /// </summary>
        /// <param name="graphicsDevice">The graphics device.</param>
        /// <param name="size">The width and height of a texture cube face in pixels.</param>
        /// <param name="mipMap"><see langword="true"/> to generate a full mipmap chain; otherwise <see langword="false"/>.</param>
        /// <param name="preferredFormat">The preferred format of the surface.</param>
        /// <param name="preferredDepthFormat">The preferred format of the depth-stencil buffer.</param>
        /// <param name="preferredMultiSampleCount">The preferred number of multisample locations.</param>
        /// <param name="usage">The usage mode of the render target.</param>
        public RenderTargetCube(GraphicsDevice graphicsDevice, int size, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
            : base(graphicsDevice, size, mipMap, preferredFormat, true)
        {
            DepthStencilFormat = preferredDepthFormat;
            MultiSampleCount   = preferredMultiSampleCount;
            RenderTargetUsage  = usage;

#if DIRECTX
            // Create one render target view per cube map face.
            _renderTargetViews = new RenderTargetView[6];
            for (int i = 0; i < _renderTargetViews.Length; i++)
            {
                var renderTargetViewDescription = new RenderTargetViewDescription
                {
                    Dimension      = RenderTargetViewDimension.Texture2DArray,
                    Format         = SharpDXHelper.ToFormat(preferredFormat),
                    Texture2DArray =
                    {
                        ArraySize       = 1,
                        FirstArraySlice = i,
                        MipSlice        = 0
                    }
                };

                _renderTargetViews[i] = new RenderTargetView(graphicsDevice._d3dDevice, _texture, renderTargetViewDescription);
            }

            // If we don't need a depth buffer then we're done.
            if (preferredDepthFormat == DepthFormat.None)
            {
                return;
            }

            var sampleDescription = new SampleDescription(1, 0);
            if (preferredMultiSampleCount > 1)
            {
                sampleDescription.Count   = preferredMultiSampleCount;
                sampleDescription.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
            }

            var depthStencilDescription = new Texture2DDescription
            {
                Format            = SharpDXHelper.ToFormat(preferredDepthFormat),
                ArraySize         = 1,
                MipLevels         = 1,
                Width             = size,
                Height            = size,
                SampleDescription = sampleDescription,
                BindFlags         = BindFlags.DepthStencil,
            };

            using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, depthStencilDescription))
            {
                var depthStencilViewDescription = new DepthStencilViewDescription
                {
                    Dimension = DepthStencilViewDimension.Texture2D,
                    Format    = SharpDXHelper.ToFormat(preferredDepthFormat),
                };
                _depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer, depthStencilViewDescription);
            }
#else
            throw new NotImplementedException();
#endif
        }
        // viewport, render target
        internal unsafe static void Draw(RenderTargetView rtv, MyViewport viewport)
        {
            if (StackTop().m_internalBatch.Texture != null && StackTop().m_internalBatch.Count > 0)
            {
                StackTop().m_internalBatch.Commit();
            }
            StackTop().m_internalBatch = new MySpritesBatch();

            RC.DeviceContext.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleStrip;

            RC.SetIL(m_inputLayout);
            //RC.SetupScreenViewport();
            RC.DeviceContext.Rasterizer.SetViewport(viewport.OffsetX, viewport.OffsetY, viewport.Width, viewport.Height);

            RC.SetVS(m_vs);
            RC.SetCB(MyCommon.FRAME_SLOT, MyCommon.FrameConstants);
            RC.SetCB(MyCommon.PROJECTION_SLOT, MyCommon.GetObjectCB(64));
            RC.SetPS(m_ps);
            RC.DeviceContext.PixelShader.SetSamplers(0, SamplerStates.StandardSamplers);

            //RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, MyRender11.Backbuffer);
            // to reset state
            RC.BindDepthRT(null, DepthStencilAccess.DepthReadOnly, null);
            RC.DeviceContext.OutputMerger.SetRenderTargets(rtv);

            RC.SetBS(MyRender11.BlendGui);

            CheckBufferSize(StackTop().m_instances.Count);
            RC.SetVB(0, m_VB.Buffer, m_VB.Stride);

            var mapping = MyMapping.MapDiscard(m_VB.Buffer);

            for (int i = 0; i < StackTop().m_instances.Count; i++)
            {
                var helper = StackTop().m_instances[i];
                mapping.WriteAndPosition(ref helper);
            }
            mapping.Unmap();

            mapping = MyMapping.MapDiscard(MyCommon.GetObjectCB(64));
            var viewportSize = new Vector2(viewport.Width, viewport.Height);

            mapping.WriteAndPosition(ref viewportSize);
            mapping.Unmap();

            foreach (var batch in StackTop().m_batches)
            {
                if (batch.ScissorRectangle.HasValue)
                {
                    RC.SetRS(MyRender11.m_scissorTestRasterizerState);

                    var scissor = batch.ScissorRectangle.Value;
                    RC.DeviceContext.Rasterizer.SetScissorRectangle((int)scissor.X, (int)scissor.Y, (int)(scissor.X + scissor.Width), (int)(scissor.Y + scissor.Height));
                }
                else
                {
                    RC.SetRS(MyRender11.m_nocullRasterizerState);
                }

                RC.BindRawSRV(0, batch.Texture);
                RC.DeviceContext.DrawInstanced(4, batch.Count, 0, batch.Start);
            }

            RC.SetBS(null);
            RC.SetRS(null);

            StackTop().m_instances.Clear();
            StackTop().m_batches.Clear();
        }
Exemple #46
0
        private void CreateAndBindTargets()
        {
            this.D3DSurface.SetRenderTargetDX10(null);

            Disposer.RemoveAndDispose(ref this.RenderTargetView);
            Disposer.RemoveAndDispose(ref this.RenderTarget1View);
            Disposer.RemoveAndDispose(ref this.RenderTarget2View);
            Disposer.RemoveAndDispose(ref this.OutputRenderTargetView);
            Disposer.RemoveAndDispose(ref this.DepthStencilView);
            Disposer.RemoveAndDispose(ref this.BlendingState);
            Disposer.RemoveAndDispose(ref this.OutputRenderTarget);
            Disposer.RemoveAndDispose(ref this.RenderTarget);
            Disposer.RemoveAndDispose(ref this.RenderTarget1);
            Disposer.RemoveAndDispose(ref this.RenderTarget2);
            Disposer.RemoveAndDispose(ref this.ShaderTargetView);
            Disposer.RemoveAndDispose(ref this.ShaderTarget1View);
            Disposer.RemoveAndDispose(ref this.ShaderTarget2View);
            Disposer.RemoveAndDispose(ref this.DepthStencil);

            width  = Math.Max((int)base.ActualWidth, 100);
            height = Math.Max((int)base.ActualHeight, 100);
            SampleDescription quality = new SampleDescription(1, 0);

            Texture2DDescription colordesc = new Texture2DDescription
            {
                BindFlags         = BindFlags.RenderTarget | BindFlags.ShaderResource,
                Format            = Format.B8G8R8A8_UNorm,
                Width             = (int)width,
                Height            = (int)height,
                MipLevels         = 1,
                SampleDescription = quality,
                Usage             = ResourceUsage.Default,
                OptionFlags       = ResourceOptionFlags.Shared,
                CpuAccessFlags    = CpuAccessFlags.None,
                ArraySize         = 1
            };

            Texture2DDescription depthdesc = new Texture2DDescription
            {
                BindFlags         = BindFlags.DepthStencil,
                Format            = Format.D32_Float_S8X24_UInt,
                Width             = (int)width,
                Height            = (int)height,
                MipLevels         = 1,
                SampleDescription = quality,
                Usage             = ResourceUsage.Default,
                OptionFlags       = ResourceOptionFlags.None,
                CpuAccessFlags    = CpuAccessFlags.None,
                ArraySize         = 1
            };

            this.RenderTarget       = new Texture2D(this.Device, colordesc);
            this.OutputRenderTarget = new Texture2D(this.Device, colordesc);

            this.DepthStencil = new Texture2D(this.Device, depthdesc);

            RenderTarget1 = new Texture2D(this.Device, new Texture2DDescription
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.RenderTarget | BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.B8G8R8A8_UNorm,
                Width             = (int)width / 2,
                Height            = (int)height / 2,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.Shared,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default
            });

            RenderTarget2 = new Texture2D(this.Device, new Texture2DDescription
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.RenderTarget | BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.B8G8R8A8_UNorm,
                Width             = (int)width / 2,
                Height            = (int)height / 2,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.Shared,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default
            });

            BlendStateDescription stateDesc = new BlendStateDescription
            {
                SourceBlend           = BlendOption.One,
                DestinationBlend      = BlendOption.One,
                BlendOperation        = BlendOperation.Add,
                SourceAlphaBlend      = BlendOption.One,
                DestinationAlphaBlend = BlendOption.One,
                AlphaBlendOperation   = BlendOperation.Add
            };

            stateDesc.IsBlendEnabled[0]        = true;
            stateDesc.RenderTargetWriteMask[0] = ColorWriteMaskFlags.All;
            stateDesc.IsAlphaToCoverageEnabled = false;

            BlendingState = new BlendState(Device, ref stateDesc);

            this.DepthStencilView = new DepthStencilView(this.Device, this.DepthStencil);

            this.RenderTargetView       = new RenderTargetView(this.Device, this.RenderTarget);
            this.RenderTarget1View      = new RenderTargetView(this.Device, this.RenderTarget1);
            this.RenderTarget2View      = new RenderTargetView(this.Device, this.RenderTarget2);
            this.OutputRenderTargetView = new RenderTargetView(this.Device, this.OutputRenderTarget);

            this.ShaderTargetView  = new ShaderResourceView(this.Device, this.RenderTarget);
            this.ShaderTarget1View = new ShaderResourceView(this.Device, this.RenderTarget1);
            this.ShaderTarget2View = new ShaderResourceView(this.Device, this.RenderTarget2);

            try
            {
                this.D3DSurface.SetRenderTargetDX10(this.OutputRenderTarget);
            }
            catch
            { }
        }
Exemple #47
0
 public void SetRenderTarget(DepthStencilView dsv, RenderTargetView renderTarget)
 {
     deviceContext.OutputMerger.SetRenderTargets(dsv, renderTarget);
 }
Exemple #48
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="desc"></param>
        public void Initialize(BufferDesc desc)
        {
            var device = GraphicsCore.D3D11Device;

            // 情報取得
            width_  = desc.width;
            height_ = desc.height;
            format_ = desc.format;
            mips_   = desc.mips;
            if (mips_ == 0)
            {
                mips_ = 1;
            }

            BindFlags bindFlags = BindFlags.ShaderResource;

            if (desc.IsRenderTarget)
            {
                bindFlags |= BindFlags.RenderTarget;
            }
            if (desc.IsDepthStencil)
            {
                bindFlags |= BindFlags.DepthStencil;
            }
            if (desc.IsUnorderedAccess)
            {
                bindFlags |= BindFlags.UnorderedAccess;
            }

            CpuAccessFlags acc_flag   = CpuAccessFlags.None;
            ResourceUsage  res_usage  = ResourceUsage.Default;
            bool           isCube     = (desc.optionFlags & ResourceOptionFlags.TextureCube) != 0;
            int            array_size = (!isCube) ? 1 : 6;

            // 初期化データ
            DataRectangle[] dataRect = null;
            if (desc.initData != null)
            {
                dataRect = new DataRectangle[desc.initData.Length * desc.initData[0].Length];
                int index = 0;
                for (int i = 0; i < desc.initData[0].Length; i++)
                {
                    for (int m = 0; m < desc.initData.Length; m++)
                    {
                        dataRect[index++] = new DataRectangle((width_ >> m) * 4, new DataStream(desc.initData[m][i], true, true));
                    }
                }
            }

            // テクスチャオブジェクト
            Texture2DDescription textureDescription = new Texture2DDescription {
                ArraySize      = array_size,
                BindFlags      = bindFlags,
                CpuAccessFlags = acc_flag,
                Format         = desc.format,
                Height         = desc.height,
                Width          = desc.width,
                MipLevels      = mips_,
                //OptionFlags = (mips_ > 1 && needsGpuWrite) ? ResourceOptionFlags.GenerateMipMaps : ResourceOptionFlags.None,
                OptionFlags       = desc.optionFlags,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = res_usage
            };
            var texture2d = new Texture2D(device, textureDescription, dataRect);

            buffer_ = texture2d;

            // 初期データ解放
            if (dataRect != null)
            {
                foreach (var d in dataRect)
                {
                    d.Data.Close();
                }
            }

            Format srvFormat = desc.format;

            // Special case for depth
            if (desc.IsDepthStencil)
            {
                srvFormat = (desc.format == Format.R32_Typeless) ? Format.R32_Float : Format.R24_UNorm_X8_Typeless;
            }

            ShaderResourceViewDescription srvViewDesc = new ShaderResourceViewDescription {
                ArraySize       = 0,
                Format          = srvFormat,
                Dimension       = (isCube) ? ShaderResourceViewDimension.TextureCube : ShaderResourceViewDimension.Texture2D,
                Flags           = 0,
                FirstArraySlice = 0,
                MostDetailedMip = 0,
                MipLevels       = mips_
            };

            shaderResourceView_ = new ShaderResourceView(device, texture2d, srvViewDesc);

            // レンダーターゲットビュー
            if (desc.IsRenderTarget)
            {
                if (!isCube)
                {
                    // 通常
                    RenderTargetViewDescription rtViewDesc = new RenderTargetViewDescription {
                        Dimension = RenderTargetViewDimension.Texture2D,
                        Format    = desc.format,
                        MipSlice  = 0,
                    };
                    renderTargetView_ = new RenderTargetView(device, texture2d, rtViewDesc);
                }
                else
                {
                    // キューブマップ
                    RenderTargetViewDescription rtViewDesc = new RenderTargetViewDescription {
                        Dimension = RenderTargetViewDimension.Texture2DArray,
                        Format    = desc.format,
                        MipSlice  = 0,
                        ArraySize = 1,
                    };
                    arrayRenderTargetView_ = new RenderTargetView[array_size * mips_];
                    for (int m = 0; m < mips_; m++)
                    {
                        for (int i = 0; i < array_size; i++)
                        {
                            rtViewDesc.MipSlice               = m;
                            rtViewDesc.FirstArraySlice        = i;
                            arrayRenderTargetView_[m * 6 + i] = new RenderTargetView(device, texture2d, rtViewDesc);
                        }
                    }
                }
            }

            // デプスステンシルビュー
            if (desc.IsDepthStencil)
            {
                DepthStencilViewDescription dsViewDesc = new DepthStencilViewDescription {
                    ArraySize       = 0,
                    Format          = (desc.format == Format.R32_Typeless) ? Format.D32_Float : Format.D24_UNorm_S8_UInt,
                    Dimension       = DepthStencilViewDimension.Texture2D,
                    MipSlice        = 0,
                    Flags           = 0,
                    FirstArraySlice = 0
                };

                depthStencilView_ = new DepthStencilView(device, texture2d, dsViewDesc);
            }

            // UAV
            if (desc.IsUnorderedAccess)
            {
                UnorderedAccessViewDescription uavDesc = new UnorderedAccessViewDescription {
                    ArraySize       = 0,
                    DepthSliceCount = 1,
                    Dimension       = UnorderedAccessViewDimension.Texture2D,
                    ElementCount    = 1,
                    FirstArraySlice = 0,
                    FirstDepthSlice = 0,
                    FirstElement    = 0,
                    Flags           = UnorderedAccessViewBufferFlags.None,
                    Format          = desc.format,
                    MipSlice        = 0
                };
                unorderedAccessView_ = new UnorderedAccessView(device, texture2d, uavDesc);
            }
        }
Exemple #49
0
        public bool Initialize(DSystemConfiguration configuration, IntPtr windowHandle)
        {
            try
            {
                #region Environment Configuration
                // Store the vsync setting.
                VerticalSyncEnabled = DSystemConfiguration.VerticalSyncEnabled;

                // Create a DirectX graphics interface factory.
                var factory = new Factory1();

                // Use the factory to create an adapter for the primary graphics interface (video card).
                var adapter = factory.GetAdapter1(0);

                // Get the primary adapter output (monitor).
                var monitor = adapter.GetOutput(0);

                // Get modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
                var modes = monitor.GetDisplayModeList(Format.R8G8B8A8_UNorm, DisplayModeEnumerationFlags.Interlaced);

                // Now go through all the display modes and find the one that matches the screen width and height.
                // When a match is found store the the refresh rate for that monitor, if vertical sync is enabled.
                // Otherwise we use maximum refresh rate.
                var rational = new Rational(0, 1);
                if (VerticalSyncEnabled)
                {
                    foreach (var mode in modes)
                    {
                        if (mode.Width == configuration.Width && mode.Height == configuration.Height)
                        {
                            rational = new Rational(mode.RefreshRate.Numerator, mode.RefreshRate.Denominator);
                            break;
                        }
                    }
                }

                // Get the adapter (video card) description.
                var adapterDescription = adapter.Description;

                // Store the dedicated video card memory in megabytes.
                VideoCardMemory = adapterDescription.DedicatedVideoMemory >> 10 >> 10;

                // Convert the name of the video card to a character array and store it.
                VideoCardDescription = adapterDescription.Description.Trim('\0');

                // Release the adapter output.
                monitor.Dispose();
                // Release the adapter.
                adapter.Dispose();
                // Release the factory.
                factory.Dispose();
                #endregion

                #region Initialize swap chain and d3d device
                // Initialize the swap chain description.
                var swapChainDesc = new SwapChainDescription()
                {
                    // Set to a single back buffer.
                    BufferCount = 1,
                    // Set the width and height of the back buffer.
                    ModeDescription = new ModeDescription(configuration.Width, configuration.Height, rational, Format.R8G8B8A8_UNorm),
                    // Set the usage of the back buffer.
                    Usage = Usage.RenderTargetOutput,
                    // Set the handle for the window to render to.
                    OutputHandle = windowHandle,
                    // Turn multisampling off.
                    SampleDescription = new SampleDescription(1, 0),
                    // Set to full screen or windowed mode.
                    IsWindowed = !DSystemConfiguration.FullScreen,
                    // Don't set the advanced flags.
                    Flags = SwapChainFlags.None,
                    // Discard the back buffer content after presenting.
                    SwapEffect = SwapEffect.Discard
                };

                // Create the swap chain, Direct3D device, and Direct3D device context.
                SharpDX.Direct3D11.Device device;
                SwapChain swapChain;
                SharpDX.Direct3D11.Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, swapChainDesc, out device, out swapChain);

                Device        = device;
                SwapChain     = swapChain;
                DeviceContext = device.ImmediateContext;
                #endregion

                #region Initialize buffers
                // Get the pointer to the back buffer.
                var backBuffer = Texture2D.FromSwapChain <Texture2D>(SwapChain, 0);

                // Create the render target view with the back buffer pointer.
                RenderTargetView = new RenderTargetView(device, backBuffer);

                // Release pointer to the back buffer as we no longer need it.
                backBuffer.Dispose();

                // Initialize and set up the description of the depth buffer.
                var depthBufferDesc = new Texture2DDescription()
                {
                    Width             = configuration.Width,
                    Height            = configuration.Height,
                    MipLevels         = 1,
                    ArraySize         = 1,
                    Format            = Format.D24_UNorm_S8_UInt,
                    SampleDescription = new SampleDescription(1, 0),
                    Usage             = ResourceUsage.Default,
                    BindFlags         = BindFlags.DepthStencil,
                    CpuAccessFlags    = CpuAccessFlags.None,
                    OptionFlags       = ResourceOptionFlags.None
                };

                // Create the texture for the depth buffer using the filled out description.
                DepthStencilBuffer = new Texture2D(device, depthBufferDesc);
                #endregion

                #region Initialize Depth Enabled Stencil
                #endregion

                #region Initialize Output Merger
                // Initialize and set up the depth stencil view.
                var depthStencilViewDesc = new DepthStencilViewDescription()
                {
                    Format    = Format.D24_UNorm_S8_UInt,
                    Dimension = DepthStencilViewDimension.Texture2D,
                    Texture2D = new DepthStencilViewDescription.Texture2DResource()
                    {
                        MipSlice = 0
                    }
                };

                // Create the depth stencil view.
                DepthStencilView = new DepthStencilView(Device, DepthStencilBuffer, depthStencilViewDesc);

                // Bind the render target view and depth stencil buffer to the output render pipeline.
                DeviceContext.OutputMerger.SetTargets(DepthStencilView, RenderTargetView);
                #endregion

                #region Initialize Raster State
                // Setup the raster description which will determine how and what polygon will be drawn.
                var rasterDesc = new RasterizerStateDescription()
                {
                    IsAntialiasedLineEnabled = false,
                    CullMode                = CullMode.Back,
                    DepthBias               = 0,
                    DepthBiasClamp          = .0f,
                    IsDepthClipEnabled      = true,
                    FillMode                = FillMode.Solid,
                    IsFrontCounterClockwise = false,
                    IsMultisampleEnabled    = false,
                    IsScissorEnabled        = false,
                    SlopeScaledDepthBias    = .0f
                };

                // Create the rasterizer state from the description we just filled out.
                RasterState = new RasterizerState(Device, rasterDesc);
                #endregion

                #region Initialize Rasterizer
                // Now set the rasterizer state.
                DeviceContext.Rasterizer.State = RasterState;

                // Setup and create the viewport for rendering.
                DeviceContext.Rasterizer.SetViewport(0, 0, configuration.Width, configuration.Height, 0, 1);
                #endregion

                #region Initialize matrices
                // Setup and create the projection matrix.
                ProjectionMatrix = Matrix.PerspectiveFovLH((float)(Math.PI / 4), ((float)configuration.Width / (float)configuration.Height), DSystemConfiguration.ScreenNear, DSystemConfiguration.ScreenDepth);

                // Initialize the world matrix to the identity matrix.
                WorldMatrix = Matrix.Identity;
                #endregion

                #region Initialize Depth Disabled Stencil
                #endregion

                #region Initialize Blend States
                #endregion

                return(true);
            }
            catch (Exception)
            {
                return(false);
            }
        }
Exemple #50
0
        private static void Main()
        {
            Noesis.Log.SetLogCallback((level, channel, message) =>
            {
                if (channel == "")
                {
                    // [TRACE] [DEBUG] [INFO] [WARNING] [ERROR]
                    string[] prefixes = new string[] { "T", "D", "I", "W", "E" };
                    string prefix     = (int)level < prefixes.Length ? prefixes[(int)level] : " ";
                    Console.WriteLine("[NOESIS/" + prefix + "] " + message);
                }
            });

            // Noesis initialization. This must be the first step before using any NoesisGUI functionality
            Noesis.GUI.Init("LICENSE_NAME", "LICENSE_KEY");

            // Setup theme
            NoesisApp.Application.SetThemeProviders();
            Noesis.GUI.LoadApplicationResources("Theme/NoesisTheme.DarkBlue.xaml");

            // For simplicity purposes we are not using resource providers in this sample. ParseXaml() is
            // enough if there is no extra XAML dependencies
            Noesis.Grid xaml = (Noesis.Grid)Noesis.GUI.ParseXaml(@"
                <Grid xmlns=""http://schemas.microsoft.com/winfx/2006/xaml/presentation"">
                    <Grid.Background>
                        <LinearGradientBrush StartPoint=""0,0"" EndPoint=""0,1"">
                            <GradientStop Offset=""0"" Color=""#FF123F61""/>
                            <GradientStop Offset=""0.6"" Color=""#FF0E4B79""/>
                            <GradientStop Offset=""0.7"" Color=""#FF106097""/>
                        </LinearGradientBrush>
                    </Grid.Background>
                    <Viewbox>
                        <StackPanel Margin=""50"">
                            <Button Content=""Hello World!"" Margin=""0,30,0,0""/>
                            <Rectangle Height=""5"" Margin=""-10,20,-10,0"">
                                <Rectangle.Fill>
                                    <RadialGradientBrush>
                                        <GradientStop Offset=""0"" Color=""#40000000""/>
                                        <GradientStop Offset=""1"" Color=""#00000000""/>
                                    </RadialGradientBrush>
                                </Rectangle.Fill>
                            </Rectangle>
                        </StackPanel>
                    </Viewbox>
                </Grid>");

            // View creation to render and interact with the user interface
            // We transfer the ownership to a global pointer instead of a Ptr<> because there is no way
            // in GLUT to do shutdown and we don't want the Ptr<> to be released at global time
            Noesis.View view = Noesis.GUI.CreateView(xaml);
            view.SetFlags(Noesis.RenderFlags.PPAA | Noesis.RenderFlags.LCD);

            // Creation of the system window
            RenderForm form = new RenderForm("NoesisGUI - IntegrationSharpDX D3D11")
            {
                Width  = 1000,
                Height = 600,
                Icon   = new System.Drawing.Icon("Noesis.ico")
            };

            view.SetSize(form.ClientSize.Width, form.ClientSize.Height);

            // SwapChain description
            SwapChainDescription desc = new SwapChainDescription()
            {
                BufferCount     = 1,
                ModeDescription = new ModeDescription(form.ClientSize.Width, form.ClientSize.Height,
                                                      new Rational(60, 1), Format.R8G8B8A8_UNorm),
                IsWindowed        = true,
                OutputHandle      = form.Handle,
                SampleDescription = new SampleDescription(1, 0),
                SwapEffect        = SwapEffect.Discard,
                Usage             = Usage.RenderTargetOutput
            };

            // Create Device and SwapChain
            Device    device;
            SwapChain swapChain;

            Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, desc, out device, out swapChain);
            DeviceContext context = device.ImmediateContext;

            Factory factory = swapChain.GetParent <Factory>();

            factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAll);
            factory.Dispose();

            // Renderer initialization with a Direct3D11 device
            view.Renderer.Init(new Noesis.RenderDeviceD3D11(context.NativePointer));

            // New RenderTargetView from the backbuffer
            Texture2D        backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
            RenderTargetView renderView = new RenderTargetView(device, backBuffer);

            backBuffer.Dispose();

            // Register window events
            form.SizeChanged += (s, e) =>
            {
                context.OutputMerger.SetRenderTargets(null, (RenderTargetView)null);
                renderView.Dispose();

                swapChain.ResizeBuffers(0, 0, 0, Format.Unknown, SwapChainFlags.None);

                backBuffer = Texture2D.FromSwapChain <Texture2D>(swapChain, 0);
                renderView = new RenderTargetView(device, backBuffer);
                backBuffer.Dispose();

                view.SetSize(form.ClientSize.Width, form.ClientSize.Height);
            };
            form.MouseMove += (s, e) => { view.MouseMove(e.X, e.Y); };
            form.MouseDown += (s, e) =>
            {
                if (e.Button == MouseButtons.Left)
                {
                    view.MouseButtonDown(e.X, e.Y, Noesis.MouseButton.Left);
                }
            };
            form.MouseUp += (s, e) =>
            {
                if (e.Button == MouseButtons.Left)
                {
                    view.MouseButtonUp(e.X, e.Y, Noesis.MouseButton.Left);
                }
            };

            // Main loop
            DateTime start = DateTime.Now;

            RenderLoop.Run(form, () =>
            {
                // Update view (layout, animations, ...)
                view.Update((DateTime.Now - start).TotalSeconds);

                // Offscreen rendering phase populates textures needed by the on-screen rendering
                view.Renderer.UpdateRenderTree();
                view.Renderer.RenderOffscreen();

                // If you are going to render here with your own engine you need to restore the GPU state
                // because noesis changes it. In this case only framebuffer and viewport need to be restored
                context.Rasterizer.SetViewport(new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height, 0.0f, 1.0f));
                context.OutputMerger.SetTargets(renderView);
                context.ClearRenderTargetView(renderView, Color.Black);

                // Rendering is done in the active framebuffer
                view.Renderer.Render();

                // Present and swap buffers
                swapChain.Present(0, PresentFlags.None);
            });

            // Release all resources
            renderView.Dispose();
            context.ClearState();
            context.Flush();
            device.Dispose();
            context.Dispose();
            swapChain.Dispose();
        }
Exemple #51
0
        public void Setup(OperatorPart outputOpPart, double startTime = 0, double endTime = 184, double frameRate   = 30, double width                = 1920, double height = 1080,
                          string fileExtension = "png", bool skipExistingFiles            = false, string directory = "output", string filenameFormat = "[T]", SharpDX.DXGI.Format imageFormat = Format.R8G8B8A8_UNorm)
        {
            try
            {
                Dispose();

                _outputOpPart      = outputOpPart;
                _directory         = directory;
                _fileNameFormat    = filenameFormat;
                _startTime         = startTime;
                _endTime           = endTime;
                _frameRate         = frameRate;
                _width             = (int)width;
                _height            = (int)height;
                _samples           = 2;
                _fileExtension     = fileExtension.ToLower();
                _skipExistingFiles = skipExistingFiles;

                _defaultContext = new OperatorPartContext(0.0f);
                _defaultContext.Variables.Add("Screensize.Width", _width);
                _defaultContext.Variables.Add("Screensize.Height", _height);
                _defaultContext.Variables.Add("AspectRatio", (float)_width / _height);
                _defaultContext.Variables.Add("Samples", _samples);
                _defaultContext.Variables.Add("FullScreen", 0.0f);
                _defaultContext.Variables.Add("LoopMode", 0.0f);
                _defaultContext.ImageBufferFormat = imageFormat;

                _frameTime = 1.0 / _frameRate;

                Directory.CreateDirectory(_directory);

                _renderer = new DefaultRenderer();

                _texture = ShaderResourceView.FromFile(D3DDevice.Device, "./assets-common/image/white.png");


                _renderTargetResource = null;
                ResourceManager.ValidateRenderTargetResource(ref _renderTargetResource, _outputOpPart, D3DDevice.Device, _width, _height, imageFormat);
                _renderTargetView = new RenderTargetView(D3DDevice.Device, _renderTargetResource.Texture);

                _renderDepthResource = null;
                ResourceManager.ValidateDepthStencilResource(ref _renderDepthResource, _outputOpPart, D3DDevice.Device, _width, _height);
                var depthViewDesc = new DepthStencilViewDescription();
                depthViewDesc.Format    = Format.D32_Float;
                depthViewDesc.Dimension = DepthStencilViewDimension.Texture2D;

                _renderTargetDepthView = new DepthStencilView(D3DDevice.Device, _renderDepthResource.Texture, depthViewDesc);

                _gpuSyncer = new BlockingGpuSyncer(D3DDevice.Device);

                D3DDevice.Device.ImmediateContext.OutputMerger.SetTargets(_renderTargetDepthView, _renderTargetView);
                _viewport = new ViewportF(0, 0, _width, _height, 0.0f, 1.0f);
                D3DDevice.Device.ImmediateContext.Rasterizer.SetViewport(_viewport);


                var timeAccessorCollector = new OperatorPart.CollectOpPartFunctionsOfType <OperatorPartTraits.ITimeAccessor>();
                _outputOpPart.TraverseWithFunction(timeAccessorCollector, null);
                _timeAccessorOpPartFunctions = new List <OperatorPart.Function>();
                foreach (var opPartFunction in timeAccessorCollector.CollectedOpPartFunctions)
                {
                    _timeAccessorOpPartFunctions.Add(opPartFunction as OperatorPart.Function);
                }
                _currentTime = _startTime;
            }
            catch (Exception e)
            {
                Logger.Error("Failed to setup image-sequence {0}", e.Message);
            }
        }
Exemple #52
0
        public bool Initialize(int screenWidth, int screenHeight, bool vSync, IntPtr hwnd, bool fullScreen, float screenDepth, float screenNear)
        {
            try {
                vSyncEnabled = vSync;

                Rational refreshRate = new Rational(0, 0);

                var factory       = new Factory1();
                var adapter       = factory.Adapters[0];
                var adapterOutput = adapter.Outputs[0];

                var modes = adapterOutput.GetDisplayModeList(Format.R8G8B8A8_UNorm, DisplayModeEnumerationFlags.Interlaced);
                for (int i = 0; i < modes.Length; i++)
                {
                    if (modes[i].Width == screenWidth)
                    {
                        if (modes[i].Height == screenHeight)
                        {
                            refreshRate = modes[i].RefreshRate;
                        }
                    }
                }

                VideoCardMemory      = adapter.Description.DedicatedVideoMemory / 1024 / 1024;
                VideoCardDescription = adapter.Description.Description;

                adapterOutput.Dispose();
                adapter.Dispose();
                factory.Dispose();

                var swapChainDescription = new SwapChainDescription {
                    BufferCount     = 1,
                    ModeDescription =
                    {
                        Width            = screenWidth,
                        Height           = screenHeight,
                        Format           = Format.R8G8B8A8_UNorm,
                        RefreshRate      = vSyncEnabled ? refreshRate : new Rational(0, 0),
                        ScanlineOrdering = DisplayModeScanlineOrder.Unspecified,
                        Scaling          = DisplayModeScaling.Unspecified
                    },
                    Usage             = Usage.RenderTargetOutput,
                    OutputHandle      = hwnd,
                    SampleDescription = { Count = 1, Quality = 0 },
                    IsWindowed        = !fullScreen,
                    SwapEffect        = SwapEffect.Discard,
                    Flags             = SwapChainFlags.None
                };

                var featureLevel = FeatureLevel.Level_11_0;

                Device device;
                Device.CreateWithSwapChain(
                    DriverType.Hardware,
                    DeviceCreationFlags.Debug,
                    new[] { featureLevel },
                    swapChainDescription,
                    out device,
                    out swapChain
                    );
                Device        = device;
                DeviceContext = device.ImmediateContext;

                using (var backBuffer = swapChain.GetBackBuffer <Texture2D>(0)) {
                    renderTargetView = new RenderTargetView(device, backBuffer);
                }

                var depthBufferDescription = new Texture2DDescription {
                    Width             = screenWidth,
                    Height            = screenHeight,
                    MipLevels         = 1,
                    ArraySize         = 1,
                    Format            = Format.D24_UNorm_S8_UInt,
                    SampleDescription = new SampleDescription(1, 0),
                    Usage             = ResourceUsage.Default,
                    BindFlags         = BindFlags.DepthStencil,
                    CpuAccessFlags    = CpuAccessFlags.None,
                    OptionFlags       = ResourceOptionFlags.None
                };

                depthStencilBuffer = new Texture2D(device, depthBufferDescription);

                var depthStencilStateDescription = new DepthStencilStateDescription {
                    IsDepthEnabled   = true,
                    DepthWriteMask   = DepthWriteMask.All,
                    DepthComparison  = Comparison.Less,
                    IsStencilEnabled = true,
                    StencilReadMask  = 0xFF,
                    StencilWriteMask = 0xFF,
                    FrontFace        =
                    {
                        FailOperation      = StencilOperation.Keep,
                        DepthFailOperation = StencilOperation.Increment,
                        PassOperation      = StencilOperation.Keep,
                        Comparison         = Comparison.Always
                    },
                    BackFace =
                    {
                        FailOperation      = StencilOperation.Keep,
                        DepthFailOperation = StencilOperation.Decrement,
                        PassOperation      = StencilOperation.Keep,
                        Comparison         = Comparison.Always
                    }
                };

                depthStencilState = new DepthStencilState(device, depthStencilStateDescription);

                var depthStencilViewDescription = new DepthStencilViewDescription {
                    Format    = Format.D24_UNorm_S8_UInt,
                    Dimension = DepthStencilViewDimension.Texture2D,
                    Texture2D =
                    {
                        MipSlice = 0
                    }
                };

                depthStencilView = new DepthStencilView(device, depthStencilBuffer, depthStencilViewDescription);

                DeviceContext.OutputMerger.SetRenderTargets(depthStencilView, renderTargetView);

                var rasterizerStateDescription = new RasterizerStateDescription {
                    IsAntialiasedLineEnabled = false,
                    CullMode                = CullMode.Back,
                    DepthBias               = 0,
                    DepthBiasClamp          = 0.0f,
                    IsDepthClipEnabled      = true,
                    FillMode                = FillMode.Solid,
                    IsFrontCounterClockwise = false,
                    IsMultisampleEnabled    = false,
                    IsScissorEnabled        = false,
                    SlopeScaledDepthBias    = 0.0f
                };

                rasterizerState = new RasterizerState(device, rasterizerStateDescription);

                DeviceContext.Rasterizer.State = rasterizerState;

                var viewport = new Viewport {
                    Width    = screenWidth,
                    Height   = screenHeight,
                    MinDepth = 0.0f,
                    MaxDepth = 1.0f,
                    X        = 0,
                    Y        = 0
                };

                DeviceContext.Rasterizer.SetViewport(viewport);

                var fieldOfView  = MathUtil.Pi / 4.0f;
                var screenAspect = (float)screenWidth / screenHeight;
                Projection = Matrix.PerspectiveFovLH(fieldOfView, screenAspect, screenNear, screenDepth);
                World      = Matrix.Identity;
                Orthogonal = Matrix.OrthoLH(screenWidth, screenHeight, screenNear, screenDepth);
            } catch { return(false); }
            return(true);
        }
Exemple #53
0
        /// <summary>
        /// Updates resources associated with a holographic camera's swap chain.
        /// The app does not access the swap chain directly, but it does create
        /// resource views for the back buffer.
        /// </summary>
        public void CreateResourcesForBackBuffer(
            DeviceResources deviceResources,
            HolographicCameraRenderingParameters cameraParameters
            )
        {
            var device = deviceResources.D3DDevice;

            // Get the WinRT object representing the holographic camera's back buffer.
            IDirect3DSurface surface = cameraParameters.Direct3D11BackBuffer;

            // Get a DXGI interface for the holographic camera's back buffer.
            // Holographic cameras do not provide the DXGI swap chain, which is owned
            // by the system. The Direct3D back buffer resource is provided using WinRT
            // interop APIs.
            InteropStatics.IDirect3DDxgiInterfaceAccess surfaceDxgiInterfaceAccess = surface as InteropStatics.IDirect3DDxgiInterfaceAccess;
            IntPtr pResource = surfaceDxgiInterfaceAccess.GetInterface(InteropStatics.ID3D11Resource);

            SharpDX.Direct3D11.Resource resource = SharpDX.Direct3D11.Resource.FromPointer <SharpDX.Direct3D11.Resource>(pResource);
            Marshal.Release(pResource);

            // Get a Direct3D interface for the holographic camera's back buffer.
            Texture2D cameraBackBuffer = resource.QueryInterface <Texture2D>();

            // Determine if the back buffer has changed. If so, ensure that the render target view
            // is for the current back buffer.
            if ((null == d3dBackBuffer) || (d3dBackBuffer.NativePointer != cameraBackBuffer.NativePointer))
            {
                // This can change every frame as the system moves to the next buffer in the
                // swap chain. This mode of operation will occur when certain rendering modes
                // are activated.
                d3dBackBuffer = cameraBackBuffer;

                // Create a render target view of the back buffer.
                // Creating this resource is inexpensive, and is better than keeping track of
                // the back buffers in order to pre-allocate render target views for each one.
                d3dRenderTargetView = ToDispose(new RenderTargetView(device, BackBufferTexture2D));

                // Get the DXGI format for the back buffer.
                // This information can be accessed by the app using CameraResources::GetBackBufferDXGIFormat().
                Texture2DDescription backBufferDesc = BackBufferTexture2D.Description;
                dxgiFormat = backBufferDesc.Format;

                // Check for render target size changes.
                Size currentSize = holographicCamera.RenderTargetSize;
                if (d3dRenderTargetSize != currentSize)
                {
                    // Set render target size.
                    d3dRenderTargetSize = HolographicCamera.RenderTargetSize;

                    // A new depth stencil view is also needed.
                    RemoveAndDispose(ref d3dDepthStencilView);
                }
            }

            // Refresh depth stencil resources, if needed.
            if (null == DepthStencilView)
            {
                // Create a depth stencil view for use with 3D rendering if needed.
                var depthStencilDesc = new Texture2DDescription
                {
                    Format            = SharpDX.DXGI.Format.D16_UNorm,
                    Width             = (int)RenderTargetSize.Width,
                    Height            = (int)RenderTargetSize.Height,
                    ArraySize         = IsRenderingStereoscopic ? 2 : 1, // Create two textures when rendering in stereo.
                    MipLevels         = 1,                               // Use a single mipmap level.
                    BindFlags         = BindFlags.DepthStencil,
                    SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0)
                };

                using (var depthStencil = new Texture2D(device, depthStencilDesc))
                {
                    var depthStencilViewDesc = new DepthStencilViewDescription();
                    depthStencilViewDesc.Dimension = IsRenderingStereoscopic ? DepthStencilViewDimension.Texture2DArray : DepthStencilViewDimension.Texture2D;
                    depthStencilViewDesc.Texture2DArray.ArraySize = IsRenderingStereoscopic ? 2 : 0;
                    d3dDepthStencilView = ToDispose(new DepthStencilView(device, depthStencil, depthStencilViewDesc));
                }
            }

            // Create the constant buffer, if needed.
            if (null == viewProjectionConstantBuffer)
            {
                // Create a constant buffer to store view and projection matrices for the camera.
                ViewProjectionConstantBuffer viewProjectionConstantBufferData = new ViewProjectionConstantBuffer();
                viewProjectionConstantBuffer = ToDispose(SharpDX.Direct3D11.Buffer.Create(
                                                             device,
                                                             BindFlags.ConstantBuffer,
                                                             ref viewProjectionConstantBufferData));
            }
        }
        public void Render(DeviceContext deviceContext, ShaderResourceView depthImageTextureRV, ShaderResourceView colorImageTextureRV, SharpDX.Direct3D11.Buffer vertexBuffer, RenderTargetView renderTargetView, DepthStencilView depthStencilView, Viewport viewport)
        {
            //bilateralFilter.Render(deviceContext, depthImageTextureRV, filteredRenderTargetView2);
            //bilateralFilter.Render(deviceContext, filteredDepthImageSRV2, filteredRenderTargetView);

            //bilateralFilter.Render(deviceContext, filteredDepthImageSRV, filteredRenderTargetView2);
            //bilateralFilter.Render(deviceContext, filteredDepthImageSRV2, filteredRenderTargetView);



            deviceContext.InputAssembler.InputLayout       = vertexInputLayout;
            deviceContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
            deviceContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, VertexPosition.SizeInBytes, 0)); // bytes per vertex
            deviceContext.Rasterizer.State = rasterizerState;
            deviceContext.Rasterizer.SetViewport(viewport);
            deviceContext.VertexShader.Set(depthAndColorVS);
            deviceContext.VertexShader.SetShaderResource(0, depthImageTextureRV);
            //deviceContext.VertexShader.SetShaderResource(0, depthAndMaskRV);
            //deviceContext.VertexShader.SetShaderResource(0, filteredDepthImageSRV);
            deviceContext.VertexShader.SetConstantBuffer(0, constantBuffer);
            deviceContext.GeometryShader.Set(depthAndColorGS);
            deviceContext.PixelShader.Set(depthAndColorPS);
            deviceContext.PixelShader.SetShaderResource(0, colorImageTextureRV);
            deviceContext.PixelShader.SetSampler(0, colorSamplerState);
            deviceContext.OutputMerger.SetTargets(depthStencilView, renderTargetView);
            deviceContext.OutputMerger.DepthStencilState = depthStencilState;
            deviceContext.Draw((depthImageWidth - 1) * (depthImageHeight - 1) * 6, 0);
        }
Exemple #55
0
 void RenderPart(RenderTargetView Target)
 {
 }
Exemple #56
0
        public void Draw(DeviceContextHolder holder, ShaderResourceView source, Vector2 sourceSize, RenderTargetView destination, Vector2 destinationSize,
                         bool useFoundTech)
        {
            holder.DeviceContext.Rasterizer.SetViewports(new Viewport(0f, 0f, destinationSize.X, destinationSize.Y));

            holder.DeviceContext.OutputMerger.SetTargets(destination);
            holder.PrepareQuad(_effect.LayoutPT);
            _effect.FxInputMap.SetResource(source);

            _effect.FxScreenSize.Set(new Vector4(destinationSize.X, destinationSize.Y, 1f / destinationSize.X, 1f / destinationSize.Y));
            _effect.FxMultipler.Set(new Vector2(destinationSize.X / sourceSize.X, destinationSize.Y / sourceSize.Y));

            (useFoundTech ? _effect.TechFound : _effect.TechAverage).DrawAllPasses(holder.DeviceContext, 6);
        }
Exemple #57
0
        void CreateBuffers()
        {
            DisposeBuffers();

            // New RenderTargetView from the backbuffer
            using (var bb = Texture2D.FromSwapChain <Texture2D>(_swapChain, 0))
            {
                renderView = new RenderTargetView(_device, bb);
            }

            Texture2DDescription gBufferDesc = new Texture2DDescription()
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.RenderTarget | BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.R8G8B8A8_UNorm,
                Width             = _width,
                Height            = _height,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.None,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default
            };

            gBufferLight     = new Texture2D(_device, gBufferDesc);
            gBufferLightView = new RenderTargetView(_device, gBufferLight);

            gBufferNormal     = new Texture2D(_device, gBufferDesc);
            gBufferNormalView = new RenderTargetView(_device, gBufferNormal);

            gBufferDiffuse     = new Texture2D(_device, gBufferDesc);
            gBufferDiffuseView = new RenderTargetView(_device, gBufferDiffuse);

            gBufferViews = new RenderTargetView[] { gBufferLightView, gBufferNormalView, gBufferDiffuseView };

            ShaderResourceViewDescription gBufferResourceDesc = new ShaderResourceViewDescription()
            {
                Format    = Format.R8G8B8A8_UNorm,
                Dimension = ShaderResourceViewDimension.Texture2D,
                Texture2D = new ShaderResourceViewDescription.Texture2DResource()
                {
                    MipLevels       = 1,
                    MostDetailedMip = 0
                }
            };

            lightBufferRes   = new ShaderResourceView(_device, gBufferLight, gBufferResourceDesc);
            normalBufferRes  = new ShaderResourceView(_device, gBufferNormal, gBufferResourceDesc);
            diffuseBufferRes = new ShaderResourceView(_device, gBufferDiffuse, gBufferResourceDesc);


            Texture2DDescription depthDesc = new Texture2DDescription()
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.DepthStencil | BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.R32_Typeless,
                Width             = _width,
                Height            = _height,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.None,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default
            };

            DepthStencilViewDescription depthViewDesc = new DepthStencilViewDescription()
            {
                Dimension = DepthStencilViewDimension.Texture2D,
                Format    = Format.D32_Float,
            };

            ShaderResourceViewDescription resourceDesc = new ShaderResourceViewDescription()
            {
                Format    = Format.R32_Float,
                Dimension = ShaderResourceViewDimension.Texture2D,
                Texture2D = new ShaderResourceViewDescription.Texture2DResource()
                {
                    MipLevels       = 1,
                    MostDetailedMip = 0
                }
            };

            depthTexture = new Texture2D(_device, depthDesc);
            depthView    = new DepthStencilView(_device, depthTexture, depthViewDesc);
            depthRes     = new ShaderResourceView(_device, depthTexture, resourceDesc);

            lightDepthTexture = new Texture2D(_device, depthDesc);
            lightDepthView    = new DepthStencilView(_device, lightDepthTexture, depthViewDesc);
            lightDepthRes     = new ShaderResourceView(_device, lightDepthTexture, resourceDesc);

            lightBufferVar   = effect2.GetVariableByName("lightBuffer").AsShaderResource();
            normalBufferVar  = effect2.GetVariableByName("normalBuffer").AsShaderResource();
            diffuseBufferVar = effect2.GetVariableByName("diffuseBuffer").AsShaderResource();
            depthMapVar      = effect2.GetVariableByName("depthMap").AsShaderResource();
            lightDepthMapVar = effect2.GetVariableByName("lightDepthMap").AsShaderResource();

            inverseProjectionVar          = effect2.GetVariableByName("InverseProjection").AsMatrix();
            inverseViewVar                = effect2.GetVariableByName("InverseView").AsMatrix();
            lightInverseViewProjectionVar = effect2.GetVariableByName("LightInverseViewProjection").AsMatrix();
            lightPositionVar              = effect2.GetVariableByName("LightPosition").AsVector();
            eyePositionVar                = effect2.GetVariableByName("EyePosition").AsVector();

            tanHalfFOVXVar = effect2.GetVariableByName("TanHalfFOVX").AsScalar();
            tanHalfFOVYVar = effect2.GetVariableByName("TanHalfFOVY").AsScalar();
            projectionAVar = effect2.GetVariableByName("ProjectionA").AsScalar();
            projectionBVar = effect2.GetVariableByName("ProjectionB").AsScalar();

            overlayViewProjectionVar = effect2.GetVariableByName("OverlayViewProjection").AsMatrix();

            _immediateContext.Rasterizer.SetViewport(new ViewportF(0, 0, _width, _height));
        }
Exemple #58
0
        void CreateBuffers()
        {
            DisposeBuffers();

            // New RenderTargetView from the backbuffer
            using (var bb = Texture2D.FromSwapChain <Texture2D>(_swapChain, 0))
            {
                renderView = new RenderTargetView(Device, bb);
            }

            var gBufferDesc = new Texture2DDescription
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.RenderTarget | BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.R8G8B8A8_UNorm,
                Width             = _width,
                Height            = _height,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.None,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default
            };

            gBufferLight     = new Texture2D(Device, gBufferDesc);
            gBufferLightView = new RenderTargetView(Device, gBufferLight);

            gBufferNormal     = new Texture2D(Device, gBufferDesc);
            gBufferNormalView = new RenderTargetView(Device, gBufferNormal);

            gBufferDiffuse     = new Texture2D(Device, gBufferDesc);
            gBufferDiffuseView = new RenderTargetView(Device, gBufferDiffuse);

            gBufferPostProcess     = new Texture2D(Device, gBufferDesc);
            gBufferPostProcessView = new RenderTargetView(Device, gBufferPostProcess);

            if (depthOfFieldEnabled)
            {
                gBufferPostProcessBlur1     = new Texture2D(Device, gBufferDesc);
                gBufferPostProcessViewBlur1 = new RenderTargetView(Device, gBufferPostProcessBlur1);

                gBufferPostProcessBlur2     = new Texture2D(Device, gBufferDesc);
                gBufferPostProcessViewBlur2 = new RenderTargetView(Device, gBufferPostProcessBlur2);
            }

            gBufferViews = new[] { gBufferNormalView, gBufferDiffuseView };

            var gBufferResourceDesc = new ShaderResourceViewDescription
            {
                Format    = Format.R8G8B8A8_UNorm,
                Dimension = ShaderResourceViewDimension.Texture2D,
                Texture2D = new ShaderResourceViewDescription.Texture2DResource()
                {
                    MipLevels       = 1,
                    MostDetailedMip = 0
                }
            };

            lightBufferRes       = new ShaderResourceView(Device, gBufferLight, gBufferResourceDesc);
            normalBufferRes      = new ShaderResourceView(Device, gBufferNormal, gBufferResourceDesc);
            diffuseBufferRes     = new ShaderResourceView(Device, gBufferDiffuse, gBufferResourceDesc);
            postProcessBufferRes = new ShaderResourceView(Device, gBufferPostProcess, gBufferResourceDesc);
            if (depthOfFieldEnabled)
            {
                postProcessBufferBlur1Res = new ShaderResourceView(Device, gBufferPostProcessBlur1, gBufferResourceDesc);
                postProcessBufferBlur2Res = new ShaderResourceView(Device, gBufferPostProcessBlur2, gBufferResourceDesc);
            }


            var depthDesc = new Texture2DDescription
            {
                ArraySize         = 1,
                BindFlags         = BindFlags.DepthStencil | BindFlags.ShaderResource,
                CpuAccessFlags    = CpuAccessFlags.None,
                Format            = Format.R32_Typeless,
                Height            = _height,
                Width             = _width,
                MipLevels         = 1,
                OptionFlags       = ResourceOptionFlags.None,
                SampleDescription = new SampleDescription(1, 0),
                Usage             = ResourceUsage.Default
            };

            var depthViewDesc = new DepthStencilViewDescription
            {
                Dimension = DepthStencilViewDimension.Texture2D,
                Format    = Format.D32_Float,
            };

            var resourceDesc = new ShaderResourceViewDescription
            {
                Format    = Format.R32_Float,
                Dimension = ShaderResourceViewDimension.Texture2D,
                Texture2D = new ShaderResourceViewDescription.Texture2DResource()
                {
                    MipLevels       = 1,
                    MostDetailedMip = 0
                }
            };

            depthTexture   = new Texture2D(Device, depthDesc);
            depthView      = new DepthStencilView(Device, depthTexture, depthViewDesc);
            depthBufferRes = new ShaderResourceView(Device, depthTexture, resourceDesc);

            lightDepthTexture = new Texture2D(Device, depthDesc);
            lightDepthView    = new DepthStencilView(Device, lightDepthTexture, depthViewDesc);
            lightDepthRes     = new ShaderResourceView(Device, lightDepthTexture, resourceDesc);

            _immediateContext.Rasterizer.SetViewport(0, 0, _width, _height);
        }
Exemple #59
0
        static void Main()
        {
            var form = new RenderForm("SlimDX - MiniTri Direct3D 10 Sample");
            var desc = new SwapChainDescription()
            {
                BufferCount = 1,
                ModeDescription = new ModeDescription(form.ClientSize.Width, form.ClientSize.Height, new Rational(60, 1), Format.R8G8B8A8_UNorm),
                IsWindowed = true,
                OutputHandle = form.Handle,
                SampleDescription = new SampleDescription(1, 0),
                SwapEffect = SwapEffect.Discard,
                Usage = Usage.RenderTargetOutput
            };

            Device device;
            SwapChain swapChain;
            Device.CreateWithSwapChain(null, DriverType.Hardware, DeviceCreationFlags.Debug, desc, out device, out swapChain);

            //Stops Alt+enter from causing fullscreen skrewiness.
            device.Factory.SetWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAll);

            Texture2D backBuffer = Texture2D.FromSwapChain<Texture2D>(swapChain, 0);
            var renderView = new RenderTargetView(device, backBuffer);
            var effect = Effect.FromFile(device, "MiniTri.fx", "fx_4_0");
            var technique = effect.GetTechniqueByIndex(0);
            var pass = technique.GetPassByIndex(0);
            var layout = new InputLayout(device, pass.Description.Signature, new[] {
                new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
                new InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0) 
            });

            var stream = new DataStream(3 * 32, true, true);
            stream.WriteRange(new[] {
                new Vector4(0.0f, 0.5f, 0.5f, 1.0f), new Vector4(1.0f, 0.0f, 0.0f, 1.0f),
                new Vector4(0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 1.0f, 0.0f, 1.0f),
                new Vector4(-0.5f, -0.5f, 0.5f, 1.0f), new Vector4(0.0f, 0.0f, 1.0f, 1.0f)
            });
            stream.Position = 0;

            var vertices = new SlimDX.Direct3D10.Buffer(device, stream, new BufferDescription()
            {
                BindFlags = BindFlags.VertexBuffer,
                CpuAccessFlags = CpuAccessFlags.None,
                OptionFlags = ResourceOptionFlags.None,
                SizeInBytes = 3 * 32,
                Usage = ResourceUsage.Default
            });
            stream.Dispose();

            device.OutputMerger.SetTargets(renderView);
            device.Rasterizer.SetViewports(new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height, 0.0f, 1.0f));

            MessagePump.Run(form, () =>
            {
                device.ClearRenderTargetView(renderView, Color.Black);

                device.InputAssembler.SetInputLayout(layout);
                device.InputAssembler.SetPrimitiveTopology(PrimitiveTopology.TriangleList);
                device.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices, 32, 0));

                for (int i = 0; i < technique.Description.PassCount; ++i)
                {
                    pass.Apply();
                    device.Draw(3, 0);
                }

                swapChain.Present(0, PresentFlags.None);
            });

            vertices.Dispose();
            layout.Dispose();
            effect.Dispose();
            renderView.Dispose();
            backBuffer.Dispose();
            device.Dispose();
            swapChain.Dispose();
            //foreach (var item in ObjectTable.Objects)
            //    item.Dispose();
        }
Exemple #60
0
        // Puvlix Methods
        public bool Initialize(SharpDX.Direct3D11.Device device, DSystemConfiguration configuration)
        {
            try
            {
                // Initialize and set up the render target description.
                Texture2DDescription textureDesc = new Texture2DDescription()
                {
                    // Shadow Map Texture size as a 1024x1024 Square
                    Width             = 1024,
                    Height            = 1024,
                    MipLevels         = 1,
                    ArraySize         = 1,
                    Format            = Format.R32G32B32A32_Float,
                    SampleDescription = new SampleDescription(1, 0),
                    Usage             = ResourceUsage.Default,
                    BindFlags         = BindFlags.RenderTarget | BindFlags.ShaderResource,
                    CpuAccessFlags    = CpuAccessFlags.None,
                    OptionFlags       = ResourceOptionFlags.None
                };

                // Create the render target texture.
                RenderTargetTexture = new Texture2D(device, textureDesc);

                // Setup the description of the render target view.
                RenderTargetViewDescription renderTargetViewDesc = new RenderTargetViewDescription()
                {
                    Format    = textureDesc.Format,
                    Dimension = RenderTargetViewDimension.Texture2D,
                };
                renderTargetViewDesc.Texture2D.MipSlice = 0;

                // Create the render target view.
                RenderTargetView = new RenderTargetView(device, RenderTargetTexture, renderTargetViewDesc);

                // Setup the description of the shader resource view.
                ShaderResourceViewDescription shaderResourceViewDesc = new ShaderResourceViewDescription()
                {
                    Format    = textureDesc.Format,
                    Dimension = ShaderResourceViewDimension.Texture2D,
                };
                shaderResourceViewDesc.Texture2D.MipLevels       = 1;
                shaderResourceViewDesc.Texture2D.MostDetailedMip = 0;

                // Create the render target view.
                ShaderResourceView = new ShaderResourceView(device, RenderTargetTexture, shaderResourceViewDesc);

                // Initialize and Set up the description of the depth buffer.
                Texture2DDescription depthStencilDesc = new Texture2DDescription()
                {
                    Width             = 1024,
                    Height            = 1024,
                    MipLevels         = 1,
                    ArraySize         = 1,
                    Format            = Format.D24_UNorm_S8_UInt,
                    SampleDescription = new SampleDescription(1, 0),
                    Usage             = ResourceUsage.Default,
                    BindFlags         = BindFlags.DepthStencil,
                    CpuAccessFlags    = CpuAccessFlags.None,
                    OptionFlags       = ResourceOptionFlags.None
                };

                // Create the texture for the depth buffer using the filled out description.
                DepthStencilBuffer = new Texture2D(device, depthStencilDesc);

                // Initailze the depth stencil view description.
                DepthStencilViewDescription deothStencilViewDesc = new DepthStencilViewDescription()
                {
                    Format    = Format.D24_UNorm_S8_UInt,
                    Dimension = DepthStencilViewDimension.Texture2D
                };
                deothStencilViewDesc.Texture2D.MipSlice = 0;

                // Create the depth stencil view.
                DepthStencilView = new DepthStencilView(device, DepthStencilBuffer, deothStencilViewDesc);

                // Setup the viewport for rendering.
                ViewPort = new ViewportF()
                {
                    Width    = 1024.0f,
                    Height   = 1024.0f,
                    MinDepth = 0.0f,
                    MaxDepth = 1.0f,
                    X        = 0.0f,
                    Y        = 0.0f
                };

                return(true);
            }
            catch
            {
                return(false);
            }
        }