コード例 #1
0
        public RenderTexture ApplyToAndReturn(RenderTexture source, SleekRenderSettings settings)
        {
            Vector4 luminanceThreshold = HelperExtensions.GetLuminanceThreshold(settings);

            // Changing current Luminance Const value just to make sure that we have the latest settings in our Uniforms
            _brightpassBlurMaterial.SetVector(Uniforms._LuminanceThreshold, luminanceThreshold);
            _brightpassBlurMaterial.SetVector(Uniforms._TexelSize, new Vector2(1f / _blurTextures[0].width, 1f / _blurTextures[0].height));

            var currentTargetRenderTexture  = _blurTextures[0];
            var previousTargetRenderTexture = _blurTextures[0];
            var passes = _blurTextures.Length;

            for (int i = 0; i < passes; i++)
            {
                currentTargetRenderTexture = _blurTextures[i];

                // We use a different material for the first blur pass
                if (i == 0)
                {
                    // Applying downsample + brightpass (stored in Alpha)
                    _renderer.Blit(source, currentTargetRenderTexture, _brightpassBlurMaterial);
                }
                else
                {
                    _downsampleBlurMaterial.SetVector(Uniforms._TexelSize, new Vector2(1f / currentTargetRenderTexture.width, 1f / currentTargetRenderTexture.height));
                    // Applying only blur to our already brightpassed texture
                    _renderer.Blit(previousTargetRenderTexture, currentTargetRenderTexture, _downsampleBlurMaterial);
                }

                previousTargetRenderTexture = currentTargetRenderTexture;
            }

            return(currentTargetRenderTexture);
        }
コード例 #2
0
 private void CreateDefaultSettingsIfNoneLinked()
 {
     if (settings == null)
     {
         settings      = ScriptableObject.CreateInstance <SleekRenderSettings>();
         settings.name = "Default Settings";
     }
 }
コード例 #3
0
        public bool SomeSettingsHaveChanged(SleekRenderSettings settings)
        {
            var textureWidthIsWrong = settings.preserveAspectRatio ? false : settings.bloomTextureWidth != _baseTextureWidth;

            return(settings.bloomPasses != _bloomPasses ||
                   settings.bloomTextureHeight != _baseTextureHeight ||
                   settings.preserveAspectRatio != _preserveAspectRatio ||
                   textureWidthIsWrong);
        }
コード例 #4
0
        public static Vector4 GetLuminanceThreshold(SleekRenderSettings settings)
        {
            float oneOverOneMinusBloomThreshold = 1f / (1f - settings.bloomThreshold);
            var   luma = settings.bloomLumaVector;

            return(new Vector4(
                       luma.x * oneOverOneMinusBloomThreshold,
                       luma.y * oneOverOneMinusBloomThreshold,
                       luma.z * oneOverOneMinusBloomThreshold, -settings.bloomThreshold * oneOverOneMinusBloomThreshold));
        }
コード例 #5
0
        private void CalculateBloomHeightAndWidth(SleekRenderSettings settings, Camera camera)
        {
            _baseTextureHeight = settings.bloomTextureHeight;

            if (settings.preserveAspectRatio)
            {
                _baseTextureWidth = Mathf.RoundToInt(_baseTextureHeight * camera.aspect);
            }
            else
            {
                _baseTextureWidth = settings.bloomTextureWidth;
            }
        }
