Пример #1
0
        public void GaussianBlurRadius11_ShouldBlur()
        {
            preblur = new RenderImage("testGaussianBlur", 1280, 768);
            blur = new RenderImage("testGaussianBlur1", 1280, 768);
            _gaussianBlur = new GaussianBlur(_resourceManager);

            _gaussianBlur.SetRadius(11);
            _gaussianBlur.SetAmount(2);
            _gaussianBlur.SetSize(new Size((int)preblur.Width, (int)preblur.Height));

            while (CluwneLib.IsRunning)
            {
                var lastFrameTime = clock.ElapsedTime.AsSeconds();
                clock.Restart();
                _frameEvent = new FrameEventArgs(lastFrameTime);
                CluwneLib.ClearCurrentRendertarget(Color.Black);
                CluwneLib.Screen.DispatchEvents();

                preblur.BeginDrawing(); // set temp as CRT (Current Render Target)
                preblur.Clear();       //Clear
                _resourceManager.GetSprite("AAAA").Draw(); //Draw NoSpritelogo
                preblur.EndDrawing();  // set previous rendertarget as CRT (screen in this case)

                _gaussianBlur.PerformGaussianBlur(preblur); // blur rendertarget

                preblur.Blit(0,0, 1280, 768); // draw blurred nosprite logo

                CluwneLib.Screen.Display();

            }
        }
        public ScrollableContainer(string uniqueName, Size size, IResourceManager resourceManager)
        {
            _resourceManager = resourceManager;

            Size = size;

            //if (RenderTargetCache.Targets.Contains(uniqueName))
            //    //Now this is an ugly hack to work around duplicate RenderImages. Have to fix this later.
            //    uniqueName = uniqueName + Guid.NewGuid();

            clippingRI = new RenderImage((uint)Size.Width,(uint) Size.Height);
                clippingRI.setName = uniqueName;
                clippingRI.setImageBuffer = ImageBufferFormats.BufferRGB888A8;
            scrollbarH = new Scrollbar(true, _resourceManager);
            scrollbarV = new Scrollbar(false, _resourceManager);
            scrollbarV.size = Size.Height;

            scrollbarH.Update(0);
            scrollbarV.Update(0);

            //clippingRI.SourceBlend = AlphaBlendOperation.SourceAlpha;
            //clippingRI.DestinationBlend = AlphaBlendOperation.InverseSourceAlpha;

            //clippingRI.SourceBlendAlpha = AlphaBlendOperation.SourceAlpha;
            //clippingRI.DestinationBlendAlpha = AlphaBlendOperation.InverseSourceAlpha;

            Update(0);
        }
Пример #3
0
        public void CreateStarScroller_ShouldCreateStars()
        {
            base.InitializeCluwneLib(1280, 720, false, 60);
            Stars = new StarScroller();
            renderimage = new RenderImage("StarScroller", 1920, 1080);

            while (CluwneLib.IsRunning)
            {
                var lastFrameTime = clock.ElapsedTime.AsSeconds();
                clock.Restart();
                _frameEvent = new FrameEventArgs(lastFrameTime);
                CluwneLib.ClearCurrentRendertarget(SFML.Graphics.Color.Black);
                CluwneLib.Screen.DispatchEvents();

                renderimage.BeginDrawing(); // set temp as CRT (Current Render Target)
                renderimage.Clear();       //Clear
                base.GetResourceManager.GetSprite("AAAA").Draw(); //Draw NoSpritelogo

                renderimage.EndDrawing();  // set previous rendertarget as CRT (screen in this case)

                renderimage.Blit(0, 0, 1280, 768); // draw blurred nosprite logo

                CluwneLib.Screen.Display();

            }
        }
Пример #4
0
 public void ApplyEffects(RenderImage image)
 {
     foreach (PostProcessingEffect e in _effects)
     {
         e.ProcessImage(image);
     }
 }
