示例#1
0
        FilterProgram BuildDefaultChain(Size chainInSize, Size chainOutSize, bool includeOSD)
        {
            // select user special FX shader chain
            var selectedChainProperties = new Dictionary <string, object>();

            Filters.RetroShaderChain selectedChain = null;
            if (Global.Config.TargetDisplayFilter == 1 && ShaderChain_hq2x != null && ShaderChain_hq2x.Available)
            {
                selectedChain = ShaderChain_hq2x;
            }

            if (Global.Config.TargetDisplayFilter == 2 && ShaderChain_scanlines != null && ShaderChain_scanlines.Available)
            {
                selectedChain = ShaderChain_scanlines;
                selectedChainProperties["uIntensity"] = 1.0f - Global.Config.TargetScanlineFilterIntensity / 256.0f;
            }

            if (Global.Config.TargetDisplayFilter == 3 && ShaderChain_user != null && ShaderChain_user.Available)
            {
                selectedChain = ShaderChain_user;
            }

            var fPresent = new Filters.FinalPresentation(chainOutSize);
            var fInput   = new Filters.SourceImage(chainInSize);
            var fOSD     = new Filters.OSD();

            fOSD.RenderCallback = () =>
            {
                if (!includeOSD)
                {
                    return;
                }

                var size = fOSD.FindInput().SurfaceFormat.Size;
                Renderer.Begin(size.Width, size.Height);
                var myBlitter = new MyBlitter(this)
                {
                    ClipBounds = new Rectangle(0, 0, size.Width, size.Height)
                };
                Renderer.SetBlendState(GL.BlendNormal);
                GlobalWin.OSD.Begin(myBlitter);
                GlobalWin.OSD.DrawScreenInfo(myBlitter);
                GlobalWin.OSD.DrawMessages(myBlitter);
                Renderer.End();
            };

            var chain = new FilterProgram();

            //add the first filter, encompassing output from the emulator core
            chain.AddFilter(fInput, "input");

            // if a non-zero padding is required, add a filter to allow for that
            // note, we have two sources of padding right now.. one can come from the VideoProvider and one from the user.
            // we're combining these now and just using black, for sake of being lean, despite the discussion below:
            // keep in mind, the VideoProvider design in principle might call for another color.
            // we haven't really been using this very hard, but users will probably want black there (they could fill it to another color if needed tho)
            var padding = CalculateCompleteContentPadding(true, true);

            if (padding.Vertical != 0 || padding.Horizontal != 0)
            {
                // TODO - add another filter just for this, its cumbersome to use final presentation... I think. but maybe there's enough similarities to justify it.
                Size size = chainInSize;
                size.Width  += padding.Horizontal;
                size.Height += padding.Vertical;
                Filters.FinalPresentation fPadding = new Filters.FinalPresentation(size);
                chain.AddFilter(fPadding, "padding");
                fPadding.GuiRenderer    = Renderer;
                fPadding.GL             = GL;
                fPadding.Config_PadOnly = true;
                fPadding.Padding        = padding;
            }

            //add lua layer 'emu'
            AppendLuaLayer(chain, "emu");

            if (Global.Config.DispPrescale != 1)
            {
                var fPrescale = new Filters.PrescaleFilter()
                {
                    Scale = Global.Config.DispPrescale
                };
                chain.AddFilter(fPrescale, "user_prescale");
            }

            // add user-selected retro shader
            if (selectedChain != null)
            {
                AppendRetroShaderChain(chain, "retroShader", selectedChain, selectedChainProperties);
            }

            // AutoPrescale makes no sense for a None final filter
            if (Global.Config.DispAutoPrescale && Global.Config.DispFinalFilter != (int)Filters.FinalPresentation.eFilterOption.None)
            {
                var apf = new Filters.AutoPrescaleFilter();
                chain.AddFilter(apf, "auto_prescale");
            }

            //choose final filter
            var finalFilter = Filters.FinalPresentation.eFilterOption.None;

            if (Global.Config.DispFinalFilter == 1)
            {
                finalFilter = Filters.FinalPresentation.eFilterOption.Bilinear;
            }

            if (Global.Config.DispFinalFilter == 2)
            {
                finalFilter = Filters.FinalPresentation.eFilterOption.Bicubic;
            }

            //if bicubic is selected and unavailable, don't use it. use bilinear instead I guess
            if (finalFilter == Filters.FinalPresentation.eFilterOption.Bicubic)
            {
                if (ShaderChain_bicubic == null || !ShaderChain_bicubic.Available)
                {
                    finalFilter = Filters.FinalPresentation.eFilterOption.Bilinear;
                }
            }

            fPresent.FilterOption = finalFilter;

            // now if bicubic is chosen, insert it
            if (finalFilter == Filters.FinalPresentation.eFilterOption.Bicubic)
            {
                AppendRetroShaderChain(chain, "bicubic", ShaderChain_bicubic, null);
            }

            // add final presentation
            chain.AddFilter(fPresent, "presentation");

            //add lua layer 'native'
            AppendLuaLayer(chain, "native");

            // and OSD goes on top of that
            // TODO - things break if this isn't present (the final presentation filter gets messed up when used with prescaling)
            // so, always include it (we'll handle this flag in the callback to do no rendering)
            //if (includeOSD)
            chain.AddFilter(fOSD, "osd");

            return(chain);
        }
