示例#1
0
        protected override void OnRender(UpdateEventArgs e)
        {
            if (resizeNeeded)
            {
                GL.Viewport(0, 0, width, height);

                using (var target = texture.Bind())
                {
                    target.Resize(width, height);
                }

                resizeNeeded = false;
            }

            using (renderTarget.Bind())
            {
                prepareForFrame();

                shapeRenderer.Render();
            }

            postProcessor.Render();

            SwapBuffers();
        }
示例#2
0
        protected override void OnLoad()
        {
            texture = Texture.Empty(1, 1, PixelInternalFormat.Rgba);

            renderTarget = new RenderTarget();
            // ReSharper disable once ConvertToUsingDeclaration
            using (var target = renderTarget.Bind())
            {
                target.SetColorAttachments(texture);
            }

            shapeShaderProgram = ShaderProgram.FromShaders(
                ShaderFactory.Vertex.FromFile("geometry.vs"), ShaderFactory.Fragment.FromFile("geometry.fs"));

            meshBuilder = new IndexedTrianglesMeshBuilder <ColorVertexData>();

            var shapeDrawer =
                new ShapeDrawer3 <ColorVertexData, Color>(meshBuilder, (xyz, color) => new ColorVertexData(xyz, color));

            shapeDrawer.DrawCube(Vector3.Zero, 1f, Color.Aqua);

            var shapeRenderable = meshBuilder.ToRenderable();

            shapeRenderer = Renderer.From(shapeRenderable, shapeShaderProgram, viewMatrix, projectionMatrix);

            viewMatrix.Value = Matrix4.LookAt(new Vector3(0, 1, -2), Vector3.Zero, Vector3.UnitY);

            postProcessShader = ShaderProgram.FromShaders(
                ShaderFactory.Vertex.FromFile("postprocess.vs"), ShaderFactory.Fragment.FromFile("postprocess.fs"));

            postProcessor = PostProcessor.From(postProcessShader,
                                               new TextureUniform("inTexture", TextureUnit.Texture0, texture), pixelSizeUniform);
        }
示例#3
0
文件: Camera.cs 项目: Andrea/duality
        /// <summary>
        /// Renders the current <see cref="Duality.Resources.Scene"/>.
        /// </summary>
        /// <param name="viewportRect">The viewport area to which will be rendered.</param>
        public void Render(Rect viewportRect)
        {
            this.MakeAvailable();
            this.UpdateDeviceConfig();

            string counterName = Path.Combine("Cameras", this.gameobj.Name);

            Profile.BeginMeasure(counterName);
            Profile.TimeRender.BeginMeasure();

            foreach (Pass t in this.passes)
            {
                this.RenderSinglePass(viewportRect, t);
                OnPassRendered(t);
            }

            OnFrameRendered();

            RenderTarget.Bind(RenderTarget.None);
            this.drawDevice.VisibilityMask = this.visibilityMask;
            this.drawDevice.RenderMode     = RenderMatrix.PerspectiveWorld;
            this.drawDevice.UpdateMatrices();             // Reset matrices for projection calculations during update

            Profile.TimeRender.EndMeasure();
            Profile.EndMeasure(counterName);
        }
示例#4
0
        private Pixmap.Layer RenderToTexture(int width, int height, Action <Canvas> renderMethod)
        {
            Pixmap.Layer pixelData;

            using (Texture texture = new Texture(width, height, Texture.SizeMode.NonPowerOfTwo))
                using (RenderTarget renderTarget = new RenderTarget(AAQuality.Off, texture))
                    using (DrawDevice device = new DrawDevice())
                    {
                        device.Perspective    = PerspectiveMode.Flat;
                        device.VisibilityMask = VisibilityFlag.AllGroups | VisibilityFlag.ScreenOverlay;
                        device.RenderMode     = RenderMatrix.OrthoScreen;
                        device.Target         = renderTarget;
                        device.ViewportRect   = new Rect(renderTarget.Width, renderTarget.Height);

                        device.BeginRendering(ClearFlag.All, ColorRgba.TransparentBlack, 1.0f);
                        {
                            Canvas canvas = new Canvas(device);
                            renderMethod(canvas);
                        }
                        device.EndRendering();

                        RenderTarget.Bind(RenderTarget.None);

                        pixelData = texture.RetrievePixelData();
                    }

            return(pixelData);
        }
