Пример #1
0
        public void Render()
        {
            var device  = this.deviceResources.D3DDevice;
            var context = this.deviceResources.D3DContext;

            float[] ClearColor         = new float[] { 0.0f, 0.55f, 0.55f, 1.0f };
            D3D11RenderTargetView pRTV = this.deviceResources.D3DRenderTargetView;
            D3D11DepthStencilView pDSV = this.deviceResources.D3DDepthStencilView;

            context.ClearRenderTargetView(pRTV, ClearColor);
            context.ClearDepthStencilView(pDSV, D3D11ClearOptions.Depth, 1.0f, 0);

            this.cascadedShadow.InitFrame(device, this.selectedMesh);
            this.cascadedShadow.RenderShadowsForAllCascades(device, context, this.selectedMesh);

            D3D11Viewport vp = new D3D11Viewport(
                0.0f,
                0.0f,
                this.deviceResources.BackBufferWidth,
                this.deviceResources.BackBufferHeight,
                0.0f,
                1.0f);

            this.cascadedShadow.RenderScene(context, pRTV, pDSV, this.selectedMesh, vp, this.VisualizeCascades);

            context.RasterizerStageSetViewports(new D3D11Viewport[] { vp });
            context.OutputMergerSetRenderTargets(new[] { pRTV }, pDSV);
        }
Пример #2
0
        public IDisplay Create(string title, int width, int height, IAdapter adapter)
        {
            const uint defaultRefreshRate = 144;
            const bool debug = true;

            var window = _windowCreator.CreateWindow(new CreateWindowArguments(title, width, height));

            // Create device
            var d3D11Device = _d3D11DeviceFactory.Create(new CreateDeviceArguments(window, defaultRefreshRate, adapter?.Handle ?? IntPtr.Zero, debug));

            // Created the backbuffer and the RenderTargetView
            using var backBuffer = d3D11Device.SwapChain.GetBuffer(0, D3D11Resources.D3D11Resource);
            var renderTarget = d3D11Device.CreateRenderTargetView(backBuffer);


            D3D11Texture2DDesc sTarget = default;

            sTarget.Height             = (uint)window.Height;
            sTarget.Width              = (uint)window.Width;
            sTarget.MipLevels          = 1u;
            sTarget.ArraySize          = 1u;
            sTarget.Format             = DxgiFormat.R8G8B8A8Unorm;
            sTarget.SampleDesc.Count   = 1;
            sTarget.SampleDesc.Quality = 0;
            sTarget.Usage              = D3D11Usage.Default;
            sTarget.BindFlags          = D3D11BindFlag.RenderTarget;

            //var d3D11Texture2D = d3D11Device.CreateTexture2D(sTarget); // TODO: this is getting leaked
            //var secondRenderTarget = d3D11Device.CreateRenderTargetView(d3D11Texture2D); // TODO: this is getting leaked


            // Create the DepthStencilView (z-buffering)
            D3D11DepthStencilDesc depthDesc = default;

            depthDesc.DepthEnable = true;
            //depthDesc.DepthWriteMask = D3D11DepthWriteMask.Zero;
            //depthDesc.DepthFunc = D3D11ComparisonFunc.LessEqual;  // this is needed to add alpha-blending to sprites, not sure why.
            depthDesc.DepthWriteMask    = D3D11DepthWriteMask.All;
            depthDesc.DepthFunc         = D3D11ComparisonFunc.LessEqual; // this is needed to add alpha-blending to sprites, not sure why.
            using var depthStencilState = d3D11Device.CreateDepthStencilState(depthDesc);
            d3D11Device.Context.OMSetDepthStencilState(depthStencilState, 1u);

            D3D11Texture2DDesc texture2DDesc = default;

            texture2DDesc.Height    = (uint)window.Height;
            texture2DDesc.Width     = (uint)window.Width;
            texture2DDesc.MipLevels = 1u;
            texture2DDesc.ArraySize = 1u;
            texture2DDesc.Format    = DxgiFormat.D32Float;
            //texture2DDesc.SampleDesc.Count = 4u;  // AA
            texture2DDesc.SampleDesc.Count   = 1;
            texture2DDesc.SampleDesc.Quality = 0;
            texture2DDesc.Usage     = D3D11Usage.Default;
            texture2DDesc.BindFlags = D3D11BindFlag.DepthStencil;
            using var depthStencil  = d3D11Device.CreateTexture2D(texture2DDesc);

            D3D11DepthStencilViewDesc viewDesc = default;

            viewDesc.Format        = DxgiFormat.D32Float;
            viewDesc.ViewDimension = D3D11DsvDimension.Texture2D;
            //viewDesc.ViewDimension = D3D11DsvDimension.Texture2Dms; // AA
            viewDesc.Texture2D.MipSlice = 0u;
            var depthStencilView = d3D11Device.CreateDepthStencilView(depthStencil, viewDesc);

            // Set the render target view and depthStencil
            unsafe
            {
                var renderTargets = stackalloc IntPtr[1];
                renderTargets[0] = renderTarget.Handle;
                d3D11Device.Context.OMSetRenderTargets(renderTargets, 1, depthStencilView.Handle);
            }



            // Set the default viewport
            D3D11Viewport viewport = default;

            viewport.Width    = window.Width;
            viewport.Height   = window.Height;
            viewport.MinDepth = 0;
            viewport.MaxDepth = 1;

            d3D11Device.Context.SetViewport(viewport);


            // Create the device abstraction
            var device = new Device(d3D11Device, renderTarget, depthStencilView, _compiler);

            return(new Display(device, window));
        }