示例#2
0
		FilterProgram BuildDefaultChain(Size chain_insize, Size chain_outsize, bool includeOSD)
		{
			//select user special FX shader chain
			Dictionary<string, object> selectedChainProperties = new Dictionary<string, object>();
			Filters.RetroShaderChain selectedChain = null;
			if (Global.Config.TargetDisplayFilter == 1 && ShaderChain_hq2x != null && ShaderChain_hq2x.Available)
				selectedChain = ShaderChain_hq2x;
			if (Global.Config.TargetDisplayFilter == 2 && ShaderChain_scanlines != null && ShaderChain_scanlines.Available)
			{
				selectedChain = ShaderChain_scanlines;
				selectedChainProperties["uIntensity"] = 1.0f - Global.Config.TargetScanlineFilterIntensity / 256.0f;
			}
			if (Global.Config.TargetDisplayFilter == 3 && ShaderChain_user != null && ShaderChain_user.Available)
				selectedChain = ShaderChain_user;

			Filters.FinalPresentation fPresent = new Filters.FinalPresentation(chain_outsize);
			Filters.SourceImage fInput = new Filters.SourceImage(chain_insize);
			Filters.OSD fOSD = new Filters.OSD();
			fOSD.RenderCallback = () =>
			{
				if (!includeOSD)
					return;
				var size = fOSD.FindInput().SurfaceFormat.Size;
				Renderer.Begin(size.Width, size.Height);
				MyBlitter myBlitter = new MyBlitter(this);
				myBlitter.ClipBounds = new Rectangle(0, 0, size.Width, size.Height);
				Renderer.SetBlendState(GL.BlendNormal);
				GlobalWin.OSD.Begin(myBlitter);
				GlobalWin.OSD.DrawScreenInfo(myBlitter);
				GlobalWin.OSD.DrawMessages(myBlitter);
				Renderer.End();
			};

			var chain = new FilterProgram();

			//add the first filter, encompassing output from the emulator core
			chain.AddFilter(fInput, "input");

			//if a non-zero padding is required, add a filter to allow for that
			//note, we have two sources of padding right now.. one can come from the videoprovider and one from the user.
			//we're combining these now and just using black, for sake of being lean, despite the discussion below:
			//keep in mind, the videoprovider design in principle might call for another color.
			//we havent really been using this very hard, but users will probably want black there (they could fill it to another color if needed tho)
			var padding = CalculateCompleteContentPadding(true,true);
			if (padding.Vertical != 0 || padding.Horizontal != 0)
			{
				//TODO - add another filter just for this, its cumbersome to use final presentation... I think. but maybe theres enough similarities to justify it.
				Size size = chain_insize;
				size.Width += padding.Horizontal;
				size.Height += padding.Vertical;
				Filters.FinalPresentation fPadding = new Filters.FinalPresentation(size);
				chain.AddFilter(fPadding, "padding");
				fPadding.GuiRenderer = Renderer;
				fPadding.GL = GL;
				fPadding.Config_PadOnly = true;
				fPadding.Padding = padding;
			}

			//add lua layer 'emu'
			AppendLuaLayer(chain, "emu");

			if (Global.Config.DispPrescale != 1)
			{
				Filters.PrescaleFilter fPrescale = new Filters.PrescaleFilter() { Scale = Global.Config.DispPrescale };
				chain.AddFilter(fPrescale, "prescale");
			}

			//add user-selected retro shader
			if (selectedChain != null)
				AppendRetroShaderChain(chain, "retroShader", selectedChain, selectedChainProperties);

			//choose final filter
			Filters.FinalPresentation.eFilterOption finalFilter = Filters.FinalPresentation.eFilterOption.None;
			if (Global.Config.DispFinalFilter == 1) finalFilter = Filters.FinalPresentation.eFilterOption.Bilinear;
			if (Global.Config.DispFinalFilter == 2) finalFilter = Filters.FinalPresentation.eFilterOption.Bicubic;
			//if bicubic is selected and unavailable, dont use it. use bilinear instead I guess
			if (finalFilter == Filters.FinalPresentation.eFilterOption.Bicubic)
			{
				if (ShaderChain_bicubic == null || !ShaderChain_bicubic.Available)
					finalFilter = Filters.FinalPresentation.eFilterOption.Bilinear;
			}
			fPresent.FilterOption = finalFilter;

			//now if bicubic is chosen, insert it
			if (finalFilter == Filters.FinalPresentation.eFilterOption.Bicubic)
				AppendRetroShaderChain(chain, "bicubic", ShaderChain_bicubic, null);

			//add final presentation 
			chain.AddFilter(fPresent, "presentation");

			//add lua layer 'native'
			AppendLuaLayer(chain, "native");

			//and OSD goes on top of that
			//TODO - things break if this isnt present (the final presentation filter gets messed up when used with prescaling)
			//so, always include it (we'll handle this flag in the callback to do no rendering)
			//if (includeOSD)
				chain.AddFilter(fOSD, "osd");

			return chain;
		}
