Esempio n. 1
0
        public void Execute(RenderWrap renderWrap)
        {
            var texInput  = renderWrap.GetRenderTexture2D(input);
            var texOutput = renderWrap.GetRenderTexture2D(output);
            int width     = texInput.width;
            int height    = texInput.height;

            renderWrap.SetRootSignature(rs);


            renderWrap.SetSRV(texInput, 0);
            renderWrap.SetUAV(texOutput, 0, 0);
            var writer = renderWrap.Writer;

            writer.Write(width);
            writer.Write(height);
            writer.SetCBV(0);
            renderWrap.Dispatch(shader, null, (width + 15) / 16, (height + 15) / 16);

            int x = width;
            int y = height;

            for (int i = 1; i < 9; i++)
            {
                x = (x + 1) / 2;
                y = (y + 1) / 2;

                writer.Write(x);
                writer.Write(y);
                writer.SetCBV(0);
                renderWrap.SetSRVLim(texOutput, i - 1, 0);
                renderWrap.SetUAV(texOutput, i, 0);
                renderWrap.Dispatch(shader, null, (x + 15) / 16, (y + 15) / 16);
            }
        }
        public bool Bake(TextureCube texture, RenderWrap renderWrap, ref object tag)
        {
            var tex = renderWrap.GetTex2D(Source);

            if (tex == null || tex.Status != GraphicsObjectStatus.loaded)
            {
                return(false);
            }
            renderWrap.SetRootSignature("Csu");
            int width  = texture.width;
            int height = texture.height;
            var writer = renderWrap.Writer;

            writer.Write(width);
            writer.Write(height);
            writer.SetCBV(0);
            renderWrap.SetSRVs(new string[] { Source });
            renderWrap.SetUAV(texture, 0, 0);
            renderWrap.Dispatch("ConvertToCube.hlsl", null, width / 8, height / 8, 6);
            for (int i = 1; i < texture.mipLevels; i++)
            {
                int mipPow = 1 << i;
                renderWrap.SetSRVLim(texture, i - 1, 0);
                renderWrap.SetUAV(texture, i, 0);
                writer.Write(width / mipPow);
                writer.Write(height / mipPow);
                writer.Write(i - 1);
                writer.SetCBV(0);
                renderWrap.Dispatch("GenerateCubeMipMap.hlsl", null, width / mipPow / 8, height / mipPow / 8, 6);
            }
            return(true);
        }
Esempio n. 3
0
        public bool Bake(Texture2D texture, RenderWrap renderWrap, ref object tag)
        {
            renderWrap.SetRootSignature("");
            renderWrap.SetRenderTarget(texture, true);
            var psoDesc = new PSODesc()
            {
                blendState        = BlendState.None,
                cullMode          = CullMode.None,
                rtvFormat         = texture.GetFormat(),
                inputLayout       = InputLayout.Default,
                renderTargetCount = 1,
            };

            renderWrap.SetShader("BRDFLUT.hlsl", psoDesc);
            renderWrap.DrawQuad();
            return(true);
        }
Esempio n. 4
0
        public void Execute(RenderWrap renderWrap)
        {
            renderWrap.SetRootSignature("Csssu");

            List <(string, string)> keywords = new List <(string, string)>();

            keywords.Add(("ENABLE_TAA", "1"));
            if (DebugRenderType == DebugRenderType.TAA)
            {
                keywords.Add(("DEBUG_TAA", "1"));
            }

            var tex    = renderWrap.GetTex2D(target);
            var writer = renderWrap.Writer;

            renderWrap.Write(cbv, writer);
            writer.SetCBV(0);

            renderWrap.SetSRVs(new string[] { depth, history, historyDepth });
            renderWrap.SetUAV(renderWrap.GetRenderTexture2D(target), 0);
            renderWrap.Dispatch("TAA.hlsl", keywords, (tex.width + 7) / 8, (tex.height + 7) / 8);
        }
Esempio n. 5
0
        public void Execute(RenderWrap renderWrap)
        {
            var outputTexture = renderWrap.GetRenderTexture2D("intermedia2");

            renderWrap.ClearTexture(outputTexture);
            if (EnableBloom)
            {
                generateMipPass.input  = inputColor;
                generateMipPass.output = "intermedia3";
                generateMipPass.Execute(renderWrap);
                var inputTexture = renderWrap.GetRenderTexture2D(inputColor);

                int  r = 0;
                uint n = (uint)(inputTexture.height / 1024);
                while (n > 0)
                {
                    r++;
                    n >>= 1;
                }
                bloomPass.mipLevel  = r;
                bloomPass.inputSize = (inputTexture.width / 2, inputTexture.height / 2);

                //bloomPass.input = inputColor;
                bloomPass.input  = "intermedia3";
                bloomPass.output = "intermedia2";
                bloomPass.Execute(renderWrap);
                postProcess.srvs[0] = inputColor;
                postProcess.srvs[1] = "intermedia2";
            }
            else
            {
                postProcess.srvs[0] = inputColor;
                postProcess.srvs[1] = "intermedia2";
            }

            postProcess.renderTargets[0] = output;
            postProcess.Execute(renderWrap);
        }
Esempio n. 6
0
 public abstract void Execute(RenderWrap renderWrap);
Esempio n. 7
0
        public bool Bake(TextureCube texture, RenderWrap renderWrap, ref object tag)
        {
            var tex = renderWrap.GetTexCube(Source);

            if (tex == null || tex.Status != GraphicsObjectStatus.loaded)
            {
                return(false);
            }

            int currentQuality;

            if (tag is int val)
            {
                currentQuality = val;
            }
            else
            {
                currentQuality = 0;
            }

            renderWrap.SetRootSignature("Csu");
            int width  = texture.width;
            int height = texture.height;
            var writer = renderWrap.Writer;

            int roughnessLevel = 5;

            {
                int t1   = roughnessLevel + 1;
                int face = 0;

                int mipLevel = currentQuality % t1;
                int quality  = currentQuality / t1;
                int pow2a    = 1 << mipLevel;
                writer.Write(width / pow2a);
                writer.Write(height / pow2a);
                writer.Write(quality);
                writer.Write(quality);
                writer.Write(Math.Max(mipLevel * mipLevel / (4.0f * 4.0f), 1e-3f));
                writer.Write(face);
                writer.SetCBV(0);

                renderWrap.SetSRV(tex, 0);
                renderWrap.SetUAV(texture, mipLevel, 0);

                if (mipLevel != roughnessLevel)
                {
                    renderWrap.Dispatch("PreFilterEnv.hlsl", null, width / 8 / pow2a, height / 8 / pow2a, 6);
                }
                else
                {
                    renderWrap.Dispatch("IrradianceMap.hlsl", null, width / 8 / pow2a, height / 8 / pow2a, 6);
                }

                currentQuality++;
            }
            tag = currentQuality;
            if (currentQuality < 256)
            {
                return(false);
            }
            else
            {
                return(true);
            }
        }