Пример #3
0
        private void CreateWindowSizeDependentResources()
        {
            this.d3dContext.OutputMergerSetRenderTargets(new D3D11RenderTargetView[] { null }, null);

            D3D11Utils.DisposeAndNull(ref this.backBuffer);
            D3D11Utils.DisposeAndNull(ref this.offscreenBuffer);
            D3D11Utils.DisposeAndNull(ref this.d3dRenderTargetView);
            D3D11Utils.DisposeAndNull(ref this.d3dDepthStencilView);
            D2D1Utils.DisposeAndNull(ref this.d2dRenderTarget);

            this.d3dContext.Flush();

            var createdBackBuffer = this.OnCreateBackBuffer();

            if (createdBackBuffer == null)
            {
                return;
            }

            this.backBuffer = createdBackBuffer;

            var backBufferDesc = this.backBuffer.Description;

            this.backBufferWidth  = backBufferDesc.Width;
            this.backBufferHeight = backBufferDesc.Height;

            if (this.d3dSampleDesc.Count > 1)
            {
                D3D11Texture2DDesc desc = new D3D11Texture2DDesc(
                    DxgiFormat.B8G8R8A8UNorm,
                    this.backBufferWidth,
                    this.backBufferHeight,
                    1,
                    1,
                    D3D11BindOptions.RenderTarget,
                    D3D11Usage.Default,
                    D3D11CpuAccessOptions.None,
                    this.d3dSampleDesc.Count,
                    this.d3dSampleDesc.Quality,
                    D3D11ResourceMiscOptions.None);

                this.offscreenBuffer = this.D3DDevice.CreateTexture2D(desc);
            }

            if (this.d3dSampleDesc.Count > 1)
            {
                D3D11RenderTargetViewDesc renderTargetViewDesc = new D3D11RenderTargetViewDesc(D3D11RtvDimension.Texture2DMs);

                this.d3dRenderTargetView = this.d3dDevice.CreateRenderTargetView(this.offscreenBuffer, renderTargetViewDesc);
            }
            else
            {
                D3D11RenderTargetViewDesc renderTargetViewDesc = new D3D11RenderTargetViewDesc(D3D11RtvDimension.Texture2D);

                this.d3dRenderTargetView = this.d3dDevice.CreateRenderTargetView(this.backBuffer, renderTargetViewDesc);
            }

            D3D11Texture2DDesc depthStencilDesc = new D3D11Texture2DDesc
            {
                Width            = this.backBufferWidth,
                Height           = this.backBufferHeight,
                MipLevels        = 1,
                ArraySize        = 1,
                Format           = DxgiFormat.D24UNormS8UInt,
                SampleDesc       = this.d3dSampleDesc,
                Usage            = D3D11Usage.Default,
                BindOptions      = D3D11BindOptions.DepthStencil,
                CpuAccessOptions = D3D11CpuAccessOptions.None,
                MiscOptions      = D3D11ResourceMiscOptions.None
            };

            using (var depthStencil = this.d3dDevice.CreateTexture2D(depthStencilDesc))
            {
                D3D11DepthStencilViewDesc depthStencilViewDesc = new D3D11DepthStencilViewDesc(this.d3dSampleDesc.Count > 1 ? D3D11DsvDimension.Texture2DMs : D3D11DsvDimension.Texture2D);

                this.d3dDepthStencilView = this.d3dDevice.CreateDepthStencilView(depthStencil, depthStencilViewDesc);
            }

            this.screenViewport = new D3D11Viewport
            {
                TopLeftX = 0,
                TopLeftY = 0,
                Width    = this.backBufferWidth,
                Height   = this.backBufferHeight,
                MinDepth = 0.0f,
                MaxDepth = 1.0f
            };

            this.d3dContext.RasterizerStageSetViewports(new[] { this.screenViewport });

            using (var surface = new DxgiSurface2(this.d3dSampleDesc.Count > 1 ? this.offscreenBuffer.Handle : this.backBuffer.Handle))
            {
                float dpiX;
                float dpiY;
                this.d2dFactory.GetDesktopDpi(out dpiX, out dpiY);

                var properties = new D2D1RenderTargetProperties(
                    D2D1RenderTargetType.Default,
                    new D2D1PixelFormat(DxgiFormat.B8G8R8A8UNorm, D2D1AlphaMode.Premultiplied),
                    dpiX,
                    dpiY,
                    D2D1RenderTargetUsages.None,
                    D2D1FeatureLevel.Default);

                this.d2dRenderTarget = this.d2dFactory.CreateDxgiSurfaceRenderTarget(surface, properties);
            }

            this.d2dRenderTarget.AntialiasMode     = D2D1AntialiasMode.PerPrimitive;
            this.d2dRenderTarget.TextAntialiasMode = D2D1TextAntialiasMode.Grayscale;

            D3D11RasterizerDesc rasterizerStateDesc = new D3D11RasterizerDesc(D3D11FillMode.Solid, D3D11CullMode.Back, false, 0, 0.0f, 0.0f, true, false, true, false);

            using (var rasterizerState = this.d3dDevice.CreateRasterizerState(rasterizerStateDesc))
            {
                this.d3dContext.RasterizerStageSetState(rasterizerState);
            }
        }