示例#3
0
        FilterProgram BuildDefaultChain(Size chain_insize, Size chain_outsize, bool includeOSD)
        {
            //select user special FX shader chain
            Dictionary <string, object> selectedChainProperties = new Dictionary <string, object>();

            Filters.RetroShaderChain selectedChain = null;
            if (Global.Config.TargetDisplayFilter == 1 && ShaderChain_hq2x != null && ShaderChain_hq2x.Available)
            {
                selectedChain = ShaderChain_hq2x;
            }
            if (Global.Config.TargetDisplayFilter == 2 && ShaderChain_scanlines != null && ShaderChain_scanlines.Available)
            {
                //shader.Pipeline["uIntensity"].Set(1.0f - Global.Config.TargetScanlineFilterIntensity / 256.0f);
                selectedChain = ShaderChain_scanlines;
                selectedChainProperties["uIntensity"] = 1.0f - Global.Config.TargetScanlineFilterIntensity / 256.0f;
            }
            if (Global.Config.TargetDisplayFilter == 3 && ShaderChain_user != null && ShaderChain_user.Available)
            {
                selectedChain = ShaderChain_user;
            }

            Filters.FinalPresentation fPresent = new Filters.FinalPresentation(chain_outsize);
            Filters.SourceImage       fInput   = new Filters.SourceImage(chain_insize);
            Filters.OSD fOSD = new Filters.OSD();
            fOSD.RenderCallback = () =>
            {
                if (!includeOSD)
                {
                    return;
                }
                var size = fOSD.FindInput().SurfaceFormat.Size;
                Renderer.Begin(size.Width, size.Height);
                MyBlitter myBlitter = new MyBlitter(this);
                myBlitter.ClipBounds = new Rectangle(0, 0, size.Width, size.Height);
                Renderer.SetBlendState(GL.BlendNormal);
                GlobalWin.OSD.Begin(myBlitter);
                GlobalWin.OSD.DrawScreenInfo(myBlitter);
                GlobalWin.OSD.DrawMessages(myBlitter);
                Renderer.End();
            };

            var chain = new FilterProgram();

            //add the first filter, encompassing output from the emulator core
            chain.AddFilter(fInput, "input");

            //add lua layer 'emu'
            AppendLuaLayer(chain, "emu");

            //add user-selected retro shader
            if (selectedChain != null)
            {
                AppendRetroShaderChain(chain, "retroShader", selectedChain, selectedChainProperties);
            }

            //choose final filter
            Filters.FinalPresentation.eFilterOption finalFilter = Filters.FinalPresentation.eFilterOption.None;
            if (Global.Config.DispFinalFilter == 1)
            {
                finalFilter = Filters.FinalPresentation.eFilterOption.Bilinear;
            }
            if (Global.Config.DispFinalFilter == 2)
            {
                finalFilter = Filters.FinalPresentation.eFilterOption.Bicubic;
            }
            //if bicubic is selected and unavailable, dont use it
            if (!ShaderChain_bicubic.Available && fPresent.FilterOption == Filters.FinalPresentation.eFilterOption.Bicubic)
            {
                finalFilter = Filters.FinalPresentation.eFilterOption.None;
            }
            fPresent.FilterOption = finalFilter;

            //now if bicubic is chosen, insert it
            if (finalFilter == Filters.FinalPresentation.eFilterOption.Bicubic)
            {
                AppendRetroShaderChain(chain, "bicubic", ShaderChain_bicubic, null);
            }

            //add final presentation
            chain.AddFilter(fPresent, "presentation");

            //add lua layer 'native'
            AppendLuaLayer(chain, "native");

            //and OSD goes on top of that
            //TODO - things break if this isnt present (the final presentation filter gets messed up)
            //so, always include it (we'll handle this flag in the callback to do no rendering)
            //if (includeOSD)
            chain.AddFilter(fOSD, "osd");

            return(chain);
        }