Пример #5
0
        public LightArea(ShadowmapSize shadowmapSize)
        {
            int baseSize = 2 << (int)shadowmapSize;
            LightAreaSize = new Vector2(baseSize, baseSize);
            renderTarget = new RenderImage("LightArea"+ shadowmapSize,(uint)baseSize, (uint)baseSize);

            Mask = IoCManager.Resolve<IResourceManager>().GetSprite("whitemask");
        }
 public override void Dispose()
 {
     if (disposing) return;
     disposing = true;
     components.ForEach(c => c.Dispose());
     components.Clear();
     clippingRI.Dispose();
     clippingRI = null;
     base.Dispose();
     GC.SuppressFinalize(this);
 }
        public override void ProcessImage(RenderImage image)
        {
            if (_duration < 3)
                _gaussianBlur.SetRadius(3);
            else if (_duration < 10)
                _gaussianBlur.SetRadius(5);
            else
                _gaussianBlur.SetRadius(7);

            _gaussianBlur.SetSize(new SizeF(image.Height, image.Height));
            _gaussianBlur.SetAmount(Math.Min(_duration/2, 3f));
            _gaussianBlur.PerformGaussianBlur(image);
        }
 public void ResolveShadows(Image shadowCastersTexture, RenderImage result, Vector2 lightPosition,
                            bool attenuateShadows, Image mask, Vector4 maskProps, Vector4 diffuseColor)
 {
     //resolveShadowsEffect.Parameters["AttenuateShadows"].SetValue(attenuateShadows ? 0 : 1);
     //resolveShadowsEffect.Parameters["MaskProps"].SetValue(maskProps);
     //resolveShadowsEffect.Parameters["DiffuseColor"].SetValue(diffuseColor);
   //  CluwneLib.CurrentRenderTarget.BlendingMode = BlendingModes.None;
     ExecuteTechnique(shadowCastersTexture, distancesRT, "ComputeDistances");
   //  ExecuteTechnique(distancesRT.Image, distortRT, "Distort");
     ApplyHorizontalReduction(distortRT, shadowMap);
     ExecuteTechnique(mask, result, "DrawShadows", shadowMap);
     //ExecuteTechnique(shadowsRT.Image, processedShadowsRT, "BlurHorizontally");
     //ExecuteTechnique(processedShadowsRT.Image, result, "BlurVerticallyAndAttenuate");
     CluwneLib.CurrentShader = null;
 }
        public override void ProcessImage(RenderImage image)
        {
            var OstafLikesTheCock = new RenderImage(image.Height, image.Height);

            CluwneLib.CurrentRenderTarget = OstafLikesTheCock;

            image.Blit(0, 0, image.Height, image.Height, Color.White, BlitterSizeMode.Crop);
            CluwneLib.CurrentRenderTarget = image;
            CluwneLib.CurrentShader = _shader;
            _shader.SetParameter("SceneTexture", OstafLikesTheCock);
            _shader.setDuration((Math.Abs(_duration)));
            OstafLikesTheCock.Blit(0, 0, image.Height, image.Height, Color.White, BlitterSizeMode.Crop);

            CluwneLib.CurrentRenderTarget = null;
            CluwneLib.CurrentShader = null;
            OstafLikesTheCock.Dispose();
        }
        public override void ProcessImage(RenderImage image)
        {
            var OstafLikesTheCock = new RenderImage("CockLoverOstaf", image.Height, image.Height);

            OstafLikesTheCock.BeginDrawing();
                image.Blit(0, 0, image.Height, image.Height, SFML.Graphics.Color.White, BlitterSizeMode.Crop);
            OstafLikesTheCock.EndDrawing();

            image.BeginDrawing();
                _shader.setAsCurrentShader();
                _shader.SetParameter("SceneTexture", OstafLikesTheCock);
                _shader.setDuration((Math.Abs(_duration)));
                OstafLikesTheCock.Blit(0, 0, image.Height, image.Height, SFML.Graphics.Color.White, BlitterSizeMode.Crop);
            image.EndDrawing();

            _shader.ResetCurrentShader();
            OstafLikesTheCock.Dispose();
        }