コード例 #6
0
        public void CreateResources(SleekRenderSettings settings, Camera camera)
        {
            _bloomPasses         = settings.bloomPasses;
            _preserveAspectRatio = settings.preserveAspectRatio;
            CalculateBloomHeightAndWidth(settings, camera);

            switch (_bloomPasses)
            {
            case 3:
                _blurTextures    = new RenderTexture[3];
                _blurTextures[0] = HelperExtensions.CreateTransientRenderTexture("Brightpass Blur 0",
                                                                                 _baseTextureWidth, _baseTextureHeight);

                _blurTextures[1] = HelperExtensions.CreateTransientRenderTexture("Downsample Blur 1",
                                                                                 _baseTextureWidth / 2, _baseTextureHeight / 2);

                _blurTextures[2] = HelperExtensions.CreateTransientRenderTexture("Downsample Blur 2",
                                                                                 _baseTextureWidth, _baseTextureHeight);
                break;

            default:
                _blurTextures    = new RenderTexture[5];
                _blurTextures[0] = HelperExtensions.CreateTransientRenderTexture("Brightpass Blur 0",
                                                                                 _baseTextureWidth, _baseTextureHeight);

                _blurTextures[1] = HelperExtensions.CreateTransientRenderTexture("Downsample Blur 1",
                                                                                 _baseTextureWidth / 2, _baseTextureHeight / 2);

                _blurTextures[2] = HelperExtensions.CreateTransientRenderTexture("Downsample Blur 2",
                                                                                 _baseTextureWidth / 4, _baseTextureHeight / 4);

                _blurTextures[3] = HelperExtensions.CreateTransientRenderTexture("Downsample Blur 4",
                                                                                 _baseTextureWidth / 2, _baseTextureHeight / 2);

                _blurTextures[4] = HelperExtensions.CreateTransientRenderTexture("Downsample Blur 4",
                                                                                 _baseTextureWidth, _baseTextureHeight);
                break;
            }

            _brightpassBlurMaterial = HelperExtensions.CreateMaterialFromShader("Sleek Render/Post Process/Brightpass Dualfilter Blur");
            _downsampleBlurMaterial = HelperExtensions.CreateMaterialFromShader("Sleek Render/Post Process/Downsample Dualfilter Blur");
        }
コード例 #7
0
        public static string GetTotalCostStringFor(SleekRenderSettings settings)
        {
            _sb.Remove(0, _sb.Length);
            _sb.Append("This info is VERY approximate and depends on target GPU architecture. Treat it as general performance overhead.\n\n");

            _sb.Append("Worst case (HiRez Low End GPU 2011-ish OpenGL ES 2.0 devices):\n\n");
            _sb.Append("\tBase overhead:\t2 ms\n");

            float totalCost = 2f;

            if (settings.bloomEnabled)
            {
                switch (settings.bloomPasses)
                {
                case 3:
                    _sb.Append("\tBloom:\t\t3 ms\n");
                    totalCost += 3f;
                    break;

                default:
                    _sb.Append("\tBloom:\t\t5 ms\n");
                    totalCost += 5f;
                    break;
                }
            }
            if (settings.colorizeEnabled)
            {
                _sb.Append("\tColorize:\t\t3 ms\n");
                totalCost += 3f;
            }
            if (settings.vignetteEnabled)
            {
                _sb.Append("\tVignette:\t\t0.5 ms\n");
                totalCost += 0.5f;
            }
            if (settings.brightnessContrastEnabled)
            {
                _sb.Append("\tBr./Contr:\t0.5ms\n");
                totalCost += 0.5f;
            }

            _sb.Append("\tTotal:\t\t" + totalCost.ToString("F2") + " ms\n\n");

            _sb.Append("General case (Arm Mali400 GPU with 480x864 screen resolution - Galaxy S2-ish):\n\n");

            _sb.Append("\tBase overhead:\t2 ms\n");
            totalCost = 2f;
            if (settings.bloomEnabled)
            {
                switch (settings.bloomPasses)
                {
                case 3:
                    _sb.Append("\tBloom:\t\t1 ms\n");
                    totalCost += 1f;
                    break;

                default:
                    _sb.Append("\tBloom:\t\t2 ms\n");
                    totalCost += 2f;
                    break;
                }
            }
            if (settings.colorizeEnabled)
            {
                _sb.Append("\tColorize:\t\t0.2 ms\n");
                totalCost += 0.2f;
            }
            if (settings.vignetteEnabled)
            {
                _sb.Append("\tVignette:\t\t0.2 ms\n");
                totalCost += 0.2f;
            }
            if (settings.brightnessContrastEnabled)
            {
                _sb.Append("\tBr./Contr:\t0.2ms\n");
                totalCost += 0.2f;
            }

            _sb.Append("\tTotal:\t\t" + totalCost.ToString("F2") + " ms\n\n");

            _sb.Append("Render target switch count (less is better):\n\n");

            _sb.Append("\tBase pipeline:\t4\n");
            int totalRenderTargetSwitchCount = 4;

            if (settings.bloomEnabled)
            {
                switch (settings.bloomPasses)
                {
                case 3:
                    _sb.Append("\tBloom:\t\t3\n");
                    totalRenderTargetSwitchCount += 3;
                    break;

                default:
                    _sb.Append("\tBloom:\t\t5\n");
                    totalRenderTargetSwitchCount += 5;
                    break;
                }
            }

            _sb.Append("\tTotal:\t\t" + totalRenderTargetSwitchCount.ToString("D") + "\n\n");

            return(_sb.ToString());
        }