示例#4
0
		FilterProgram BuildDefaultChain(Size chain_insize, Size chain_outsize, bool includeOSD)
		{
			//select user special FX shader chain
			Dictionary<string, object> selectedChainProperties = new Dictionary<string, object>();
			Filters.RetroShaderChain selectedChain = null;
			if (Global.Config.TargetDisplayFilter == 1 && ShaderChain_hq2x != null && ShaderChain_hq2x.Available)
				selectedChain = ShaderChain_hq2x;
			if (Global.Config.TargetDisplayFilter == 2 && ShaderChain_scanlines != null && ShaderChain_scanlines.Available)
			{
				//shader.Pipeline["uIntensity"].Set(1.0f - Global.Config.TargetScanlineFilterIntensity / 256.0f);
				selectedChain = ShaderChain_scanlines;
				selectedChainProperties["uIntensity"] = 1.0f - Global.Config.TargetScanlineFilterIntensity / 256.0f;
			}
			if (Global.Config.TargetDisplayFilter == 3 && ShaderChain_user != null && ShaderChain_user.Available)
				selectedChain = ShaderChain_user;

			Filters.FinalPresentation fPresent = new Filters.FinalPresentation(chain_outsize);
			Filters.SourceImage fInput = new Filters.SourceImage(chain_insize);
			Filters.OSD fOSD = new Filters.OSD();
			fOSD.RenderCallback = () =>
			{
				if (!includeOSD)
					return;
				var size = fOSD.FindInput().SurfaceFormat.Size;
				Renderer.Begin(size.Width, size.Height);
				MyBlitter myBlitter = new MyBlitter(this);
				myBlitter.ClipBounds = new Rectangle(0, 0, size.Width, size.Height);
				Renderer.SetBlendState(GL.BlendNormal);
				GlobalWin.OSD.Begin(myBlitter);
				GlobalWin.OSD.DrawScreenInfo(myBlitter);
				GlobalWin.OSD.DrawMessages(myBlitter);
				Renderer.End();
			};

			var chain = new FilterProgram();

			//add the first filter, encompassing output from the emulator core
			chain.AddFilter(fInput, "input");

			//add lua layer 'emu'
			AppendLuaLayer(chain, "emu");

			//add user-selected retro shader
			if (selectedChain != null)
				AppendRetroShaderChain(chain, "retroShader", selectedChain, selectedChainProperties);

			//choose final filter
			Filters.FinalPresentation.eFilterOption finalFilter = Filters.FinalPresentation.eFilterOption.None;
			if (Global.Config.DispFinalFilter == 1) finalFilter = Filters.FinalPresentation.eFilterOption.Bilinear;
			if (Global.Config.DispFinalFilter == 2) finalFilter = Filters.FinalPresentation.eFilterOption.Bicubic;
			//if bicubic is selected and unavailable, dont use it
			if (!ShaderChain_bicubic.Available && fPresent.FilterOption == Filters.FinalPresentation.eFilterOption.Bicubic)
			{
				finalFilter = Filters.FinalPresentation.eFilterOption.None;
			}
			fPresent.FilterOption = finalFilter;

			//now if bicubic is chosen, insert it
			if (finalFilter == Filters.FinalPresentation.eFilterOption.Bicubic)
				AppendRetroShaderChain(chain, "bicubic", ShaderChain_bicubic, null);

			//add final presentation 
			chain.AddFilter(fPresent, "presentation");

			//add lua layer 'native'
			AppendLuaLayer(chain, "native");

			//and OSD goes on top of that
			//TODO - things break if this isnt present (the final presentation filter gets messed up)
			//so, always include it (we'll handle this flag in the callback to do no rendering)
			//if (includeOSD)
				chain.AddFilter(fOSD, "osd");

			return chain;
		}