示例#5
0
        public void DrawFromCamera(Camera camera, RenderTarget renderTarget)
        {
            //GlowingPass( camera );
            ShadowMappingPass(camera);

            camera.SetCurrentView();

            renderTarget.Clear();
            renderTarget.Bind();
            DeviceContext.OutputMerger.BlendState = mainBlend;

            SetViewport(camera.GetViewport());

            LightManager.Instance.Update(View.Current);

            if (!turnOffSceneRendering)
            {
                //ProjectorManager.Instance.Bind();
                scene_.Render();
                //ProjectorManager.Instance.UnBind();
            }

            //renderTarget.DepthStencil.SetDepthComparison( Comparison.Greater );
            // On vérifie si la camera possède une skybox
            if (camera.Skybox != null)
            {
                // Dans ce cas, on affiche la skybox
                // On l'affiche en dernier pour éviter d'effectuer les test du Stencil buffer inutilement
                camera.Skybox.Render();
            }
            // if (Isglowing){
            // GlowingManager.Instance.DrawQuadOnTop();
            // }
        }
示例#6
0
        public void BeginRendering(ClearFlag clearFlags, ColorRgba clearColor, float clearDepth)
        {
            RenderTarget.Bind(this.renderTarget);

            // Setup viewport
            Vector2 refSize     = this.TargetSize;
            Rect    viewportAbs = new Rect(refSize);

            GL.Viewport((int)viewportAbs.X, (int)refSize.Y - (int)viewportAbs.H - (int)viewportAbs.Y, (int)viewportAbs.W, (int)viewportAbs.H);
            GL.Scissor((int)viewportAbs.X, (int)refSize.Y - (int)viewportAbs.H - (int)viewportAbs.Y, (int)viewportAbs.W, (int)viewportAbs.H);

            // Clear buffers
            ClearBufferMask glClearMask = 0;

            if ((clearFlags & ClearFlag.Color) != ClearFlag.None)
            {
                glClearMask |= ClearBufferMask.ColorBufferBit;
            }
            if ((clearFlags & ClearFlag.Depth) != ClearFlag.None)
            {
                glClearMask |= ClearBufferMask.DepthBufferBit;
            }
            GL.ClearColor((OpenTK.Graphics.Color4)clearColor);
            GL.ClearDepth((double)clearDepth);             // The "float version" is from OpenGL 4.1..
            GL.Clear(glClearMask);

            // Configure Rendering params
            if (this.renderMode == RenderMatrix.OrthoScreen)
            {
                GL.Enable(EnableCap.ScissorTest);
                GL.Enable(EnableCap.DepthTest);
                GL.DepthFunc(DepthFunction.Always);
            }
            else
            {
                GL.Enable(EnableCap.ScissorTest);
                GL.Enable(EnableCap.DepthTest);
                GL.DepthFunc(DepthFunction.Lequal);
            }

            // Upload and adjust matrices
            this.UpdateMatrices();
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadMatrix(ref this.matModelView);
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadMatrix(ref this.matProjection);
            if (this.renderTarget.IsAvailable)
            {
                if (this.renderMode == RenderMatrix.OrthoScreen)
                {
                    GL.Translate(0.0f, RenderTarget.BoundRT.Res.Height * 0.5f, 0.0f);
                }
                GL.Scale(1.0f, -1.0f, 1.0f);
                if (this.renderMode == RenderMatrix.OrthoScreen)
                {
                    GL.Translate(0.0f, -RenderTarget.BoundRT.Res.Height * 0.5f, 0.0f);
                }
            }
        }
示例#7
0
        public static void RenderVoid(Rect viewportRect)
        {
            RenderTarget.Bind(ContentRef <RenderTarget> .Null);

            GL.Viewport((int)viewportRect.X, (int)viewportRect.Y, (int)viewportRect.W, (int)viewportRect.H);
            GL.Scissor((int)viewportRect.X, (int)viewportRect.Y, (int)viewportRect.W, (int)viewportRect.H);

            GL.ClearDepth(1.0d);
            GL.ClearColor((OpenTK.Graphics.Color4)ColorRgba.TransparentBlack);
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
        }
