Beispiel #1
0
        public override void Render()
        {
            Framebuffer.BindWithDrawBuffers(Framebuffer);

            GL.Enable(EnableCap.DepthTest);

            var shader = Resources.Find <Shader>("Debug");

            Shader.SetShader(shader);

            //CameraLoop

            /*foreach(var cameraEntity in renderFrame.World.ReadEntities()) {
             *      if(!cameraEntity.Has<Camera>()) {
             *              continue;
             *      }
             *
             *      var camera = cameraEntity.Get<Camera>();
             *      var viewport = GetViewport(camera);
             *
             *      GL.Viewport(viewport.x, viewport.y, viewport.width, viewport.height);
             *
             *      var viewProj = camera.ViewMatrix * camera.ProjectionMatrix;
             *
             *      Shader.UniformMatrix4(shader.GetUniformLocation("viewProj"), ref viewProj);
             *
             *      Debug.FlushRendering();
             * }*/

            Shader.SetShader(null);
            GL.Disable(EnableCap.DepthTest);

            Framebuffer.Bind(null);
        }
Beispiel #2
0
        public override void Render()
        {
            Framebuffer.BindWithDrawBuffers(Framebuffer);

            GL.Enable(EnableCap.CullFace);
            GL.Enable(EnableCap.DepthTest);
            GL.Enable(EnableCap.Blend);
            GL.CullFace(CullFaceMode.Back);

            bool[]    uniformComputed = new bool[DefaultShaderUniforms.Count];
            Matrix4x4 worldMatrix = default, inverseWorldMatrix = default,
Beispiel #3
0
        public override void Render()
        {
            Framebuffer.BindWithDrawBuffers(Framebuffer);

            GL.Enable(EnableCap.Blend);
            GL.DepthMask(false);

            Shader.SetShader(PassShader);

            PassShader.SetupCommonUniforms();

            GL.Viewport(0, 0, Screen.Width, Screen.Height);

            var renderViewData = GlobalGet <RenderViewData>();

            foreach (var renderView in renderViewData.RenderViews)
            {
                var camera    = renderView.camera;
                var transform = renderView.transform;
                var viewport  = GetViewport(camera);

                PassShader.SetupCameraUniforms(camera, transform.Position);

                if (passedTextures != null)
                {
                    for (int j = 0; j < passedTextures.Length; j++)
                    {
                        var texture = passedTextures[j];

                        GL.ActiveTexture((TextureUnit)((int)TextureUnit.Texture0 + j));
                        GL.BindTexture(TextureTarget.Texture2D, texture.Id);

                        if (PassShader != null)
                        {
                            GL.Uniform1(GL.GetUniformLocation(PassShader.Id, texture.Name), j);
                        }
                    }
                }

                var vpPointsA = new Vector4(
                    viewport.x / (float)Screen.Width,
                    viewport.y / (float)Screen.Height,
                    viewport.Right / (float)Screen.Width,
                    viewport.Bottom / (float)Screen.Height
                    );
                var vpPointsB = vpPointsA * 2f - Vector4.One;

                DrawUtils.DrawQuadUv0(vpPointsB, vpPointsA);
            }

            GL.DepthMask(true);
            GL.Disable(EnableCap.Blend);
        }
Beispiel #4
0
        public override void Render()
        {
            Framebuffer.BindWithDrawBuffers(Framebuffer);

            GL.Enable(EnableCap.Blend);
            GL.Enable(EnableCap.CullFace);
            GL.DepthMask(false);

            //test if it equals 1
            //GL.StencilFunc(StencilFunction.Notequal, 0x01, 0x01);
            //GL.StencilMask(0);

            Matrix4x4 worldMatrix, inverseWorldMatrix = default,
Beispiel #5
0
        public override void Render()
        {
            Framebuffer.BindWithDrawBuffers(null);

            Shader.SetShader(Rendering.GUIShader);

            GL.Enable(EnableCap.Blend);
            GL.Enable(EnableCap.CullFace);
            GL.CullFace(CullFaceMode.Back);

            GUI.canDraw = true;

            Game.Instance?.OnGUI();
            //ComponentManager.OnGUI();

            GUI.canDraw = false;

            GL.Disable(EnableCap.Blend);
            GL.Disable(EnableCap.CullFace);
        }