protected override void InitializeService()
        {
            //  Listen to changes in light count
            sceneManager.LightCountSet += new SceneManager.LightCountSetDelegate(SetLightCount);

            ShadowBlendState    = BlendState.Default;
            ShadowFaceCullState = FaceCullState.Default;
            ShadowDepthState    = DepthState.Default;

            quadRenderer       = new QuadRenderer(renderer);
            visualizeShadowMap = renderer.Programs["VisualizeShadowMap"];

            if (example.Renderer.Configuration.hardwareShadowPCF)
            {
                materialManager.MakeMaterial("Shadow", "ShadowCaster2");
            }
            else
            {
                materialManager.MakeMaterial("Shadow", "ShadowCaster");
            }

            {
                var m = materialManager.MakeMaterial("VisualizeShadowMap");
                m.DepthState    = DepthState.Disabled;
                m.FaceCullState = FaceCullState.Disabled;
            }

            renderer.Resize += new EventHandler <EventArgs>(renderer_Resize);
        }
Exemple #2
0
 public static void Set(DepthState depthState)
 {
     if (Current != depthState)
     {
         Graphics.State.OnStateChanging?.Invoke();
         Graphics.SetDepth(depthState);
         Current = depthState;
         Graphics.State.OnStateChanged?.Invoke();
     }
 }
Exemple #3
0
        internal override void SetDepth(DepthState depthState)
        {
            if (depthState.Enabled)
            {
                GL.Enable(EnableCap.DepthTest);
            }
            else
            {
                GL.Disable(EnableCap.DepthTest);
            }

            GL.DepthFunc(depthState.DepthFunction.ToOpenGL());
        }
Exemple #4
0
        internal override void SetDepth(DepthState depthState)
        {
            if (depthState.Enabled)
            {
                GL.enable(DEPTH_TEST);
            }
            else
            {
                GL.disable(DEPTH_TEST);
            }

            GL.depthFunc(depthState.DepthFunction.ToWebGL2());
        }
        public void Begin()
        {
            // Save old state
            _oldDepthState         = _device.DepthState;
            _oldFaceCullingEnabled = _device.FaceCullingEnabled;
            _oldBlendState         = _device.BlendState;

            // Set new state
            _device.DepthState         = DepthState.None;
            _device.FaceCullingEnabled = false;
            _device.BlendState         = BlendState.AlphaBlend;

            _batch.Begin();
        }
        private void OnApplyButtonClicked()
        {
            ConfigureDepth(_enableDepthToggle.isOn);
            if (_depthMapToggle.isOn)
            {
                _depthState = DepthState.DepthMap;
                _debugVisualizer.SetActive(true);
            }
            else
            {
                _debugVisualizer.SetActive(false);
            }

            _planeDiscoveryGuide.EnablePlaneDiscoveryGuide(true);
        }
        private void _OnApplyButtonClicked()
        {
            _ConfigureDepth(m_EnableDepthToggle.isOn);
            if (m_DepthMapToggle.isOn)
            {
                m_DepthState = DepthState.DepthMap;
                m_DebugVisualizer.SetActive(true);
            }
            else
            {
                m_DebugVisualizer.SetActive(false);
            }

            m_MenuWindow.SetActive(false);
            m_PlaneDiscoveryGuide.EnablePlaneDiscoveryGuide(true);
        }
            public bool Compatible(DepthState other)
            {
                if (Enabled != other.Enabled)
                {
                    return(false);
                }
                if (EdramBase != other.EdramBase)
                {
                    return(false);
                }
                if (Format != other.Format)
                {
                    return(false);
                }

                return(true);
            }
Exemple #9
0
        public void Begin(Matrix3x2?transform, TextureFiltering textureFiltering)
        {
            // Save old state
            _oldDepthState         = _device.DepthState;
            _oldFaceCullingEnabled = _device.FaceCullingEnabled;
            _oldBlendState         = _device.BlendState;
            _oldScissorEnabled     = _device.ScissorTestEnabled;

            // Set new state
            _device.DepthState         = DepthState.None;
            _device.FaceCullingEnabled = false;
            _device.BlendState         = BlendState.AlphaBlend;
            _device.ScissorTestEnabled = true;

            _batch.Begin();

            _beginCalled = true;
            _transform   = transform;
            _filtering   = textureFiltering;
        }
        /// <summary>
        /// Show Depth Card window when first asset placed and device supports depth.
        /// </summary>
        public void ConfigureDepthBeforePlacingFirstAsset()
        {
            if (!_depthConfigured)
            {
                // Session might not be initialized when GameOject is inializing.
                // Hence, it would be better NOT to call `IsDepthModeSupported` in start().
                if (Session.IsDepthModeSupported(DepthMode.Automatic))
                {
                    _depthState    = DepthState.DepthDisabled;
                    _menuText.text = "Your device supports depth.";
                    _depthCardWindow.SetActive(true);
                    _planeDiscoveryGuide.EnablePlaneDiscoveryGuide(false);
                }
                else
                {
                    _depthState    = DepthState.DepthNotAvailable;
                    _menuText.text = "Your device doesn't support depth.";
                }

                _depthConfigured = true;
            }
        }