示例#8
0
        /// <summary>
        /// Renders a picking map of the current <see cref="Duality.Resources.Scene"/>.
        /// If picking is required, this will be (automatically) done each frame a picking operation needs to
        /// be performed.
        /// </summary>
        /// <param name="viewportSize">Sife of the viewport area to which will be rendered.</param>
        /// <returns>True, if the picking map has been rendered. False, if this frames cached version is used.</returns>
        public bool RenderPickingMap(Vector2 viewportSize)
        {
            if (this.pickingLast == Time.FrameCount)
            {
                return(false);
            }
            this.pickingLast = Time.FrameCount;
            Profile.TimeVisualPicking.BeginMeasure();

            // Render picking map
            {
                this.MakeAvailable();
                this.UpdateDeviceConfig();
                this.SetupPickingRT(viewportSize);

                // Setup DrawDevice
                this.drawDevice.PickingIndex   = 1;
                this.drawDevice.Target         = this.pickingRT;
                this.drawDevice.VisibilityMask = this.visibilityMask & VisibilityFlag.AllGroups;
                this.drawDevice.RenderMode     = RenderMatrix.PerspectiveWorld;
                this.drawDevice.ViewportRect   = new Rect(this.pickingTex.PixelWidth, this.pickingTex.PixelHeight);

                // Render Scene
                this.drawDevice.BeginRendering(ClearFlag.All, ColorRgba.Black, 1.0f);
                this.CollectDrawcalls();
                this.drawDevice.EndRendering();
                this.drawDevice.PickingIndex = 0;

                GL.Finish();
                RenderTarget.Bind(RenderTarget.None);
            }

            // Move data to local buffer
            int pxNum     = this.pickingTex.PixelWidth * this.pickingTex.PixelHeight;
            int pxByteNum = pxNum * 4;

            if (pxByteNum > this.pickingBuffer.Length)
            {
                Array.Resize(ref this.pickingBuffer, Math.Max(this.pickingBuffer.Length * 2, pxByteNum));
            }

            ContentRef <RenderTarget> lastTex = RenderTarget.BoundRT;

            RenderTarget.Bind(this.pickingRT);
            GL.ReadBuffer(ReadBufferMode.ColorAttachment0);
            GL.ReadPixels(0, 0, this.pickingTex.PixelWidth, this.pickingTex.PixelHeight, PixelFormat.Rgba, PixelType.UnsignedByte, this.pickingBuffer);
            RenderTarget.Bind(lastTex);
            GL.ReadBuffer(ReadBufferMode.Back);

            Profile.TimeVisualPicking.EndMeasure();
            return(true);
        }
示例#9
0
        public void Draw()
        {
            if (!IsEnabled)
            {
                return;
            }

            shadowMapTarget.Bind(1);

            Draw(modelRenderer);
            Draw(spriteBatch3D);
            Draw(skeletonRenderer);
        }
示例#10
0
        public void Draw()
        {
            if (!IsDrawEnabled)
            {
                return;
            }

            shadowMapTarget.Bind(Constants.TextureLimit);

            Draw(modelRenderer);
            Draw(spriteBatch3D);
            Draw(skeletonRenderer);
        }
示例#11
0
        public static void RenderVoid()
        {
            RenderTarget.Bind(ContentRef <RenderTarget> .Null);

            Vector2 refSize     = DualityApp.TargetResolution;
            Rect    viewportAbs = new Rect(refSize);

            GL.Viewport((int)viewportAbs.X, (int)refSize.Y - (int)viewportAbs.H - (int)viewportAbs.Y, (int)viewportAbs.W, (int)viewportAbs.H);
            GL.Scissor((int)viewportAbs.X, (int)refSize.Y - (int)viewportAbs.H - (int)viewportAbs.Y, (int)viewportAbs.W, (int)viewportAbs.H);

            GL.ClearDepth(1.0d);
            GL.ClearColor((OpenTK.Graphics.Color4)ColorRgba.TransparentBlack);
            GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);
        }
示例#12
0
        public void DrawTargets()
        {
            modelTarget.Apply();

            // Note that by this point, the scene's shadow map should have already been computed.
            var renderer = Scene.Renderer;

            renderer.VpMatrix = viewOrientation;
            renderer.Draw();

            shader.Apply();
            Sky.Target.Bind(0);
            modelTarget.Bind(1);
        }
示例#13
0
        public override void Draw()
        {
            RenderTarget originalRenderTarget = RenderTarget.Current;

            RenderTarget.Bind(Surface);
            Graphics.Clear(Colour.Black);

            // Shadow Casters
            Vector2 caster = occlusion.player.Position;
            //Vector2 caster = Input.Mouse.Position.World.round();
            //Vector2 caster = Vector2.Zero;

            // Falloff Shadow
            BlendState originalBlendState = Graphics.State.BlendState;

            Graphics.State.SetBlendState(BlendState.Subtractive);
            Renderer.Draw.Circle(caster, Resolution.Height * 2f, Colour.White, Colour.White.Alpha(0), 32);
            Graphics.State.SetBlendState(originalBlendState);

            //Renderer.SetBlendState(nsBlendState.Subtractive);
            foreach (Box box in Scene.Entities.FindAll <Box>())
            {
                var block_l = box.X - box.Origin.X;
                var block_r = box.X - box.Origin.X + box.Size.X;
                var block_t = box.Y - box.Origin.Y;
                var block_b = box.Y - box.Origin.Y + box.Size.Y;

                if (caster.Y > block_t)
                {
                    DrawShadow(new Vector2(block_l, block_t), new Vector2(block_r, block_t), caster, 700);
                }
                if (caster.Y < block_b)
                {
                    DrawShadow(new Vector2(block_l, block_b), new Vector2(block_r, block_b), caster, 700);
                }
                if (caster.X > block_l)
                {
                    DrawShadow(new Vector2(block_l, block_t), new Vector2(block_l, block_b), caster, 700);
                }
                if (caster.X < block_r)
                {
                    DrawShadow(new Vector2(block_r, block_t), new Vector2(block_r, block_b), caster, 700);
                }
            }
            RenderTarget.Bind(originalRenderTarget);
            //Graphics.State.SetBlendState(BlendState.Additive);
            Renderer.Draw.RenderTarget(Surface, Camera.Position.X - Resolution.Half.Width / Camera.Zoom, Camera.Position.Y - Resolution.Half.Height / Camera.Zoom, 1f / Camera.Zoom, Camera.Rotation, Camera.Position, Colour.White);
            //Renderer.ResetBlendState();
        }