Пример #4
0
        private void RenderShadowMap(out XMFloat4X4 mViewProjLight, out XMFloat3 vLightDir)
        {
            var context = this.deviceResources.D3DContext;

            D3D11Rect[]     oldRects = context.RasterizerStageGetScissorRects();
            D3D11Viewport[] oldVp    = context.RasterizerStageGetViewports();

            D3D11Rect[] rects = new D3D11Rect[1] {
                new D3D11Rect(0, (int)g_fShadowMapWidth, 0, (int)g_fShadowMapHeight)
            };
            context.RasterizerStageSetScissorRects(rects);

            D3D11Viewport[] vp = new D3D11Viewport[1] {
                new D3D11Viewport(0, 0, g_fShadowMapWidth, g_fShadowMapHeight, 0.0f, 1.0f)
            };
            context.RasterizerStageSetViewports(vp);

            // Set our scene render target & keep original depth buffer
            D3D11RenderTargetView[] pRTVs = new D3D11RenderTargetView[2];
            context.OutputMergerSetRenderTargets(pRTVs, this.g_pDepthStencilTextureDSV);

            // Clear the render target
            context.ClearDepthStencilView(this.g_pDepthStencilTextureDSV, D3D11ClearOptions.Depth | D3D11ClearOptions.Stencil, 1.0f, 0);

            // Get the projection & view matrix from the camera class
            XMFloat3 up           = new XMFloat3(0, 1, 0);
            XMFloat4 vLight       = new XMFloat4(0.0f, 0.0f, 0.0f, 1.0f);
            XMFloat4 vLightLookAt = new XMFloat4(0.0f, -0.5f, 1.0f, 0.0f);

            vLightLookAt = vLight.ToVector() + vLightLookAt.ToVector();
            vLight       = XMVector4.Transform(vLight, this.LightWorldMatrix);
            vLightLookAt = XMVector4.Transform(vLightLookAt, this.LightWorldMatrix);

            vLightDir = XMVector.Subtract(vLightLookAt, vLight);

            XMMatrix mProj = XMMatrix.OrthographicOffCenterLH(-8.5f, 9, -15, 11, -20, 20);
            XMMatrix mView = XMMatrix.LookAtLH(vLight, vLightLookAt, up);

            mViewProjLight = mView * mProj;

            // Setup the constant buffer for the scene vertex shader
            ConstantBufferConstants pConstants = new ConstantBufferConstants
            {
                WorldViewProjection = mViewProjLight.ToMatrix().Transpose(),
                WorldViewProjLight  = mViewProjLight.ToMatrix().Transpose(),
                ShadowMapDimensions = new XMFloat4(
                    g_fShadowMapWidth,
                    g_fShadowMapHeight,
                    1.0f / g_fShadowMapWidth,
                    1.0f / g_fShadowMapHeight),
                LightDir = new XMFloat4(vLightDir.X, vLightDir.Y, vLightDir.Z, 0.0f),
                SunWidth = this.SunWidth
            };

            context.UpdateSubresource(this.g_pcbConstants, 0, null, pConstants, 0, 0);
            context.VertexShaderSetConstantBuffers(g_iConstantsConstantBufferBind, new[] { this.g_pcbConstants });
            context.PixelShaderSetConstantBuffers(g_iConstantsConstantBufferBind, new[] { this.g_pcbConstants });

            // Set the shaders
            context.VertexShaderSetShader(this.g_pShadowMapVS, null);
            context.PixelShaderSetShader(null, null);

            // Set the vertex buffer format
            context.InputAssemblerSetInputLayout(this.g_pSceneVertexLayout);

            // Render the scene
            this.g_Poles.Render(0, -1, -1);

            // reset the old viewport etc.
            context.RasterizerStageSetScissorRects(oldRects);
            context.RasterizerStageSetViewports(oldVp);
        }