Пример #11
0
        private void ExecuteTechnique(Image source, RenderImage destination, string techniqueName, RenderImage shadowMap)
        {
            Vector2 renderTargetSize;
            renderTargetSize = new Vector2(baseSize, baseSize);
            CluwneLib.CurrentRenderTarget = destination;
            CluwneLib.CurrentRenderTarget.Clear(Color.White.ToSFMLColor());

           //CluwneLib.CurrentShader = resolveShadowsEffect.Techniques[techniqueName];
           // resolveShadowsEffect.Parameters["renderTargetSize"].SetValue(renderTargetSize);
           // if (source != null)
           //     resolveShadowsEffect.Parameters["InputTexture"].SetValue(source);
           // if (shadowMap != null)
           //     resolveShadowsEffect.Parameters["ShadowMapTexture"].SetValue(shadowMap);

            quadRender.Render(new Vector2(1, 1)*-1, new Vector2(1, 1));

            CluwneLib.CurrentRenderTarget = null;
        }
Пример #12
0
        public void LoadContent()
        {
            reductionEffect = _resourceManager.GetShader("reductionEffect");
            resolveShadowsEffect = _resourceManager.GetShader("resolveShadowsEffect");

            //// BUFFER TYPES ARE VERY IMPORTANT HERE AND IT WILL BREAK IF YOU CHANGE THEM!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
            //distortRT = new RenderImage("distortRT" + baseSize, baseSize, baseSize, ImageBufferFormats.BufferGR1616F);
            //distancesRT = new RenderImage("distancesRT" + baseSize, baseSize, baseSize, ImageBufferFormats.BufferGR1616F);
            //shadowMap = new RenderImage("shadowMap" + baseSize, 2, baseSize, ImageBufferFormats.BufferGR1616F);
            reductionRT = new RenderImage[reductionChainCount];
            for (int i = 0; i < reductionChainCount; i++)
            {
                reductionRT[i] = new RenderImage("reductionRT" + i + baseSize, 2 << i, baseSize,
                                                 ImageBufferFormats.BufferGR1616F);
            }
            shadowsRT = new RenderImage("shadowsRT" + baseSize, baseSize, baseSize, ImageBufferFormats.BufferRGB888A8);
            processedShadowsRT = new RenderImage("processedShadowsRT" + baseSize, baseSize, baseSize,
                                                 ImageBufferFormats.BufferRGB888A8);
        }
Пример #13
0
 public static void DebugRendertarget(RenderImage Rendertarget)
 {
     DebugRendertarget(Rendertarget, Rendertarget.Key);
 }
 public virtual void ProcessImage(RenderImage image)
 {
 }
Пример #15
0
        public void PerformGaussianBlur(RenderImage sourceImage)
        {
            // Perform horizontal Gaussian blur.
            _intermediateTarget = new RenderImage(sourceImage.Width, sourceImage.Height);
            _intermediateTarget.setName = targetName;
            _intermediateTarget.Clear(Color.Black);

            CluwneLib.CurrentRenderTarget = _intermediateTarget;
            CluwneLib.CurrentShader = _shader; //TODO .Techniques["GaussianBlurHorizontal"];

           // _shader.setParameter("weights_offsets").SetValue(WeightsOffsetsX);
           // _shader.setParameters["colorMapTexture"].SetValue(sourceImage.Image);

            sourceImage.Blit(0, 0, sourceImage.Width, sourceImage.Height);

            // Perform vertical Gaussian blur.
          CluwneLib.CurrentRenderTarget = sourceImage;
          CluwneLib.CurrentShader = _shader; //.Techniques["GaussianBlurVertical"];

            //   _shader.Parameters["colorMapTexture"].SetValue(_intermediateTarget.Image);
            //_shader.Parameters["weights_offsets"].SetValue(WeightsOffsetsY);

            //_intermediateTargetSprite.Draw();
            _intermediateTarget.Blit(0, 0, sourceImage.Width, sourceImage.Height);

            CluwneLib.CurrentShader = null;
            CluwneLib.CurrentRenderTarget = null;
            _intermediateTarget.Dispose();
        }