示例#14
0
        private static PipelineRenderTarget renderTarget(
            Action <RenderTarget.Target>?additionalSetup, params PipelineTexture[] textures)
        {
            var renderTarget = new RenderTarget();

            using (var target = renderTarget.Bind())
            {
                target.SetColorAttachments(textures.Select(t => t.Texture).ToArray());
                additionalSetup?.Invoke(target);

                var status = target.CheckStatus();
                if (status != FramebufferErrorCode.FramebufferComplete)
                {
                    throw new InvalidOperationException($"Framebuffer incomplete: {status}");
                }
            }

            return(new PipelineRenderTarget(renderTarget));
        }
示例#15
0
    // tick for OpenGL rendering code
    public void RenderGL()
    {
        HandleInput();

        // measure frame duration
        float frameDuration = timer.ElapsedMilliseconds;

        timer.Reset();
        timer.Start();

        UpdateScene(); //update transformations of all objects that are not static

        // update rotation
        a += 0.001f * frameDuration;

        if (a > 1000 * PI)
        {
            a -= 1000 * PI;                //reset a to prevent stack overflows
        }
        if (useRenderTarget)
        {
            // enable render target
            target.Bind();

            // render scene to render target
            sceneGraph.RenderHierarchy(camera);

            // render quad
            target.Unbind();
            quad.Render(postproc, target.GetTextureID());
        }
        else
        {
            // render scene directly to the screen
            sceneGraph.RenderHierarchy(camera);
        }
    }