Exemple #11
0
        public bool Equals(GLCmdBufferPipelineItem other)
        {
//			if (!Pipeline.Equals (other.Pipeline))
//				return false;
//
//			if (!Pass.Equals (other.Pass))
//				return false;

            if (!Flags.Equals(other.Flags))
            {
                return(false);
            }

            if (!DepthState.Equals(other.DepthState))
            {
                return(false);
            }

            if (!StencilState.Equals(other.StencilState))
            {
                return(false);
            }

//			if (!Rasterization.Equals (other.Rasterization))
//				return false;

            if (!ColorBlendEnums.Equals(other.ColorBlendEnums))
            {
                return(false);
            }

            if (!ClearValues.Equals(other.ClearValues))
            {
                return(false);
            }

            return(true);
        }
        public void Render()
        {
            Framebuffer.Execute();
            Viewport.Execute();
            BlendState.Execute();
            FaceCullState.Execute();
            MaskState.Execute();
            DepthState.Execute();
            StencilState.Execute();
            Clear.Execute();
            camera.UpdateFrame();
            camera.UpdateViewport(Viewport.Viewport);
            foreach (var item in renderItems)
            {
#if false
                if (item.Model.Frame != frame)
                {
                    camera.UpdateModelFrame(frame);
                }
#endif
                //item.Batch.Mesh.ApplyAttributes(
            }
        }
        /// <summary>
        /// Callback event when the depth menu button is clicked.
        /// </summary>
        public void OnMenuButtonClicked()
        {
            if (!_depthConfigured)
            {
                // Session might not be initialized when GameOject is inializing.
                // Hence, it would be better NOT to call `IsDepthModeSupported` in start().
                if (Session.IsDepthModeSupported(DepthMode.Automatic))
                {
                    _depthState    = DepthState.DepthDisabled;
                    _menuText.text = "Your device supports depth.";
                }
                else
                {
                    ConfigureDepth(false);
                    _depthState    = DepthState.DepthNotAvailable;
                    _menuText.text = "Your device doesn't support depth.";
                }

                _depthConfigured = true;
                ApplyDepthState();
            }

            _planeDiscoveryGuide.EnablePlaneDiscoveryGuide(false);
        }
Exemple #14
0
        private void _OnMenuButtonClicked()
        {
            if (!m_DepthConfigured)
            {
                // Session might not be initialized when GameOject is inializing.
                // Hence, it would be better NOT to call `IsDepthModeSupported` in start().
                if (Session.IsDepthModeSupported(DepthMode.Automatic))
                {
                    m_DepthState    = DepthState.DepthDisabled;
                    m_MenuText.text = "Your device supports depth.";
                }
                else
                {
                    _ConfigureDepth(false);
                    m_DepthState    = DepthState.DepthNotAvailable;
                    m_MenuText.text = "Your device doesn't support depth.";
                }

                _ResetToggle();
            }

            m_MenuWindow.SetActive(true);
            m_PlaneDiscoveryGuide.EnablePlaneDiscoveryGuide(false);
        }
Exemple #15
0
 public void SetDepthState(DepthState state)
 {
     depthState      = state;
     depthStateDirty = true;
 }