Пример #16
0
 public void Blit(RenderImage target)
 {
     Blit(new SFML.System.Vector2f(), new SFML.System.Vector2f(target.Size.X, target.Size.Y), Color.White);
 }
Пример #17
0
 public void SetParameter(string Parameter, RenderImage Image)
 {
     base.SetParameter(Parameter, Image.Texture);
 }
Пример #18
0
        public void PerformGaussianBlur(RenderImage sourceImage)
        {
            // Blur the source horizontally
            _intermediateTarget = new RenderImage("intermediateTarget",sourceImage.Width, sourceImage.Height);
            _intermediateTarget.Key = targetName;

            _intermediateTarget.BeginDrawing(); //stores screen, makes current

            GaussianBlurTechnique["GaussianBlur" + Radius + "Horizontal"].SetParameter("colorMapTexture", GLSLShader.CurrentTexture);
            GaussianBlurTechnique["GaussianBlur" + Radius + "Horizontal"].SetParameter("weights_offsets", WeightsOffsetsX);

            GaussianBlurTechnique["GaussianBlur" + Radius + "Horizontal"].setAsCurrentShader(); //.Techniques["GaussianBlurHorizontal"];

            sourceImage.Blit(0, 0, sourceImage.Width, sourceImage.Height);
            _intermediateTarget.EndDrawing();
            GaussianBlurTechnique["GaussianBlur" + Radius + "Horizontal"].ResetCurrentShader();

            //// blur the blur vertically
            sourceImage.BeginDrawing();

            GaussianBlurTechnique["GaussianBlur" + Radius + "Vertical"].SetParameter("colorMapTexture", GLSLShader.CurrentTexture);
            GaussianBlurTechnique["GaussianBlur" + Radius + "Vertical"].SetParameter("weights_offsets", WeightsOffsetsY);

            GaussianBlurTechnique["GaussianBlur" + Radius + "Vertical"].setAsCurrentShader() ; //.Techniques["GaussianBlurVertical"];

            _intermediateTarget.Blit(0, 0, _intermediateTarget.Width, _intermediateTarget.Height);
            sourceImage.EndDrawing();

            CluwneLib.CurrentShader = null;

            _intermediateTarget.Dispose();
        }
Пример #19
0
        private void ApplyHorizontalReduction(RenderImage source, RenderImage destination)
        {
            int step = reductionChainCount - 1;
            RenderImage s = source;
            RenderImage d = reductionRT[step];
          //  CluwneLib.CurrentShader = reductionEffect.Techniques["HorizontalReduction"];

            while (step >= 0)
            {
                d = reductionRT[step];

                CluwneLib.CurrentRenderTarget = d;
                d.Clear(Color.White);

             //   reductionEffect.Parameters["SourceTexture"].SetValue(s);
                var textureDim = new Vector2(1.0f/s.Width, 1.0f/s.Height);
           //     reductionEffect.Parameters["TextureDimensions"].SetValue(textureDim);
                quadRender.Render(new Vector2(1, 1)*-1, new Vector2(1, 1));
                s = d;
                step--;
            }

            //copy to destination
            CluwneLib.CurrentRenderTarget = destination;
           // CluwneLib.CurrentShader = reductionEffect.Techniques["Copy"];
      //      reductionEffect.Parameters["SourceTexture"].SetValue(d);
            CluwneLib.CurrentRenderTarget.Clear(Color.White.ToSFMLColor());
            quadRender.Render(new Vector2(1, 1)*-1, new Vector2(1, 1));

       //     reductionEffect.Parameters["SourceTexture"].SetValue(reductionRT[reductionChainCount - 1]);
            CluwneLib.CurrentRenderTarget = null;
        }
Пример #20
0
        public static void DebugRendertarget(RenderImage Rendertarget, string fileName)
        {
            string path = "..\\DEBUGTEXTURE\\" + fileName + ".png";

               // Rendertarget.Texture.CopyToImage().SaveToFile(path);
        }
Пример #21
0
 private void ExecuteTechnique(Image source, RenderImage destination, string techniqueName)
 {
     ExecuteTechnique(source, destination, techniqueName, null);
 }