示例#16
0
        void UpdateSourceDrawingWork(JobInfo job)
        {
            bool vsync          = false;
            bool alternateVsync = false;
            //only used by alternate vsync
            IGL_SlimDX9 dx9 = null;

            if (!job.offscreen)
            {
                //apply the vsync setting (should probably try to avoid repeating this)
                vsync = Global.Config.VSyncThrottle || Global.Config.VSync;

                //ok, now this is a bit undesireable.
                //maybe the user wants vsync, but not vsync throttle.
                //this makes sense... but we dont have the infrastructure to support it now (we'd have to enable triple buffering or something like that)
                //so what we're gonna do is disable vsync no matter what if throttling is off, and maybe nobody will notice.
                //update 26-mar-2016: this upsets me. When fastforwarding and skipping frames, vsync should still work. But I'm not changing it yet
                if (Global.DisableSecondaryThrottling)
                {
                    vsync = false;
                }

                //for now, it's assumed that the presentation panel is the main window, but that may not always be true
                if (vsync && Global.Config.DispAlternateVsync && Global.Config.VSyncThrottle)
                {
                    dx9 = GL as IGL_SlimDX9;
                    if (dx9 != null)
                    {
                        alternateVsync = true;
                        //unset normal vsync if we've chosen the alternate vsync
                        vsync = false;
                    }
                }

                //TODO - whats so hard about triple buffering anyway? just enable it always, and change api to SetVsync(enable,throttle)
                //maybe even SetVsync(enable,throttlemethod) or just SetVsync(enable,throttle,advanced)

                if (LastVsyncSetting != vsync || LastVsyncSettingGraphicsControl != presentationPanel.GraphicsControl)
                {
                    if (LastVsyncSetting == null && vsync)
                    {
                        // Workaround for vsync not taking effect at startup (Intel graphics related?)
                        presentationPanel.GraphicsControl.SetVsync(false);
                    }
                    presentationPanel.GraphicsControl.SetVsync(vsync);
                    LastVsyncSettingGraphicsControl = presentationPanel.GraphicsControl;
                    LastVsyncSetting = vsync;
                }
            }

            //begin rendering on this context
            //should this have been done earlier?
            //do i need to check this on an intel video card to see if running excessively is a problem? (it used to be in the FinalTarget command below, shouldnt be a problem)
            //GraphicsControl.Begin(); //CRITICAL POINT for yabause+GL

            //TODO - auto-create and age these (and dispose when old)
            int rtCounter = 0;

            CurrentFilterProgram.RenderTargetProvider = new DisplayManagerRenderTargetProvider((size) => ShaderChainFrugalizers[rtCounter++].Get(size));

            GL.BeginScene();

            //run filter chain
            Texture2d    texCurr       = null;
            RenderTarget rtCurr        = null;
            bool         inFinalTarget = false;

            foreach (var step in CurrentFilterProgram.Program)
            {
                switch (step.Type)
                {
                case FilterProgram.ProgramStepType.Run:
                {
                    int fi = (int)step.Args;
                    var f  = CurrentFilterProgram.Filters[fi];
                    f.SetInput(texCurr);
                    f.Run();
                    var orec = f.FindOutput();
                    if (orec != null)
                    {
                        if (orec.SurfaceDisposition == SurfaceDisposition.Texture)
                        {
                            texCurr = f.GetOutput();
                            rtCurr  = null;
                        }
                    }
                    break;
                }

                case FilterProgram.ProgramStepType.NewTarget:
                {
                    var size = (Size)step.Args;
                    rtCurr = ShaderChainFrugalizers[rtCounter++].Get(size);
                    rtCurr.Bind();
                    CurrentFilterProgram.CurrRenderTarget = rtCurr;
                    break;
                }

                case FilterProgram.ProgramStepType.FinalTarget:
                {
                    var size = (Size)step.Args;
                    inFinalTarget = true;
                    rtCurr        = null;
                    CurrentFilterProgram.CurrRenderTarget = null;
                    GL.BindRenderTarget(null);
                    break;
                }
                }
            }

            GL.EndScene();

            if (job.offscreen)
            {
                job.offscreenBB = rtCurr.Texture2d.Resolve();
                job.offscreenBB.DiscardAlpha();
            }
            else
            {
                Debug.Assert(inFinalTarget);

                //wait for vsync to begin
                if (alternateVsync)
                {
                    dx9.AlternateVsyncPass(0);
                }

                //present and conclude drawing
                presentationPanel.GraphicsControl.SwapBuffers();

                //wait for vsync to end
                if (alternateVsync)
                {
                    dx9.AlternateVsyncPass(1);
                }

                //nope. dont do this. workaround for slow context switching on intel GPUs. just switch to another context when necessary before doing anything
                //presentationPanel.GraphicsControl.End();
            }
        }