Exemple #16
0
        public static void Initialize(GxContext context)
        {
            gGraphics = System.Drawing.Graphics.FromImage(Bitmap);

            gSampler = new Sampler(context)
            {
                AddressU = SharpDX.Direct3D11.TextureAddressMode.Wrap,
                AddressV = SharpDX.Direct3D11.TextureAddressMode.Wrap,
                AddressW = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                Filter   = Filter.MinMagMipLinear
            };

            gSampler2D = new Sampler(context)
            {
                AddressU = SharpDX.Direct3D11.TextureAddressMode.Wrap,
                AddressV = SharpDX.Direct3D11.TextureAddressMode.Wrap,
                AddressW = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                Filter   = Filter.MinMagMipPoint
            };

            gBlendState = new Graphics.BlendState(context)
            {
                BlendEnabled          = true,
                SourceBlend           = BlendOption.SourceAlpha,
                DestinationBlend      = BlendOption.InverseSourceAlpha,
                SourceAlphaBlend      = BlendOption.SourceAlpha,
                DestinationAlphaBlend = BlendOption.InverseSourceAlpha
            };

            gRasterState = new RasterState(context)
            {
                CullEnabled = false
            };

            gDepthState = new DepthState(context)
            {
                DepthEnabled      = true,
                DepthWriteEnabled = false
            };

            gNoDepthState = new DepthState(context)
            {
                DepthEnabled      = false,
                DepthWriteEnabled = false
            };

            gVertexBuffer = new VertexBuffer(context);

            gMesh = new Mesh(context)
            {
                Stride = IO.SizeCache <WorldTextVertex> .Size
            };

            gMesh.DepthState.Dispose();
            gMesh.BlendState.Dispose();
            gMesh.IndexBuffer.Dispose();
            gMesh.VertexBuffer.Dispose();

            gMesh.RasterizerState = gRasterState;
            gMesh.BlendState      = gBlendState;
            gMesh.VertexBuffer    = gVertexBuffer;
            gMesh.DepthState      = gDepthState;

            gMesh.AddElement("POSITION", 0, 3);
            gMesh.AddElement("TEXCOORD", 0, 2);

            gWorldTextShader = new ShaderProgram(context);
            gWorldTextShader.SetVertexShader(Resources.Shaders.WorldTextVertex);
            gWorldTextShader.SetPixelShader(Resources.Shaders.WorldTextPixel);

            gWorldTextShader2D = new ShaderProgram(context);
            gWorldTextShader2D.SetVertexShader(Resources.Shaders.WorldTextVertexOrtho);
            gWorldTextShader2D.SetPixelShader(Resources.Shaders.WorldTextPixel);
            gMesh.Program = gWorldTextShader;
            gMesh.InitLayout(gWorldTextShader);

            gPerDrawCallBuffer = new ConstantBuffer(context);
            gPerDrawCallBuffer.UpdateData(new PerDrawCallBuffer
            {
                matTransform = Matrix.Identity
            });
        }
        protected override void InitializeService()
        {
            models          = new HashSet<Model>();
            polygonIds      = new HashSet<uint>();
            readonlyModels  = new ReadOnlyHashSet<Model>(models);
            //selectionMesh   = new GeometryMesh();

            silhouetteHidden    = new Material("silhouetteHidden",  renderer.Programs["FatTriangle"], renderer.MaterialUB);
            silhouetteVisible   = new Material("silhouetteVisible", renderer.Programs["FatTriangle"], renderer.MaterialUB);
            edgeLinesSelected   = new Material("edgeLinesSelected", renderer.Programs["WideLineUniformColor"], renderer.MaterialUB);
            edgeLinesHidden     = new Material("edgeLinesHidden",   renderer.Programs["WideLineUniformColor"], renderer.MaterialUB);
            cornerPoints        = new Material("cornerPoints",      renderer.Programs["ColorFill"], renderer.MaterialUB);
            polygonCentroids    = new Material("polygonCentroids",  renderer.Programs["ColorFill"], renderer.MaterialUB);
            stencilMaskWrite    = new Material("stencilMaskWrite",  renderer.Programs["ColorFill"], renderer.MaterialUB);

            if(RenderStack.Graphics.Configuration.canUseGeometryShaders == false)
            {
                silhouetteHidden.MeshMode   = MeshMode.EdgeLines;
                silhouetteVisible.MeshMode  = MeshMode.EdgeLines;
            }

            var greaterDepthState = new DepthState();
            greaterDepthState.Enabled = true;
            greaterDepthState.Function = DepthFunction.Greater;

            float lineWidth = 2.0f;
            edgeLinesSelected.MeshMode  = MeshMode.EdgeLines;
            edgeLinesSelected.Floats("line_width").Set(lineWidth, lineWidth * lineWidth * 0.25f);
            edgeLinesSelected.Floats("line_color").Set(0.0f, 0.0f, 1.0f, 1.0f);
            edgeLinesSelected.Sync();

            lineWidth = 1.0f;
            edgeLinesHidden.MeshMode        = MeshMode.EdgeLines;
            edgeLinesHidden.DepthState      = greaterDepthState;
            edgeLinesHidden.MaskState       = new MaskState();
            edgeLinesHidden.MaskState.Red   = true;
            edgeLinesHidden.MaskState.Green = true;
            edgeLinesHidden.MaskState.Blue  = true;
            edgeLinesHidden.MaskState.Alpha = true;
            edgeLinesHidden.MaskState.Depth = false;
            edgeLinesHidden.Floats("line_width").Set(lineWidth, lineWidth * lineWidth * 0.25f);
            edgeLinesHidden.Floats("line_color").Set(0.0f, 0.0f, 0.5f, 1.0f);
            edgeLinesHidden.Sync();

            lineWidth = 6.0f;
            silhouetteHidden.DepthState = greaterDepthState;
            silhouetteHidden.MaskState = new MaskState();
            silhouetteHidden.MaskState.Depth = false;
            silhouetteHidden.Floats("line_width").Set(lineWidth, lineWidth * lineWidth * 0.25f);
            silhouetteHidden.Floats("line_color").Set(0.4f, 0.6f, 0.8f, 1.0f);

            //  StencilState to fail if stencil != 0, no writes
            silhouetteHidden.StencilState                       = new StencilState();
            silhouetteHidden.StencilState.Enabled               = true;
            silhouetteHidden.StencilState.Front.Function        = StencilFunction.Equal;
            silhouetteHidden.StencilState.Front.Reference       = 0;
            silhouetteHidden.StencilState.Front.TestMask        = 0xffff;
            silhouetteHidden.StencilState.Front.WriteMask       = 0xffff;
            silhouetteHidden.StencilState.Front.StencilFailOp   = StencilOp.Keep;
            silhouetteHidden.StencilState.Front.ZFailOp         = StencilOp.Keep;
            silhouetteHidden.StencilState.Front.ZPassOp         = StencilOp.Keep;

            silhouetteHidden.Sync();

            silhouetteVisible.MaskState = silhouetteHidden.MaskState;
            silhouetteVisible.StencilState = silhouetteHidden.StencilState;
            lineWidth = 6.0f;
            silhouetteVisible.Floats("line_width").Set(lineWidth, lineWidth * lineWidth * 0.25f);
            silhouetteVisible.Floats("line_color").Set(0.9f, 0.9f, 1.0f, 1.0f);
            silhouetteVisible.Sync();
            
            cornerPoints.Floats("point_color").Set(1.0f, 0.0f, 0.0f, 1.0f);
            cornerPoints.Sync();
            
            polygonCentroids.Floats("point_color").Set(0.5f, 0.0f, 1.0f, 1.0f);
            polygonCentroids.Sync();

            //  No depth test; Do not write to color or depth; Only write to stencil
            stencilMaskWrite.DepthState        = DepthState.Disabled;
            stencilMaskWrite.MaskState         = new MaskState();
            stencilMaskWrite.MaskState.Red     = false;
            stencilMaskWrite.MaskState.Green   = false;
            stencilMaskWrite.MaskState.Blue    = false;
            stencilMaskWrite.MaskState.Alpha   = false;
            stencilMaskWrite.MaskState.Depth   = false;

            //  StencilState to write 1 to stencil, always
            stencilMaskWrite.StencilState                       = new StencilState();
            stencilMaskWrite.StencilState.Enabled               = true;
            stencilMaskWrite.StencilState.Front.StencilFailOp   = StencilOp.Replace;
            stencilMaskWrite.StencilState.Front.ZFailOp         = StencilOp.Replace;
            stencilMaskWrite.StencilState.Front.ZPassOp         = StencilOp.Replace;
            stencilMaskWrite.StencilState.Front.Function        = StencilFunction.Always;
            stencilMaskWrite.StencilState.Front.Reference       = 1;
            stencilMaskWrite.StencilState.Front.TestMask        = 0xffff;
            stencilMaskWrite.StencilState.Front.WriteMask       = 0xffff;

            sphereMesh = new GeometryMesh(
                new RenderStack.Geometry.Shapes.Sphere(1.0f, 20, 12),
                NormalStyle.PointNormals
            );
        }