示例#17
0
    public void Render()
    {
        // measure frame duration
        float frameDuration = (float)timer.Elapsed.TotalSeconds;    //timer.ElapsedMilliseconds;

        timer.Reset();
        timer.Start();

        CameraControls(frameDuration);

        //prepare matrices for vertex shader
        Vector3 campos3 = -cameraM.Row3.Xyz;

        camID = GL.GetUniformLocation(shader.programID, "campos");
        GL.UseProgram(shader.programID);
        GL.Uniform3(camID, campos3);

        Vector3 newlightpos3 = lightpos3;

        lightID = GL.GetUniformLocation(shader.programID, "lightPos");
        GL.UseProgram(shader.programID);
        GL.Uniform3(lightID, newlightpos3);

        Matrix4 teapotT = Matrix4.CreateFromAxisAngle(new Vector3(0, 1, 0), -a);

        teapotN.localM = teapotT;

        Matrix4 smallteapotT = Matrix4.CreateFromAxisAngle(new Vector3(0, 1, 0), -b);

        smallteapotT      *= Matrix4.CreateScale(0.6f);
        smallteapotT      *= Matrix4.CreateTranslation(8f, 7f, 0);
        smallteapot.localM = smallteapotT;

        Matrix4 carT = Matrix4.CreateScale(0.8f);

        carT       *= Matrix4.CreateFromAxisAngle(new Vector3(0, 1, 0), 0.8f * (float)Math.PI);;
        carT       *= Matrix4.CreateTranslation(4f, -2.2f, 0);
        carT       *= Matrix4.CreateFromAxisAngle(new Vector3(0, 1, 0), b);
        carN.localM = carT;

        Matrix4 carT2 = Matrix4.CreateScale(0.8f);

        carT2       *= Matrix4.CreateFromAxisAngle(new Vector3(0, -1, 0), 0.2f * (float)Math.PI);;
        carT2       *= Matrix4.CreateTranslation(-3.5f, -2.25f, 0);
        carT2       *= Matrix4.CreateFromAxisAngle(new Vector3(0, 1, 0), b);
        carN2.localM = carT2;


        // update rotation
        a += 1f * frameDuration;
        b += 1.5f * frameDuration;
        if (a > 2 * PI)
        {
            a -= 2 * PI;
        }
        if (b > 2 * PI)
        {
            b -= 2 * PI;
        }

        if (useRenderTarget)
        {
            // enable render target
            target.Bind();

            // render scene to render target
            root.Render(ToWorld, cameraM);

            // render quad
            target.Unbind();
            quad.Render(postproc, target.GetTextureID());
        }
        else
        {
            // render scene directly to the screen
            root.Render(ToWorld, cameraM);
        }
    }
        void UpdateSourceDrawingWork(JobInfo job)
        {
            //begin rendering on this context
            //should this have been done earlier?
            //do i need to check this on an intel video card to see if running excessively is a problem? (it used to be in the FinalTarget command below, shouldnt be a problem)
            //GraphicsControl.Begin();

            //run filter chain
            Texture2d    texCurr       = null;
            RenderTarget rtCurr        = null;
            int          rtCounter     = 0;
            bool         inFinalTarget = false;

            foreach (var step in CurrentFilterProgram.Program)
            {
                switch (step.Type)
                {
                case FilterProgram.ProgramStepType.Run:
                {
                    int fi = (int)step.Args;
                    var f  = CurrentFilterProgram.Filters[fi];
                    f.SetInput(texCurr);
                    f.Run();
                    var orec = f.FindOutput();
                    if (orec != null)
                    {
                        if (orec.SurfaceDisposition == SurfaceDisposition.Texture)
                        {
                            texCurr = f.GetOutput();
                            rtCurr  = null;
                        }
                    }
                    break;
                }

                case FilterProgram.ProgramStepType.NewTarget:
                {
                    var size = (Size)step.Args;
                    rtCurr = ShaderChainFrugalizers[rtCounter++].Get(size);
                    rtCurr.Bind();
                    CurrentFilterProgram.CurrRenderTarget = rtCurr;
                    break;
                }

                case FilterProgram.ProgramStepType.FinalTarget:
                {
                    var size = (Size)step.Args;
                    inFinalTarget = true;
                    rtCurr        = null;
                    CurrentFilterProgram.CurrRenderTarget = null;
                    GL.BindRenderTarget(null);
                    break;
                }
                }
            }

            if (job.offscreen)
            {
                job.offscreenBB = rtCurr.Texture2d.Resolve();
            }
            else
            {
                Debug.Assert(inFinalTarget);
                //apply the vsync setting (should probably try to avoid repeating this)
                bool vsync = Global.Config.VSyncThrottle || Global.Config.VSync;

                //ok, now this is a bit undesireable.
                //maybe the user wants vsync, but not vsync throttle.
                //this makes sense... but we dont have the infrastructure to support it now (we'd have to enable triple buffering or something like that)
                //so what we're gonna do is disable vsync no matter what if throttling is off, and maybe nobody will notice.
                if (Global.DisableSecondaryThrottling)
                {
                    vsync = false;
                }

                if (LastVsyncSetting != vsync || LastVsyncSettingGraphicsControl != presentationPanel.GraphicsControl)
                {
                    if (LastVsyncSetting == null && vsync)
                    {
                        // Workaround for vsync not taking effect at startup (Intel graphics related?)
                        presentationPanel.GraphicsControl.SetVsync(false);
                    }
                    presentationPanel.GraphicsControl.SetVsync(vsync);
                    LastVsyncSettingGraphicsControl = presentationPanel.GraphicsControl;
                    LastVsyncSetting = vsync;
                }

                //present and conclude drawing
                presentationPanel.GraphicsControl.SwapBuffers();

                //nope. dont do this. workaround for slow context switching on intel GPUs. just switch to another context when necessary before doing anything
                //presentationPanel.GraphicsControl.End();
            }
        }
示例#19
0
        void UpdateSourceDrawingWork(JobInfo job)
        {
            //begin rendering on this context
            //should this have been done earlier?
            //do i need to check this on an intel video card to see if running excessively is a problem? (it used to be in the FinalTarget command below, shouldnt be a problem)
            //GraphicsControl.Begin();

            //run filter chain
            Texture2d    texCurr       = null;
            RenderTarget rtCurr        = null;
            int          rtCounter     = 0;
            bool         inFinalTarget = false;

            foreach (var step in CurrentFilterProgram.Program)
            {
                switch (step.Type)
                {
                case FilterProgram.ProgramStepType.Run:
                {
                    int fi = (int)step.Args;
                    var f  = CurrentFilterProgram.Filters[fi];
                    f.SetInput(texCurr);
                    f.Run();
                    var orec = f.FindOutput();
                    if (orec != null)
                    {
                        if (orec.SurfaceDisposition == SurfaceDisposition.Texture)
                        {
                            texCurr = f.GetOutput();
                            rtCurr  = null;
                        }
                    }
                    break;
                }

                case FilterProgram.ProgramStepType.NewTarget:
                {
                    var size = (Size)step.Args;
                    rtCurr = ShaderChainFrugalizers[rtCounter++].Get(size);
                    rtCurr.Bind();
                    CurrentFilterProgram.CurrRenderTarget = rtCurr;
                    break;
                }

                case FilterProgram.ProgramStepType.FinalTarget:
                {
                    var size = (Size)step.Args;
                    inFinalTarget = true;
                    rtCurr        = null;
                    CurrentFilterProgram.CurrRenderTarget = null;
                    GL.BindRenderTarget(null);
                    break;
                }
                }
            }

            if (job.offscreen)
            {
                job.offscreenBB = rtCurr.Texture2d.Resolve();
            }
            else
            {
                Debug.Assert(inFinalTarget);
                //apply the vsync setting (should probably try to avoid repeating this)
                bool vsync = Global.Config.VSyncThrottle || Global.Config.VSync;
                if (LastVsyncSetting != vsync || LastVsyncSettingGraphicsControl != presentationPanel.GraphicsControl)
                {
                    presentationPanel.GraphicsControl.SetVsync(vsync);
                    LastVsyncSettingGraphicsControl = presentationPanel.GraphicsControl;
                    LastVsyncSetting = vsync;
                }

                //present and conclude drawing
                presentationPanel.GraphicsControl.SwapBuffers();

                //nope. dont do this. workaround for slow context switching on intel GPUs. just switch to another context when necessary before doing anything
                //presentationPanel.GraphicsControl.End();

                NeedsToPaint = false;                 //??
            }
        }
示例#20
0
        public void BeginRendering(ClearFlag clearFlags, ColorRgba clearColor, float clearDepth, bool scaleViewport = true)
        {
            RenderTarget.Bind(this.renderTarget);

            // Setup viewport
            Rect viewport = this.ViewportRect;

            if (scaleViewport)
            {
                float width             = this.viewportRect.W;
                var   targetAspectRatio = nominalViewportSize.X / nominalViewportSize.Y;
                float height            = (width / targetAspectRatio + 0.5f);

                if (height > viewportRect.H)
                {
                    height = viewportRect.H;
                    width  = height * targetAspectRatio + 0.5f;
                }

                viewport = new Rect(
                    (viewportRect.W / 2) - (width / 2),
                    (viewportRect.H / 2) - (height / 2),
                    width, height);
            }

            GL.Viewport((int)viewport.X, (int)viewport.Y, (int)viewport.W, (int)viewport.H);
            GL.Scissor((int)this.viewportRect.X, (int)this.viewportRect.Y, (int)this.viewportRect.W, (int)this.viewportRect.H);

            // Clear buffers
            ClearBufferMask glClearMask = 0;

            if ((clearFlags & ClearFlag.Color) != ClearFlag.None)
            {
                glClearMask |= ClearBufferMask.ColorBufferBit;
            }
            if ((clearFlags & ClearFlag.Depth) != ClearFlag.None)
            {
                glClearMask |= ClearBufferMask.DepthBufferBit;
            }
            GL.ClearColor((OpenTK.Graphics.Color4)clearColor);
            GL.ClearDepth((double)clearDepth);             // The "float version" is from OpenGL 4.1..
            GL.Clear(glClearMask);

            // Configure Rendering params
            if (this.renderMode == RenderMatrix.OrthoScreen)
            {
                GL.Enable(EnableCap.ScissorTest);
                GL.Enable(EnableCap.DepthTest);
                GL.DepthFunc(DepthFunction.Always);
            }
            else
            {
                GL.Enable(EnableCap.ScissorTest);
                GL.Enable(EnableCap.DepthTest);
                GL.DepthFunc(DepthFunction.Lequal);
            }

            // Upload and adjust matrices
            this.UpdateMatrices();
            GL.MatrixMode(MatrixMode.Modelview);
            GL.LoadMatrix(ref this.matModelView);
            GL.MatrixMode(MatrixMode.Projection);
            GL.LoadMatrix(ref this.matProjection);
            if (this.renderTarget.IsAvailable)
            {
                if (this.renderMode == RenderMatrix.OrthoScreen)
                {
                    GL.Translate(0.0f, RenderTarget.BoundRT.Res.Height * 0.5f, 0.0f);
                }
                GL.Scale(1.0f, -1.0f, 1.0f);
                if (this.renderMode == RenderMatrix.OrthoScreen)
                {
                    GL.Translate(0.0f, -RenderTarget.BoundRT.Res.Height * 0.5f, 0.0f);
                }
            }
        }