Exemple #18
0
 public bool Equals(DepthState depth)
 {
     return(this == depth);
 }
Exemple #19
0
 public static void SetDefault(DepthState depthState) => Default = depthState;
Exemple #20
0
        public static void Initialize(GxContext context)
        {
            gDepthWriteState = new DepthState(context)
            {
                DepthEnabled      = true,
                DepthWriteEnabled = true
            };

            gDepthNoWriteState = new DepthState(context)
            {
                DepthEnabled      = true,
                DepthWriteEnabled = false
            };

            gMesh = new Mesh(context)
            {
                Stride     = IO.SizeCache <M2Vertex> .Size,
                DepthState = gDepthNoWriteState
            };

            gMesh.BlendState.Dispose();
            gMesh.IndexBuffer.Dispose();
            gMesh.VertexBuffer.Dispose();

            gMesh.BlendState   = null;
            gMesh.IndexBuffer  = null;
            gMesh.VertexBuffer = null;

            gMesh.AddElement("POSITION", 0, 3);
            gMesh.AddElement("BLENDWEIGHT", 0, 4, DataType.Byte, true);
            gMesh.AddElement("BLENDINDEX", 0, 4, DataType.Byte);
            gMesh.AddElement("NORMAL", 0, 3);
            gMesh.AddElement("TEXCOORD", 0, 2);
            gMesh.AddElement("TEXCOORD", 1, 2);

            // all combinations are set in this one each time
            gCustomProgram = new ShaderProgram(context);
            gCustomProgram.SetVertexShader(Resources.Shaders.M2VertexSingle_VS_Diffuse_T1);
            gCustomProgram.SetPixelShader(Resources.Shaders.M2Pixel_PS_Combiners_Mod);

            gMesh.Program = gCustomProgram;

            gNoBlendProgram = new ShaderProgram(context);
            gNoBlendProgram.SetPixelShader(Resources.Shaders.M2PixelOld);
            gNoBlendProgram.SetVertexShader(Resources.Shaders.M2VertexSingleOld);

            gBlendProgram = new ShaderProgram(context);
            gBlendProgram.SetPixelShader(Resources.Shaders.M2PixelBlendOld);
            gBlendProgram.SetVertexShader(Resources.Shaders.M2VertexSingleOld);

            gBlendTestProgram = new ShaderProgram(context);
            gBlendTestProgram.SetPixelShader(Resources.Shaders.M2PixelBlendAlphaOld);
            gBlendTestProgram.SetVertexShader(Resources.Shaders.M2VertexSingleOld);

            g2PassProgram = new ShaderProgram(context);
            g2PassProgram.SetPixelShader(Resources.Shaders.M2Pixel2PassOld);
            g2PassProgram.SetVertexShader(Resources.Shaders.M2VertexSingleOld);

            g3PassProgram = new ShaderProgram(context);
            g3PassProgram.SetPixelShader(Resources.Shaders.M2Pixel3PassOld);
            g3PassProgram.SetVertexShader(Resources.Shaders.M2VertexSingleOld);

            gPerDrawCallBuffer = new ConstantBuffer(context);
            gPerDrawCallBuffer.UpdateData(new PerDrawCallBuffer()
            {
                instanceMat = Matrix.Identity
            });

            gPerPassBuffer = new ConstantBuffer(context);

            gPerPassBuffer.UpdateData(new PerModelPassBuffer()
            {
                uvAnimMatrix1   = Matrix.Identity,
                uvAnimMatrix2   = Matrix.Identity,
                uvAnimMatrix3   = Matrix.Identity,
                uvAnimMatrix4   = Matrix.Identity,
                modelPassParams = Vector4.Zero
            });

            gSamplerWrapU = new Sampler(context)
            {
                AddressU          = SharpDX.Direct3D11.TextureAddressMode.Wrap,
                AddressV          = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                AddressW          = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                Filter            = SharpDX.Direct3D11.Filter.Anisotropic,
                MaximumAnisotropy = 16
            };

            gSamplerWrapV = new Sampler(context)
            {
                AddressU          = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                AddressV          = SharpDX.Direct3D11.TextureAddressMode.Wrap,
                AddressW          = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                Filter            = SharpDX.Direct3D11.Filter.Anisotropic,
                MaximumAnisotropy = 16
            };

            gSamplerWrapBoth = new Sampler(context)
            {
                AddressU          = SharpDX.Direct3D11.TextureAddressMode.Wrap,
                AddressV          = SharpDX.Direct3D11.TextureAddressMode.Wrap,
                AddressW          = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                Filter            = SharpDX.Direct3D11.Filter.Anisotropic,
                MaximumAnisotropy = 16
            };

            gSamplerClampBoth = new Sampler(context)
            {
                AddressU          = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                AddressV          = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                AddressW          = SharpDX.Direct3D11.TextureAddressMode.Clamp,
                Filter            = SharpDX.Direct3D11.Filter.Anisotropic,
                MaximumAnisotropy = 16
            };

            for (var i = 0; i < BlendStates.Length; ++i)
            {
                BlendStates[i] = new BlendState(context);
            }

            BlendStates[0] = new BlendState(context)
            {
                BlendEnabled = false
            };

            BlendStates[1] = new BlendState(context)
            {
                BlendEnabled          = true,
                SourceBlend           = SharpDX.Direct3D11.BlendOption.One,
                DestinationBlend      = SharpDX.Direct3D11.BlendOption.Zero,
                SourceAlphaBlend      = SharpDX.Direct3D11.BlendOption.One,
                DestinationAlphaBlend = SharpDX.Direct3D11.BlendOption.Zero
            };

            BlendStates[2] = new BlendState(context)
            {
                BlendEnabled          = true,
                SourceBlend           = SharpDX.Direct3D11.BlendOption.SourceAlpha,
                DestinationBlend      = SharpDX.Direct3D11.BlendOption.InverseSourceAlpha,
                SourceAlphaBlend      = SharpDX.Direct3D11.BlendOption.SourceAlpha,
                DestinationAlphaBlend = SharpDX.Direct3D11.BlendOption.InverseSourceAlpha
            };

            BlendStates[3] = new BlendState(context)
            {
                BlendEnabled          = true,
                SourceBlend           = SharpDX.Direct3D11.BlendOption.SourceColor,
                DestinationBlend      = SharpDX.Direct3D11.BlendOption.DestinationColor,
                SourceAlphaBlend      = SharpDX.Direct3D11.BlendOption.SourceAlpha,
                DestinationAlphaBlend = SharpDX.Direct3D11.BlendOption.DestinationAlpha
            };

            BlendStates[4] = new BlendState(context)
            {
                BlendEnabled          = true,
                SourceBlend           = SharpDX.Direct3D11.BlendOption.SourceAlpha,
                DestinationBlend      = SharpDX.Direct3D11.BlendOption.One,
                SourceAlphaBlend      = SharpDX.Direct3D11.BlendOption.SourceAlpha,
                DestinationAlphaBlend = SharpDX.Direct3D11.BlendOption.One
            };

            BlendStates[5] = new BlendState(context)
            {
                BlendEnabled          = true,
                SourceBlend           = SharpDX.Direct3D11.BlendOption.SourceAlpha,
                DestinationBlend      = SharpDX.Direct3D11.BlendOption.InverseSourceAlpha,
                SourceAlphaBlend      = SharpDX.Direct3D11.BlendOption.SourceAlpha,
                DestinationAlphaBlend = SharpDX.Direct3D11.BlendOption.InverseSourceAlpha
            };

            BlendStates[6] = new BlendState(context)
            {
                BlendEnabled          = true,
                SourceBlend           = SharpDX.Direct3D11.BlendOption.DestinationColor,
                DestinationBlend      = SharpDX.Direct3D11.BlendOption.SourceColor,
                SourceAlphaBlend      = SharpDX.Direct3D11.BlendOption.DestinationAlpha,
                DestinationAlphaBlend = SharpDX.Direct3D11.BlendOption.SourceAlpha
            };

            gNoCullState = new RasterState(context)
            {
                CullEnabled = false
            };
            gCullState = new RasterState(context)
            {
                CullEnabled = true
            };
        }