示例#21
0
        static unsafe void Main(string[] args)
        {
            BizHawk.Bizware.BizwareGL.IGL igl = new BizHawk.Bizware.BizwareGL.Drivers.OpenTK.IGL_TK();

            List <Art> testArts = new List <Art>();
            ArtManager am       = new ArtManager(igl);

            foreach (var name in typeof(Program).Assembly.GetManifestResourceNames())
            {
                if (name.Contains("flame"))
                {
                    testArts.Add(am.LoadArt(typeof(Program).Assembly.GetManifestResourceStream(name)));
                }
            }
            var smile = am.LoadArt(typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.smile.png"));

            am.Close(true);
            StringRenderer sr;

            using (var xml = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.courier16px.fnt"))
                using (var tex = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.courier16px_0.png"))
                    sr = new StringRenderer(igl, xml, tex);

            GuiRenderer gr = new GuiRenderer(igl);

            TestForm tf = new TestForm();
            RetainedGraphicsControl c = new RetainedGraphicsControl(igl);

            tf.Controls.Add(c);
            c.Dock          = System.Windows.Forms.DockStyle.Fill;
            tf.FormClosing += (object sender, System.Windows.Forms.FormClosingEventArgs e) =>
            {
                tf.Controls.Remove(c);
                c.Dispose();
                c = null;
            };
            tf.Show();

            //tf.Paint += (object sender, PaintEventArgs e) => c.Refresh();

            c.SetVsync(false);

            //create a render target
            RenderTarget rt = igl.CreateRenderTarget(60, 60);

            rt.Bind();
            igl.SetClearColor(Color.Blue);
            igl.Clear(ClearBufferMask.ColorBufferBit);
            gr.Begin(60, 60, true);
            gr.Draw(smile);
            gr.End();
            rt.Unbind();

            Texture2d rttex2d = igl.LoadTexture(rt.Texture2d.Resolve());

            //test retroarch shader
            RenderTarget rt2 = igl.CreateRenderTarget(240, 240);

            rt2.Bind();
            igl.SetClearColor(Color.CornflowerBlue);
            igl.Clear(ClearBufferMask.ColorBufferBit);
            RetroShader shader;

            using (var stream = typeof(Program).Assembly.GetManifestResourceStream("BizHawk.Bizware.Test.TestImages.4xSoft.glsl"))
                shader = new RetroShader(igl, new System.IO.StreamReader(stream).ReadToEnd());
            igl.SetBlendState(igl.BlendNone);
            shader.Run(rttex2d, new Size(60, 60), new Size(240, 240), true);


            bool running = true;

            c.MouseClick += (object sender, MouseEventArgs e) =>
            {
                if (e.Button == MouseButtons.Left)
                {
                    running ^= true;
                }
                if (e.Button == MouseButtons.Right)
                {
                    c.Retain ^= true;
                }
            };

            DateTime start  = DateTime.Now;
            int      wobble = 0;

            for (; ;)
            {
                if (c == null)
                {
                    break;
                }

                if (running)
                {
                    c.Begin();

                    igl.SetClearColor(Color.Red);
                    igl.Clear(ClearBufferMask.ColorBufferBit);

                    int frame = (int)((DateTime.Now - start).TotalSeconds) % testArts.Count;

                    gr.Begin(c.ClientSize.Width, c.ClientSize.Height);

                    gr.SetModulateColor(Color.Green);
                    gr.RectFill(250, 0, 16, 16);

                    gr.SetBlendState(igl.BlendNone);
                    gr.Draw(rttex2d, 0, 20);
                    gr.SetBlendState(igl.BlendNormal);

                    sr.RenderString(gr, 0, 0, "?? fps");
                    gr.SetModulateColor(Color.FromArgb(255, 255, 255, 255));
                    gr.SetCornerColor(0, OpenTK.Graphics.Color4.Red);
                    gr.Draw(rt2.Texture2d, 0, 0);
                    gr.SetCornerColor(0, OpenTK.Graphics.Color4.White);
                    gr.SetModulateColorWhite();
                    gr.Modelview.Translate((float)Math.Sin(wobble / 360.0f) * 50, 0);
                    gr.Modelview.Translate(100, 100);
                    gr.Modelview.Push();
                    gr.Modelview.Translate(testArts[frame].Width, 0);
                    gr.Modelview.Scale(-1, 1);
                    wobble++;
                    gr.SetModulateColor(Color.Yellow);
                    gr.DrawFlipped(testArts[frame], true, false);
                    gr.SetModulateColorWhite();
                    gr.Modelview.Pop();
                    gr.SetBlendState(igl.BlendNormal);
                    gr.Draw(smile);

                    gr.End();


                    c.SwapBuffers();
                    c.End();
                }

                System.Windows.Forms.Application.DoEvents();
                System.Threading.Thread.Sleep(0);
            }
        }