Exemple #21
0
 internal abstract void SetDepth(DepthState depthState);
Exemple #22
0
 private void _ConfigureDepth(bool depthEnabled)
 {
     (m_Camera.GetComponent(typeof(DepthEffect)) as MonoBehaviour).enabled = depthEnabled;
     m_DepthConfigured = true;
     m_DepthState      = depthEnabled ? DepthState.DepthEnabled : DepthState.DepthDisabled;
 }
        public GPUStateRenderTargets(GPUStateCapture state)
        {
            var regModeControl    = state.Reg(GPURegisterName.RB_MODECONTROL);
            var regSurfaceInfo    = state.Reg(GPURegisterName.RB_SURFACE_INFO);
            var regColor0Info     = state.Reg(GPURegisterName.RB_COLOR_INFO);
            var regColor1Info     = state.Reg(GPURegisterName.RB_COLOR1_INFO);
            var regColor2Info     = state.Reg(GPURegisterName.RB_COLOR2_INFO);
            var regColor3Info     = state.Reg(GPURegisterName.RB_COLOR3_INFO);
            var regColorMask      = state.Reg(GPURegisterName.RB_COLOR_MASK);
            var regDepthInfo      = state.Reg(GPURegisterName.RB_DEPTH_INFO);
            var regDepthControl   = state.Reg(GPURegisterName.RB_DEPTHCONTROL);
            var regStencilRefMask = state.Reg(GPURegisterName.RB_STENCILREFMASK);

            // read standard stuff
            MSAA         = (GPUMsaaSamples)((regSurfaceInfo >> 16) & 3);
            SurfacePitch = regSurfaceInfo & 0x3FFF;

            // reset color/depth state
            Color = new ColorState[4];
            Depth = new DepthState();

            // read surface settings
            var enableMode = (GPUModeControl)(regModeControl & 0x7);

            if (enableMode == GPUModeControl.ColorDepth)
            {
                UInt32[] regColor = { regColor0Info, regColor1Info, regColor2Info, regColor3Info };

                for (int rtIndex = 0; rtIndex < 4; ++rtIndex)
                {
                    var rtInfo = regColor[rtIndex];

                    // get color mask for this specific render target
                    var writeMask = (regColorMask >> (rtIndex * 4)) & 0xF;
                    if (writeMask != 0)
                    {
                        ColorState colorInfo = new ColorState();
                        colorInfo.WriteRed   = (writeMask & 1) != 0;
                        colorInfo.WriteGreen = (writeMask & 2) != 0;
                        colorInfo.WriteBlue  = (writeMask & 4) != 0;
                        colorInfo.WriteAlpha = (writeMask & 8) != 0;
                        colorInfo.Enabled    = true;
                        colorInfo.EdramBase  = (rtInfo & 0xFFF); // tile address
                        colorInfo.Format     = (GPUColorRenderTargetFormat)((rtInfo >> 16) & 0xF);
                        Color[rtIndex]       = colorInfo;
                    }
                }
            }

            // depth
            {
                var usesDepth        = (0 != (regDepthControl & 0x00000002)) || (0 != (regDepthControl & 0x00000004));
                var stencilWriteMask = (regStencilRefMask & 0x00FF0000) >> 16;
                var usesStencil      = (0 != (regDepthControl & 0x00000001)) || (stencilWriteMask != 0);

                if (usesDepth || usesStencil)
                {
                    DepthState depthState = new DepthState();
                    depthState.Enabled   = true;
                    depthState.EdramBase = (regDepthInfo & 0xFFF);
                    depthState.Format    = (GPUDepthRenderTargetFormat)((regDepthInfo >> 16) & 1);
                    Depth = depthState;
                }
            }
        }
 private void ConfigureDepth(bool depthEnabled)
 {
     (_camera.GetComponent(typeof(DepthEffect)) as MonoBehaviour).enabled = depthEnabled;
     _depthState = depthEnabled ? DepthState.DepthEnabled : DepthState.DepthDisabled;
 }
    // Main entry point for our scriptable render loop
    public static void Render(ScriptableRenderContext context, IEnumerable <Camera> cameras)
    {
        bool stereoEnabled = XRSettings.isDeviceActive;

        foreach (Camera camera in cameras)
        {
            // Culling
            ScriptableCullingParameters cullingParams;

            // Stereo-aware culling parameters are configured to perform a single cull for both eyes
            if (!CullResults.GetCullingParameters(camera, stereoEnabled, out cullingParams))
            {
                continue;
            }
            CullResults cull = new CullResults();
            CullResults.Cull(ref cullingParams, context, ref cull);

            // Setup camera for rendering (sets render target, view/projection matrices and other
            // per-camera built-in shader variables).
            // If stereo is enabled, we also configure stereo matrices, viewports, and XR device render targets
            context.SetupCameraProperties(camera, stereoEnabled);

            // Draws in-between [Start|Stop]MultiEye are stereo-ized by engine
            if (stereoEnabled)
            {
                context.StartMultiEye(camera);
            }

            // clear depth buffer
            CommandBuffer cmd = new CommandBuffer();
            cmd.ClearRenderTarget(true, false, Color.black);
            context.ExecuteCommandBuffer(cmd);
            cmd.Release();

            // Setup global lighting shader variables
            SetupLightShaderVariables(cull.visibleLights, context);

            // Draw skybox
            context.DrawSkybox(camera);

            // Setup DrawSettings and FilterSettings
            ShaderPassName          passName       = new ShaderPassName("BasicPass");
            DrawRendererSettings    drawSettings   = new DrawRendererSettings(camera, passName);
            FilterRenderersSettings filterSettings = new FilterRenderersSettings(true);

            //*************************************************************
            // Block
            RenderStateBlock rsb = new RenderStateBlock(RenderStateMask.Depth | RenderStateMask.Blend | RenderStateMask.Raster | RenderStateMask.Stencil);

            DepthState ds = rsb.depthState;//
            ds.writeEnabled    = true;
            ds.compareFunction = CompareFunction.LessEqual;
            rsb.depthState     = ds;                     //

            BlendState             bs  = rsb.blendState; //
            RenderTargetBlendState rs0 = bs.blendState0; //
            bs.alphaToMask                = false;
            rs0.sourceColorBlendMode      = BlendMode.SrcAlpha;
            rs0.destinationColorBlendMode = BlendMode.One;
            rs0.colorBlendOperation       = BlendOp.Add;
            rs0.sourceAlphaBlendMode      = BlendMode.Zero;
            rs0.destinationAlphaBlendMode = BlendMode.One;
            rs0.alphaBlendOperation       = BlendOp.Add;
            rs0.writeMask  = ColorWriteMask.All;
            bs.blendState0 = rs0;             //
            rsb.blendState = bs;              //

            RasterState rs = rsb.rasterState; //
            rs.cullingMode  = CullMode.Off;
            rs.depthClip    = false;
            rs.offsetFactor = 0;
            rs.offsetUnits  = 0;
            rsb.rasterState = rs;//


            StencilState ss = rsb.stencilState;//
            rsb.stencilReference    = 0;
            ss.compareFunction      = CompareFunction.Disabled;
            ss.compareFunctionBack  = CompareFunction.Disabled;
            ss.compareFunctionFront = CompareFunction.Disabled;
            ss.failOperation        = StencilOp.Keep;
            ss.failOperationBack    = StencilOp.Keep;
            ss.failOperationFront   = StencilOp.Keep;
            ss.passOperation        = StencilOp.Keep;
            ss.passOperationBack    = StencilOp.Keep;
            ss.passOperationFront   = StencilOp.Keep;
            ss.zFailOperation       = StencilOp.Keep;
            ss.zFailOperationBack   = StencilOp.Keep;
            ss.zFailOperationFront  = StencilOp.Keep;
            ss.readMask             = 255;
            ss.writeMask            = 255;
            ss.enabled       = true;
            rsb.stencilState = ss;//

            //**************************************************************
            //mapping

            RenderStateBlock rsb_opaque = new RenderStateBlock(RenderStateMask.Raster | RenderStateMask.Stencil);
            rsb_opaque.rasterState      = rsb.rasterState;
            rsb_opaque.stencilState     = rsb.stencilState;
            rsb_opaque.stencilReference = rsb.stencilReference;

            RenderStateBlock rsb_trans = new RenderStateBlock(RenderStateMask.Blend);
            rsb_trans.blendState = rsb.blendState;

            RenderStateBlock rsb_over = new RenderStateBlock(RenderStateMask.Raster | RenderStateMask.Depth | RenderStateMask.Stencil);
            rsb_over.depthState       = rsb.depthState;
            rsb_over.rasterState      = rsb.rasterState;
            rsb_over.stencilState     = rsb.stencilState;
            rsb_over.stencilReference = rsb.stencilReference;

            List <RenderStateMapping> rsm = new List <RenderStateMapping>
            {
                new RenderStateMapping("Opaque", rsb_opaque),
                new RenderStateMapping("Transparent", rsb_trans),
                new RenderStateMapping("Overlay", rsb_over)
            };

            //**************************************************************

            // Draw opaque objects using BasicPass shader pass
            filterSettings.layerMask        = LayerMask.GetMask("Default");
            drawSettings.sorting.flags      = SortFlags.CommonOpaque;
            filterSettings.renderQueueRange = RenderQueueRange.opaque;
            context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);

            // WITH RENDERSTATEBLOCK OPAQUE
            filterSettings.layerMask        = LayerMask.GetMask("TransparentFX");
            drawSettings.sorting.flags      = SortFlags.CommonOpaque;
            filterSettings.renderQueueRange = RenderQueueRange.opaque;
            context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsb);

            // WITH RENDERSTATEMAPPING OPAQUE
            filterSettings.layerMask        = LayerMask.GetMask("Ignore Raycast");
            drawSettings.sorting.flags      = SortFlags.CommonOpaque;
            filterSettings.renderQueueRange = RenderQueueRange.opaque;
            context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsm);

            //**************************************************************

            // Draw transparent objects using BasicPass shader pass
            filterSettings.layerMask        = LayerMask.GetMask("Default");
            drawSettings.sorting.flags      = SortFlags.CommonTransparent;
            filterSettings.renderQueueRange = RenderQueueRange.transparent;
            context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings);

            // WITH RENDERSTATEBLOCK TRANSPARENT
            filterSettings.layerMask        = LayerMask.GetMask("TransparentFX");
            drawSettings.sorting.flags      = SortFlags.CommonTransparent;
            filterSettings.renderQueueRange = RenderQueueRange.transparent;
            context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsb);

            // WITH RENDERSTATEMAPPING TRANSPARENT
            filterSettings.layerMask        = LayerMask.GetMask("Ignore Raycast");
            drawSettings.sorting.flags      = SortFlags.CommonTransparent;
            filterSettings.renderQueueRange = RenderQueueRange.transparent;
            context.DrawRenderers(cull.visibleRenderers, ref drawSettings, filterSettings, rsm);

            //**************************************************************

            if (stereoEnabled)
            {
                context.StopMultiEye(camera);
                // StereoEndRender will reset state on the camera to pre-Stereo settings,
                // and invoke XR based events/callbacks.
                context.StereoEndRender(camera);
            }

            context.Submit();
        }
    }