예제 #1
0
        public bool AllocTextureArray(int numCubeMaps, int width, GraphicsFormat format, bool isMipMapped, Material cubeBlitMaterial)
        {
            var res = AllocTextureArray(numCubeMaps);

            m_NumMipLevels = GetNumMips(width, width);      // will calculate same way whether we have cube array or not

            if (!TextureCache.supportsCubemapArrayTextures)
            {
                m_CubeBlitMaterial = cubeBlitMaterial;

                int panoWidthTop  = 4 * width;
                int panoHeightTop = 2 * width;

                // create panorama 2D array. Hardcoding the render target for now. No convenient way atm to
                m_CacheNoCubeArray = new Texture2DArray(panoWidthTop, panoHeightTop, numCubeMaps, format, isMipMapped ? TextureCreationFlags.MipChain : TextureCreationFlags.None)
                {
                    hideFlags  = HideFlags.HideAndDontSave,
                    wrapMode   = TextureWrapMode.Repeat,
                    wrapModeV  = TextureWrapMode.Clamp,
                    filterMode = FilterMode.Trilinear,
                    anisoLevel = 0,
                    name       = CoreUtils.GetTextureAutoName(panoWidthTop, panoHeightTop, format, TextureDimension.Tex2DArray, depth: numCubeMaps, name: m_CacheName)
                };

                m_NumPanoMipLevels = isMipMapped ? GetNumMips(panoWidthTop, panoHeightTop) : 1;
                m_StagingRTs       = new RenderTexture[m_NumPanoMipLevels];
                for (int m = 0; m < m_NumPanoMipLevels; m++)
                {
                    m_StagingRTs[m] = new RenderTexture(Mathf.Max(1, panoWidthTop >> m), Mathf.Max(1, panoHeightTop >> m), 0, format)
                    {
                        hideFlags = HideFlags.HideAndDontSave
                    };
                    m_StagingRTs[m].name = CoreUtils.GetRenderTargetAutoName(Mathf.Max(1, panoWidthTop >> m), Mathf.Max(1, panoHeightTop >> m), 1, format, String.Format("PanaCache{0}", m));
                }

                if (m_CubeBlitMaterial)
                {
                    m_CubeMipLevelPropName = Shader.PropertyToID("_cubeMipLvl");
                    m_cubeSrcTexPropName   = Shader.PropertyToID("_srcCubeTexture");
                }
            }
            else
            {
                var desc = new RenderTextureDescriptor(width, width, format, 0)
                {
                    dimension        = TextureDimension.CubeArray,
                    volumeDepth      = numCubeMaps * 6, // We need to multiply by the face count of a cubemap here
                    autoGenerateMips = false,
                    useMipMap        = isMipMapped,
                    msaaSamples      = 1,
                };

                m_Cache = new RenderTexture(desc)
                {
                    hideFlags  = HideFlags.HideAndDontSave,
                    wrapMode   = TextureWrapMode.Clamp,
                    filterMode = FilterMode.Trilinear,
                    anisoLevel = 0, // It is important to set 0 here, else unity force anisotropy filtering
                    name       = CoreUtils.GetTextureAutoName(width, width, format, desc.dimension, depth: numCubeMaps, name: m_CacheName, mips: isMipMapped)
                };

                // We need to clear the content in case it is read on first frame, since on console we have no guarantee that
                // the content won't be NaN
                ClearCache();
                m_Cache.Create();
            }

            return(res);
        }
예제 #2
0
        public static bool RequiresIntermediateColorTexture(ref CameraData cameraData, RenderTextureDescriptor baseDescriptor)
        {
            if (cameraData.isOffscreenRender)
            {
                return(false);
            }

            bool isScaledRender         = !Mathf.Approximately(cameraData.renderScale, 1.0f);
            bool isTargetTexture2DArray = baseDescriptor.dimension == TextureDimension.Tex2DArray;
            bool noAutoResolveMsaa      = cameraData.msaaSamples > 1 && !SystemInfo.supportsMultisampleAutoResolve;

            return(noAutoResolveMsaa || cameraData.isSceneViewCamera || isScaledRender || cameraData.isHdrEnabled ||
                   cameraData.postProcessEnabled || cameraData.requiresOpaqueTexture || isTargetTexture2DArray || !cameraData.isDefaultViewport);
        }
예제 #3
0
 private static extern void INTERNAL_get_eyeTextureDesc(out RenderTextureDescriptor value);
예제 #4
0
        public void FrameUpdate(PipelineCamera cam, ref PipelineCommandData data)
        {
            CommandBuffer buffer = data.buffer;

            if (!Decal.decalDatas.isCreated)
            {
                buffer.SetGlobalInt(_EnableDecal, 0);
                return;
            }
            buffer.SetGlobalInt(_EnableDecal, 1);
            handle.Complete();
            if (cullJob.count > decalBuffer.count)
            {
                int oldCount = decalBuffer.count;
                decalBuffer.Dispose();
                decalBuffer = new ComputeBuffer((int)max(oldCount * 1.5f, cullJob.count), sizeof(DecalStrct));
            }
            if (!minMaxBoundMat)
            {
                minMaxBoundMat = new Material(data.resources.shaders.minMaxDepthBounding);
            }
            int pixelWidth  = cam.cam.pixelWidth;
            int pixelHeight = cam.cam.pixelHeight;

            decalBuffer.SetDataPtr(sortJob.sortedDecalDatas.unsafePtr, 0, cullJob.count);
            buffer.GetTemporaryRT(_DownSampledDepth0, pixelWidth / 2, pixelHeight / 2, 0, FilterMode.Point, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear, 1, false, RenderTextureMemoryless.None, false);
            buffer.GetTemporaryRT(_DownSampledDepth1, pixelWidth / 4, pixelHeight / 4, 0, FilterMode.Point, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear, 1, false, RenderTextureMemoryless.None, false);
            buffer.GetTemporaryRT(_DownSampledDepth2, pixelWidth / 8, pixelHeight / 8, 0, FilterMode.Point, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear, 1, false, RenderTextureMemoryless.None, false);
            buffer.GetTemporaryRT(_DownSampledDepth3, pixelWidth / 16, pixelHeight / 16, 0, FilterMode.Point, RenderTextureFormat.RGHalf, RenderTextureReadWrite.Linear, 1, false, RenderTextureMemoryless.None, false);
            buffer.BlitSRT(_DownSampledDepth0, minMaxBoundMat, 0);
            buffer.SetGlobalTexture(ShaderIDs._TargetDepthTexture, _DownSampledDepth0);
            buffer.BlitSRT(_DownSampledDepth1, minMaxBoundMat, 1);
            buffer.SetGlobalTexture(ShaderIDs._TargetDepthTexture, _DownSampledDepth1);
            buffer.BlitSRT(_DownSampledDepth2, minMaxBoundMat, 1);
            buffer.SetGlobalTexture(ShaderIDs._TargetDepthTexture, _DownSampledDepth2);
            buffer.BlitSRT(_DownSampledDepth3, minMaxBoundMat, 1);
            int2 tileSize = int2(pixelWidth / 16, pixelHeight / 16);
            RenderTextureDescriptor lightTileDisc = new RenderTextureDescriptor
            {
                autoGenerateMips  = false,
                bindMS            = false,
                colorFormat       = RenderTextureFormat.RInt,
                depthBufferBits   = 0,
                dimension         = TextureDimension.Tex3D,
                enableRandomWrite = true,
                width             = tileSize.x,
                height            = tileSize.y,
                msaaSamples       = 1,
                volumeDepth       = CBDRSharedData.MAXLIGHTPERTILE
            };

            buffer.GetTemporaryRT(ShaderIDs._DecalTile, lightTileDisc);
            tileSizeArray[0] = tileSize.x;
            tileSizeArray[1] = tileSize.y;
            float3 * corners  = stackalloc float3[4];
            PerspCam perspCam = new PerspCam
            {
                fov      = cam.cam.fieldOfView,
                up       = cam.cam.transform.up,
                right    = cam.cam.transform.right,
                forward  = cam.cam.transform.forward,
                position = cam.cam.transform.position,
                aspect   = cam.cam.aspect,
            };

            PipelineFunctions.GetFrustumCorner(ref perspCam, 1, corners);
            for (int i = 0; i < 4; ++i)
            {
                frustumCorners[i] = float4(corners[i], 1);
            }
            buffer.SetComputeVectorArrayParam(cbdrShader, ShaderIDs._FrustumCorners, frustumCorners);
            buffer.SetComputeVectorParam(cbdrShader, ShaderIDs._CameraPos, cam.cam.transform.position);
            buffer.SetComputeIntParams(cbdrShader, ShaderIDs._TileSize, tileSizeArray);
            buffer.SetGlobalVector(ShaderIDs._TileSize, new Vector4(tileSize.x, tileSize.y));
            buffer.SetComputeVectorParam(cbdrShader, ShaderIDs._CameraForward, cam.cam.transform.forward);
            buffer.SetComputeTextureParam(cbdrShader, CBDRSharedData.DecalCull, ShaderIDs._DepthBoundTexture, new RenderTargetIdentifier(_DownSampledDepth3));
            buffer.SetComputeTextureParam(cbdrShader, CBDRSharedData.DecalCull, ShaderIDs._DecalTile, new RenderTargetIdentifier(ShaderIDs._DecalTile));
            buffer.SetComputeBufferParam(cbdrShader, CBDRSharedData.DecalCull, ShaderIDs._AllDecals, decalBuffer);
            buffer.SetComputeIntParam(cbdrShader, ShaderIDs._DecalCount, cullJob.count);
            buffer.SetGlobalBuffer(ShaderIDs._AllDecals, decalBuffer);
            buffer.DispatchCompute(cbdrShader, CBDRSharedData.DecalCull, Mathf.CeilToInt(tileSize.x / 8f), Mathf.CeilToInt(tileSize.y / 8f), 1);
            buffer.ReleaseTemporaryRT(_DownSampledDepth0);
            buffer.ReleaseTemporaryRT(_DownSampledDepth1);
            buffer.ReleaseTemporaryRT(_DownSampledDepth2);
            buffer.ReleaseTemporaryRT(_DownSampledDepth3);
            RenderPipeline.ReleaseRTAfterFrame(ShaderIDs._DecalTile);
            decalCullResults.Dispose();
            decalCompareResults.Dispose();
        }
예제 #5
0
 private void MyAfterTransparent(Camera camera, ScriptableRenderContext context, RenderTargetIdentifier RTid, RenderTextureDescriptor Desc)
 {
 }
        /// <inheritdoc/>
        protected override void Setup()
        {
            var myCamera = perceptionCamera.GetComponent <Camera>();

            camWidth  = myCamera.pixelWidth;
            camHeight = myCamera.pixelHeight;

            if (labelConfig == null)
            {
                throw new InvalidOperationException(
                          "SemanticSegmentationLabeler's LabelConfig must be assigned");
            }

            m_AsyncAnnotations = new Dictionary <int, AsyncAnnotation>();

            if (targetTexture != null)
            {
                if (targetTexture.sRGB)
                {
                    Debug.LogError("targetTexture supplied to SemanticSegmentationLabeler must be in Linear mode. Disabling labeler.");
                    this.enabled = false;
                }
                var renderTextureDescriptor = new RenderTextureDescriptor(camWidth, camHeight, GraphicsFormat.R8G8B8A8_UNorm, 8);
                targetTexture.descriptor = renderTextureDescriptor;
            }
            else
            {
                m_TargetTextureOverride = new RenderTexture(camWidth, camHeight, 8, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
            }

            targetTexture.Create();
            targetTexture.name = "Labeling";

#if HDRP_PRESENT
            var gameObject       = perceptionCamera.gameObject;
            var customPassVolume = gameObject.GetComponent <CustomPassVolume>() ?? gameObject.AddComponent <CustomPassVolume>();
            customPassVolume.injectionPoint = CustomPassInjectionPoint.BeforeRendering;
            customPassVolume.isGlobal       = true;
            m_SemanticSegmentationPass      = new SemanticSegmentationPass(myCamera, targetTexture, labelConfig)
            {
                name = "Labeling Pass"
            };
            customPassVolume.customPasses.Add(m_SemanticSegmentationPass);
#endif
#if URP_PRESENT
            perceptionCamera.AddScriptableRenderPass(new SemanticSegmentationUrpPass(myCamera, targetTexture, labelConfig));
#endif

            var specs = labelConfig.labelEntries.Select((l) => new SemanticSegmentationSpec()
            {
                label_name  = l.label,
                pixel_value = l.color
            }).ToArray();

            m_SemanticSegmentationAnnotationDefinition = DatasetCapture.RegisterAnnotationDefinition(
                "semantic segmentation",
                specs,
                "pixel-wise semantic segmentation label",
                "PNG",
                id: Guid.Parse(annotationId));

            m_SemanticSegmentationTextureReader = new RenderTextureReader <Color32>(targetTexture, myCamera,
                                                                                    (frameCount, data, tex) => OnSemanticSegmentationImageRead(frameCount, data));

            visualizationEnabled = supportsVisualization;
        }
예제 #7
0
        /// <inheritdoc/>
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            if (m_CopyDepthMaterial == null)
            {
                Debug.LogErrorFormat("Missing {0}. {1} render pass will not execute. Check for missing reference in the renderer resources.", m_CopyDepthMaterial, GetType().Name);
                return;
            }
            CommandBuffer cmd = CommandBufferPool.Get();

            using (new ProfilingScope(cmd, ProfilingSampler.Get(URPProfileId.CopyDepth)))
            {
                int cameraSamples = 0;

                if (MssaSamples == -1)
                {
                    RenderTextureDescriptor descriptor = renderingData.cameraData.cameraTargetDescriptor;
                    cameraSamples = descriptor.msaaSamples;
                }
                else
                {
                    cameraSamples = MssaSamples;
                }

                CameraData cameraData = renderingData.cameraData;

                switch (cameraSamples)
                {
                case 8:
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
                    cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
                    break;

                case 4:
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
                    cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
                    break;

                case 2:
                    cmd.EnableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
                    break;

                // MSAA disabled
                default:
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa2);
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa4);
                    cmd.DisableShaderKeyword(ShaderKeywordStrings.DepthMsaa8);
                    break;
                }

                cmd.SetGlobalTexture("_CameraDepthAttachment", source.Identifier());


#if ENABLE_VR && ENABLE_XR_MODULE
                // XR uses procedural draw instead of cmd.blit or cmd.DrawFullScreenMesh
                if (renderingData.cameraData.xr.enabled)
                {
                    // XR flip logic is not the same as non-XR case because XR uses draw procedure
                    // and draw procedure does not need to take projection matrix yflip into account
                    // We y-flip if
                    // 1) we are bliting from render texture to back buffer and
                    // 2) renderTexture starts UV at top
                    // XRTODO: handle scalebias and scalebiasRt for src and dst separately
                    bool    isRenderToBackBufferTarget = destination.Identifier() == cameraData.xr.renderTarget && !cameraData.xr.renderTargetIsRenderTexture;
                    bool    yflip       = isRenderToBackBufferTarget && SystemInfo.graphicsUVStartsAtTop;
                    float   flipSign    = (yflip) ? -1.0f : 1.0f;
                    Vector4 scaleBiasRt = (flipSign < 0.0f)
                        ? new Vector4(flipSign, 1.0f, -1.0f, 1.0f)
                        : new Vector4(flipSign, 0.0f, 1.0f, 1.0f);
                    cmd.SetGlobalVector(ShaderPropertyId.scaleBiasRt, scaleBiasRt);

                    cmd.DrawProcedural(Matrix4x4.identity, m_CopyDepthMaterial, 0, MeshTopology.Quads, 4);
                }
                else
#endif
                {
                    // Blit has logic to flip projection matrix when rendering to render texture.
                    // Currently the y-flip is handled in CopyDepthPass.hlsl by checking _ProjectionParams.x
                    // If you replace this Blit with a Draw* that sets projection matrix double check
                    // to also update shader.
                    // scaleBias.x = flipSign
                    // scaleBias.y = scale
                    // scaleBias.z = bias
                    // scaleBias.w = unused
                    // In game view final target acts as back buffer were target is not flipped
                    bool    isGameViewFinalTarget = (cameraData.cameraType == CameraType.Game && destination == RenderTargetHandle.CameraTarget);
                    bool    yflip       = (cameraData.IsCameraProjectionMatrixFlipped()) && !isGameViewFinalTarget;
                    float   flipSign    = yflip ? -1.0f : 1.0f;
                    Vector4 scaleBiasRt = (flipSign < 0.0f)
                        ? new Vector4(flipSign, 1.0f, -1.0f, 1.0f)
                        : new Vector4(flipSign, 0.0f, 1.0f, 1.0f);
                    cmd.SetGlobalVector(ShaderPropertyId.scaleBiasRt, scaleBiasRt);

                    cmd.DrawMesh(RenderingUtils.fullscreenMesh, Matrix4x4.identity, m_CopyDepthMaterial);
                }
            }

            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }
예제 #8
0
 /// <summary>
 /// Configure the pass
 /// </summary>
 /// <param name="baseDescriptor"></param>
 /// <param name="colorHandle"></param>
 public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle)
 {
     m_Source = colorHandle;
 }
예제 #9
0
    private bool PopulateLayer(int mipLevels, bool isHdr, OVRPlugin.Sizei size, int sampleCount)
    {
        bool ret = false;

        RenderTextureFormat rtFormat = (isHdr) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGB32;

        for (int eyeId = 0; eyeId < texturesPerStage; ++eyeId)
        {
            int dstElement = (layout == OVRPlugin.LayerLayout.Array) ? eyeId : 0;

            int     stage = frameIndex % stageCount;
            Texture et    = layerTextures[eyeId].swapChain[stage];
            if (et == null)
            {
                continue;
            }

            for (int mip = 0; mip < mipLevels; ++mip)
            {
#if UNITY_2017_1_1 || UNITY_2017_2_OR_NEWER
                int width = size.w >> mip;
                if (width < 1)
                {
                    width = 1;
                }
                int height = size.h >> mip;
                if (height < 1)
                {
                    height = 1;
                }

                RenderTextureDescriptor descriptor = new RenderTextureDescriptor(width, height, rtFormat, 0);
                descriptor.msaaSamples      = sampleCount;
                descriptor.useMipMap        = true;
                descriptor.autoGenerateMips = false;

                var tempRTDst = RenderTexture.GetTemporary(descriptor);
#else
                var tempRTDst = RenderTexture.GetTemporary(size.w >> mip, size.h >> mip, 0, rtFormat, RenderTextureReadWrite.Default, sampleCount);
#endif

                if (!tempRTDst.IsCreated())
                {
                    tempRTDst.Create();
                }

                tempRTDst.DiscardContents();

                if (currentOverlayShape != OverlayShape.Cubemap && currentOverlayShape != OverlayShape.OffcenterCubemap)
                {
#if UNITY_ANDROID && !UNITY_EDITOR
                    if (((textures[eyeId] as Cubemap) != null) &&
                        ((et as Cubemap) != null) &&
                        ((textures[eyeId] as Cubemap).format == (et as Cubemap).format))
                    {
                        Graphics.CopyTexture(textures[eyeId], 0, mip, et, 0, mip);
                    }
                    else
                    {
                        Graphics.Blit(textures[eyeId], tempRTDst);                         //Resolve, decompress, swizzle, etc not handled by simple CopyTexture.
                        Graphics.CopyTexture(tempRTDst, 0, 0, et, dstElement, mip);
                    }
#else
                    // The PC compositor uses premultiplied alpha, so multiply it here.
                    Graphics.Blit(textures[eyeId], tempRTDst, premultiplyMaterial);
                    Graphics.CopyTexture(tempRTDst, 0, 0, et, dstElement, mip);
#endif
                }
#if UNITY_2017_1_OR_NEWER
                else                 // Cubemap
                {
                    var tempRTSrc = RenderTexture.GetTemporary(size.w >> mip, size.h >> mip, 0, rtFormat, RenderTextureReadWrite.Default, sampleCount);

                    if (!tempRTSrc.IsCreated())
                    {
                        tempRTSrc.Create();
                    }

                    tempRTSrc.DiscardContents();

                    for (int face = 0; face < 6; ++face)
                    {
#if UNITY_ANDROID && !UNITY_EDITOR
                        if ((textures[eyeId] as Cubemap).format == (et as Cubemap).format)
                        {
                            Graphics.CopyTexture(textures[eyeId], face, mip, et, 0, mip);
                        }
                        else
                        {
                            //HACK: It would be much more efficient to blit directly from textures[eyeId] to et, but Unity's API doesn't support that.
                            //Suggest using a native plugin to render directly to a cubemap layer for 360 video, etc.
                            Graphics.CopyTexture(textures[eyeId], face, mip, tempRTSrc, 0, 0);
                            Graphics.Blit(tempRTSrc, tempRTDst);
                            Graphics.CopyTexture(tempRTDst, 0, 0, et, face, mip);
                        }
#else
                        //HACK: It would be much more efficient to blit directly from textures[eyeId] to et, but Unity's API doesn't support that.
                        //Suggest using a native plugin to render directly to a cubemap layer for 360 video, etc.
                        Graphics.CopyTexture(textures[eyeId], face, mip, tempRTSrc, 0, 0);
                        // The PC compositor uses premultiplied alpha, so multiply it here.
                        Graphics.Blit(tempRTSrc, tempRTDst, premultiplyMaterial);
                        Graphics.CopyTexture(tempRTDst, 0, 0, et, face, mip);
#endif
                    }
                    RenderTexture.ReleaseTemporary(tempRTSrc);
                }
#endif
                RenderTexture.ReleaseTemporary(tempRTDst);

                ret = true;
            }
        }

        return(ret);
    }
예제 #10
0
        public override void Render(PostProcessRenderContext context)
        {
            var cmd = context.command;

            cmd.BeginSample("ScanLine");
            RenderTextureDescriptor desc = new RenderTextureDescriptor(context.width, context.height);

            desc.enableRandomWrite = true;
            //cmd.GetTemporaryRT(tempCanvas, desc);
            desc.graphicsFormat = UnityEngine.Experimental.Rendering.GraphicsFormat.R32G32B32A32_SFloat;
            cmd.GetTemporaryRT(tempRTID1, desc);
            cmd.GetTemporaryRT(tempRTID2, desc);
            cmd.GetTemporaryRT(tempRTID3, desc);


            Matrix4x4 V      = Camera.main.worldToCameraMatrix;
            Matrix4x4 P      = GL.GetGPUProjectionMatrix(Camera.main.projectionMatrix, true);
            Matrix4x4 VP     = P * V;
            Matrix4x4 InvMVP = VP.inverse;

            // depth edge
            cmd.SetComputeIntParam(depthEdgeShader, "Width", context.width - 1);
            cmd.SetComputeIntParam(depthEdgeShader, "Height", context.height - 1);

            cmd.SetComputeFloatParam(depthEdgeShader, "EdgeStrength", settings.DepthEdgeStrength.value);

            cmd.SetComputeTextureParam(depthEdgeShader, sobelForDepthKernelID, "Source", BuiltinRenderTextureType.Depth);// or ResolvedDepth
            cmd.SetComputeTextureParam(depthEdgeShader, sobelForDepthKernelID, "Result", tempRTID1);
            cmd.DispatchCompute(depthEdgeShader, sobelForDepthKernelID, context.width, context.height, 1);


            // distance field
            cmd.SetComputeIntParam(distanceFieldShader, "Width", context.width - 1);
            cmd.SetComputeIntParam(distanceFieldShader, "Height", context.height - 1);
            cmd.SetComputeFloatParam(distanceFieldShader, "DistanceScale", settings.DistanceScale.value);
            cmd.SetComputeMatrixParam(distanceFieldShader, "InvVPMatrix", InvMVP);
            var tar = settings.Target.value;

            cmd.SetComputeFloatParams(distanceFieldShader, "Target", new float[3] {
                tar.x, tar.y, tar.z
            });
            cmd.SetComputeTextureParam(distanceFieldShader, distanceFromTargetKernelID, "Source", BuiltinRenderTextureType.Depth);// or ResolvedDepth
            cmd.SetComputeTextureParam(distanceFieldShader, distanceFromTargetKernelID, "Result", tempRTID2);
            cmd.DispatchCompute(distanceFieldShader, distanceFromTargetKernelID, context.width, context.height, 1);

            // distance field edge
            cmd.SetComputeFloatParam(depthEdgeShader, "EdgeStrength", settings.DistanceEdgeStrength.value);
            cmd.SetComputeFloatParam(depthEdgeShader, "DistanceThresold", settings.DistanceThresold.value);
            cmd.SetComputeTextureParam(depthEdgeShader, sobelForDisatnceKernelID, "Source", tempRTID2);// or ResolvedDepth
            cmd.SetComputeTextureParam(depthEdgeShader, sobelForDisatnceKernelID, "Result", tempRTID3);
            cmd.DispatchCompute(depthEdgeShader, sobelForDisatnceKernelID, context.width, context.height, 1);

            // mix color
            var depthColor = settings.DepthEdgeColor.value;

            cmd.SetComputeFloatParams(colorMixerShader, "DepthEdgeColor", new float[3] {
                depthColor.r, depthColor.g, depthColor.b
            });
            var distanceColor = settings.DistanceEdgeColor.value;

            cmd.SetComputeFloatParams(colorMixerShader, "DistanceEdgeColor", new float[3] {
                distanceColor.r, distanceColor.g, distanceColor.b
            });

            cmd.SetComputeTextureParam(colorMixerShader, colroMixerKernelID, "ColorSource", context.source);
            cmd.SetComputeTextureParam(colorMixerShader, colroMixerKernelID, "DepthSource", tempRTID1);
            cmd.SetComputeTextureParam(colorMixerShader, colroMixerKernelID, "DistanceSource", tempRTID3);

            cmd.SetComputeTextureParam(colorMixerShader, colroMixerKernelID, "Result", tempRTID2);
            cmd.DispatchCompute(colorMixerShader, colroMixerKernelID, context.width, context.height, 1);

            cmd.Blit(tempRTID2, context.destination);
            cmd.ReleaseTemporaryRT(tempRTID1);
            cmd.ReleaseTemporaryRT(tempRTID2);
            cmd.ReleaseTemporaryRT(tempRTID3);

            cmd.EndSample("ScanLine");
        }
예제 #11
0
        public void ScatterAlphamap(string editorUndoName)
        {
            Vector4[] layerMasks = { new Vector4(1, 0, 0, 0), new Vector4(0, 1, 0, 0), new Vector4(0, 0, 1, 0), new Vector4(0, 0, 0, 1) };

            Material copyTerrainLayerMaterial = TerrainPaintUtility.GetCopyTerrainLayerMaterial();

            for (int i = 0; i < m_TerrainTiles.Count; i++)
            {
                TerrainTile terrainTile = m_TerrainTiles[i];
                if (terrainTile.clippedLocal.width == 0 || terrainTile.clippedLocal.height == 0)
                {
                    continue;
                }

                if (onTerrainTileBeforePaint != null)
                {
                    onTerrainTileBeforePaint(terrainTile, ToolAction.PaintTexture, editorUndoName);
                }

                var rtdesc = new RenderTextureDescriptor(destinationRenderTexture.width, destinationRenderTexture.height, RenderTextureFormat.ARGB32);
                rtdesc.sRGB             = false;
                rtdesc.useMipMap        = false;
                rtdesc.autoGenerateMips = false;
                RenderTexture destTarget = RenderTexture.GetTemporary(rtdesc);
                RenderTexture.active = destTarget;

                var writeRect = new RectInt(
                    terrainTile.clippedLocal.x + terrainTile.rect.x - pixelRect.x + terrainTile.writeOffset.x,
                    terrainTile.clippedLocal.y + terrainTile.rect.y - pixelRect.y + terrainTile.writeOffset.y,
                    terrainTile.clippedLocal.width,
                    terrainTile.clippedLocal.height);

                var readRect = new Rect(
                    writeRect.x / (float)pixelRect.width,
                    writeRect.y / (float)pixelRect.height,
                    writeRect.width / (float)pixelRect.width,
                    writeRect.height / (float)pixelRect.height);

                destinationRenderTexture.filterMode = FilterMode.Point;

                for (int j = 0; j < terrainTile.terrain.terrainData.alphamapTextureCount; j++)
                {
                    Texture2D sourceTex = terrainTile.terrain.terrainData.alphamapTextures[j];
                    if ((sourceTex.width != targetTextureWidth) || (sourceTex.height != targetTextureHeight))
                    {
                        Debug.LogWarning("PaintContext alphamap operations must use the same resolution for all Terrains - mismatched Terrains are ignored.", terrainTile.terrain);
                        continue;
                    }

                    int mapIndex     = terrainTile.mapIndex;
                    int channelIndex = terrainTile.channelIndex;

                    Rect combineRect = new Rect(
                        terrainTile.clippedLocal.x / (float)sourceTex.width,
                        terrainTile.clippedLocal.y / (float)sourceTex.height,
                        terrainTile.clippedLocal.width / (float)sourceTex.width,
                        terrainTile.clippedLocal.height / (float)sourceTex.height);

                    copyTerrainLayerMaterial.SetTexture("_MainTex", destinationRenderTexture);
                    copyTerrainLayerMaterial.SetTexture("_OldAlphaMapTexture", sourceRenderTexture);
                    copyTerrainLayerMaterial.SetTexture("_AlphaMapTexture", sourceTex);
                    copyTerrainLayerMaterial.SetVector("_LayerMask", j == mapIndex ? layerMasks[channelIndex] : Vector4.zero);
                    copyTerrainLayerMaterial.SetPass(1);

                    GL.PushMatrix();
                    GL.LoadOrtho();
                    GL.LoadPixelMatrix(0, destTarget.width, 0, destTarget.height);

                    GL.Begin(GL.QUADS);
                    GL.Color(new Color(1.0f, 1.0f, 1.0f, 1.0f));

                    GL.MultiTexCoord2(0, readRect.x, readRect.y);
                    GL.MultiTexCoord2(1, combineRect.x, combineRect.y);
                    GL.Vertex3(writeRect.x, writeRect.y, 0.0f);
                    GL.MultiTexCoord2(0, readRect.x, readRect.yMax);
                    GL.MultiTexCoord2(1, combineRect.x, combineRect.yMax);
                    GL.Vertex3(writeRect.x, writeRect.yMax, 0.0f);
                    GL.MultiTexCoord2(0, readRect.xMax, readRect.yMax);
                    GL.MultiTexCoord2(1, combineRect.xMax, combineRect.yMax);
                    GL.Vertex3(writeRect.xMax, writeRect.yMax, 0.0f);
                    GL.MultiTexCoord2(0, readRect.xMax, readRect.y);
                    GL.MultiTexCoord2(1, combineRect.xMax, combineRect.y);
                    GL.Vertex3(writeRect.xMax, writeRect.y, 0.0f);

                    GL.End();
                    GL.PopMatrix();

                    if (TerrainPaintUtility.paintTextureUsesCopyTexture)
                    {
                        var rtdesc2 = new RenderTextureDescriptor(sourceTex.width, sourceTex.height, RenderTextureFormat.ARGB32);
                        rtdesc2.sRGB             = false;
                        rtdesc2.useMipMap        = true;
                        rtdesc2.autoGenerateMips = false;
                        var mips = RenderTexture.GetTemporary(rtdesc2);
                        if (!mips.IsCreated())
                        {
                            mips.Create();
                        }

                        // Composes mip0 in a RT with full mipchain.
                        Graphics.CopyTexture(sourceTex, 0, 0, mips, 0, 0);
                        Graphics.CopyTexture(destTarget, 0, 0, writeRect.x, writeRect.y, writeRect.width, writeRect.height, mips, 0, 0, terrainTile.clippedLocal.x, terrainTile.clippedLocal.y);
                        mips.GenerateMips();

                        // Copy them into sourceTex.
                        Graphics.CopyTexture(mips, sourceTex);

                        RenderTexture.ReleaseTemporary(mips);
                    }
                    else
                    {
                        GraphicsDeviceType deviceType = SystemInfo.graphicsDeviceType;
                        if (deviceType == GraphicsDeviceType.Metal || deviceType == GraphicsDeviceType.OpenGLCore)
                        {
                            sourceTex.ReadPixels(new Rect(writeRect.x, writeRect.y, writeRect.width, writeRect.height), terrainTile.clippedLocal.x, terrainTile.clippedLocal.y);
                        }
                        else
                        {
                            sourceTex.ReadPixels(new Rect(writeRect.x, destTarget.height - writeRect.y - writeRect.height, writeRect.width, writeRect.height), terrainTile.clippedLocal.x, terrainTile.clippedLocal.y);
                        }
                        sourceTex.Apply();
                    }
                }

                RenderTexture.active = null;
                RenderTexture.ReleaseTemporary(destTarget);

                OnTerrainPainted(terrainTile, ToolAction.PaintTexture);
            }
        }
예제 #12
0
 public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
 {
     base.Configure(cmd, cameraTextureDescriptor);
 }
예제 #13
0
 public static RenderTexture CreateRenderTexture(RenderTextureDescriptor rtDsc)
 {
     return(new RenderTexture(rtDsc));
 }
예제 #14
0
        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
        {
            if (!renderingData.cameraData.postProcessEnabled)
            {
                return;
            }

            var stack = VolumeManager.instance.stack;

            m_SunShafts = stack.GetComponent <SunShafts>();
            if (m_SunShafts == null)
            {
                return;
            }
            if (!m_SunShafts.IsActive())
            {
                return;
            }

            if (sunShaftsMaterial == null)
            {
                return;
            }

            var cmd = CommandBufferPool.Get(k_RenderTag);

            if (RenderSettings.sun == null)
            {
                return;
            }

            Vector3 vSun;
            bool    positiveZ = UpdateSun(renderingData.cameraData.camera, out vSun);

            int divider = 4;

            if (m_SunShafts.resolution == SunShaftsResolution.Normal)
            {
                divider = 2;
            }

            if (!positiveZ)
            {
                return;
            }

            float sradius = m_SunShafts.sunShaftBlurRadius.value;

            RenderTextureDescriptor desc = renderingData.cameraData.cameraTargetDescriptor;

            var material = sunShaftsMaterial;

            var destination = currentTarget;

            cmd.SetGlobalTexture(MainTexId, destination);
            cmd.GetTemporaryRT(TempTargetId, desc.width, desc.height, 0, FilterMode.Bilinear, desc.colorFormat);

            cmd.Blit(destination, TempTargetId);

            int rtW = desc.width / divider;
            int rtH = desc.height / divider;

            RenderTexture lrColorB;
            RenderTexture lrDepthBuffer = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);

            // mask out everything except the skybox
            // we have 2 methods, one of which requires depth buffer support, the other one is just comparing images

            material.SetVector("_SunPosition", new Vector4(vSun.x, vSun.y, vSun.z, m_SunShafts.maxRadius.value));

            cmd.Blit(TempTargetId, lrDepthBuffer, material, 2);
            // paint a small black small border to get rid of clamping problems
            //DrawBorder(lrDepthBuffer, Color.clear);

            // radial blur:

            m_SunShafts.radialBlurIterations.value = Mathf.Clamp(m_SunShafts.radialBlurIterations.value, 1, 4);

            int iter = m_SunShafts.radialBlurIterations.value;

            float ofs = sradius * (1.0f / 768.0f);

            material.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
            material.SetVector("_SunPosition", new Vector4(vSun.x, vSun.y, vSun.z, m_SunShafts.maxRadius.value));

            for (int it2 = 0; it2 < iter; it2++)
            {
                // each iteration takes 2 * 6 samples
                // we update _BlurRadius each time to cheaply get a very smooth look

                lrColorB = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
                cmd.Blit(lrDepthBuffer, lrColorB, material, 1);
                RenderTexture.ReleaseTemporary(lrDepthBuffer);
                ofs = sradius * (((it2 * 2.0f + 1.0f) * 6.0f)) / 768.0f;
                material.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));

                lrDepthBuffer = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
                cmd.Blit(lrColorB, lrDepthBuffer, material, 1);
                RenderTexture.ReleaseTemporary(lrColorB);
                ofs = sradius * (((it2 * 2.0f + 2.0f) * 6.0f)) / 768.0f;
                material.SetVector("_BlurRadius4", new Vector4(ofs, ofs, 0.0f, 0.0f));
            }

            if (m_SunShafts.lastBlur.value)
            {
                lrColorB = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
                cmd.Blit(lrDepthBuffer, lrColorB, material, 5);
                RenderTexture.ReleaseTemporary(lrDepthBuffer);

                lrDepthBuffer = RenderTexture.GetTemporary(rtW, rtH, 0, desc.colorFormat);
                cmd.Blit(lrColorB, lrDepthBuffer, material, 6);
                RenderTexture.ReleaseTemporary(lrColorB);
            }

            // put together:
            material.SetTexture("_ColorBuffer", lrDepthBuffer);
            cmd.Blit(TempTargetId, destination, material, (m_SunShafts.screenBlendMode == ShaftsScreenBlendMode.Screen) ? 0 : 4);

            RenderTexture.ReleaseTemporary(lrDepthBuffer);

            cmd.ReleaseTemporaryRT(TempTargetId);

            context.ExecuteCommandBuffer(cmd);
            CommandBufferPool.Release(cmd);
        }
예제 #15
0
        /// <summary>Renders a vector sprite to Texture2D.</summary>
        /// <param name="sprite">The sprite to render</param>
        /// <param name="width">The desired width of the resulting texture</param>
        /// <param name="height">The desired height of the resulting texture</param>
        /// <param name="mat">The material used to render the sprite</param>
        /// <param name="antiAliasing">The number of samples per pixel for anti-aliasing</param>
        /// <param name="expandEdges">When true, expand the edges to avoid a dark banding effect caused by filtering. This is slower to render and uses more graphics memory.</param>
        /// <returns>A Texture2D object containing the rendered vector sprite</returns>
        public static Texture2D RenderSpriteToTexture2D(Sprite sprite, int width, int height, Material mat, int antiAliasing = 1, bool expandEdges = false)
        {
            if (width <= 0 || height <= 0)
            {
                return(null);
            }

            RenderTexture tex       = null;
            var           oldActive = RenderTexture.active;

            var desc = new RenderTextureDescriptor(width, height, RenderTextureFormat.ARGB32, 0)
            {
                msaaSamples = 1,
                sRGB        = true
            };

            if (expandEdges)
            {
                // Draw the sprite normally to be used as a background, no-antialiasing
                var normalTex = RenderTexture.GetTemporary(desc);
                RenderTexture.active = normalTex;
                RenderSprite(sprite, mat);

                // Expand the edges and make completely transparent
                if (s_ExpandEdgesMat == null)
                {
                    s_ExpandEdgesMat = new Material(Shader.Find("Hidden/VectorExpandEdges"));
                }

                var expandTex = RenderTexture.GetTemporary(desc);
                RenderTexture.active = expandTex;
                GL.Clear(false, true, Color.clear);
                Graphics.Blit(normalTex, expandTex, s_ExpandEdgesMat, 0);
                RenderTexture.ReleaseTemporary(normalTex);

                // Draw the sprite again, but clear with the texture rendered in the previous step,
                // this will make the bilinear filter to interpolate the colors with values different
                // than "transparent black", which causes black-ish outlines around the shape.
                desc.msaaSamples = antiAliasing;
                tex = RenderTexture.GetTemporary(desc);
                RenderTexture.active = tex;
                Graphics.Blit(expandTex, tex);
                RenderTexture.ReleaseTemporary(expandTex); // Use the expanded texture to clear the buffer

                RenderTexture.active = tex;
                RenderSprite(sprite, mat, false);
            }
            else
            {
                desc.msaaSamples = antiAliasing;
                tex = RenderTexture.GetTemporary(desc);
                RenderTexture.active = tex;
                RenderSprite(sprite, mat);
            }

            Texture2D copy = new Texture2D(width, height, TextureFormat.RGBA32, false);

            copy.hideFlags = HideFlags.HideAndDontSave;
            copy.ReadPixels(new Rect(0, 0, width, height), 0, 0);
            copy.Apply();

            RenderTexture.active = oldActive;
            RenderTexture.ReleaseTemporary(tex);

            return(copy);
        }
        public void Setup(ScriptableRenderer renderer, ref RenderingData renderingData)
        {
            Init();

            Camera camera = renderingData.cameraData.camera;

            renderer.SetupPerObjectLightIndices(ref renderingData.cullResults, ref renderingData.lightData);
            RenderTextureDescriptor baseDescriptor   = ScriptableRenderer.CreateRenderTextureDescriptor(ref renderingData.cameraData);
            RenderTextureDescriptor shadowDescriptor = baseDescriptor;

            shadowDescriptor.dimension = TextureDimension.Tex2D;

            bool mainLightShadows = false;

            if (renderingData.shadowData.supportsMainLightShadows)
            {
                mainLightShadows = m_MainLightShadowCasterPass.Setup(m_MainLightShadowmap, ref renderingData);
                if (mainLightShadows)
                {
                    renderer.EnqueuePass(m_MainLightShadowCasterPass);
                }
            }

            if (renderingData.shadowData.supportsAdditionalLightShadows)
            {
                bool additionalLightShadows = m_AdditionalLightsShadowCasterPass.Setup(m_AdditionalLightsShadowmap, ref renderingData, renderer.maxVisibleAdditionalLights);
                if (additionalLightShadows)
                {
                    renderer.EnqueuePass(m_AdditionalLightsShadowCasterPass);
                }
            }

            bool resolveShadowsInScreenSpace = mainLightShadows && renderingData.shadowData.requiresScreenSpaceShadowResolve;
            bool requiresDepthPrepass        = resolveShadowsInScreenSpace || renderingData.cameraData.isSceneViewCamera ||
                                               (renderingData.cameraData.requiresDepthTexture && (!CanCopyDepth(ref renderingData.cameraData)));

            // For now VR requires a depth prepass until we figure out how to properly resolve texture2DMS in stereo
            requiresDepthPrepass |= renderingData.cameraData.isStereoEnabled;

            renderer.EnqueuePass(m_SetupForwardRenderingPass);

            camera.GetComponents(m_AfterDepthpasses);
            camera.GetComponents(m_AfterOpaquePasses);
            camera.GetComponents(m_AfterOpaquePostProcessPasses);
            camera.GetComponents(m_AfterSkyboxPasses);
            camera.GetComponents(m_AfterTransparentPasses);
            camera.GetComponents(m_AfterRenderPasses);

            if (requiresDepthPrepass)
            {
                m_DepthOnlyPass.Setup(baseDescriptor, m_DepthTexture, SampleCount.One);
                renderer.EnqueuePass(m_DepthOnlyPass);

                foreach (var pass in m_AfterDepthpasses)
                {
                    renderer.EnqueuePass(pass.GetPassToEnqueue(m_DepthOnlyPass.descriptor, m_DepthTexture));
                }
            }

            if (resolveShadowsInScreenSpace)
            {
                m_ScreenSpaceShadowResolvePass.Setup(baseDescriptor, m_ScreenSpaceShadowmap);
                renderer.EnqueuePass(m_ScreenSpaceShadowResolvePass);
            }

            bool requiresRenderToTexture = RequiresIntermediateColorTexture(ref renderingData.cameraData, baseDescriptor) ||
                                           m_AfterDepthpasses.Count != 0 ||
                                           m_AfterOpaquePasses.Count != 0 ||
                                           m_AfterOpaquePostProcessPasses.Count != 0 ||
                                           m_AfterSkyboxPasses.Count != 0 ||
                                           m_AfterTransparentPasses.Count != 0 ||
                                           m_AfterRenderPasses.Count != 0 ||
                                           Display.main.requiresBlitToBackbuffer ||
                                           renderingData.killAlphaInFinalBlit;

            RenderTargetHandle colorHandle = RenderTargetHandle.CameraTarget;
            RenderTargetHandle depthHandle = RenderTargetHandle.CameraTarget;


            var sampleCount = (SampleCount)renderingData.cameraData.msaaSamples;

            if (requiresRenderToTexture)
            {
                colorHandle = m_ColorAttachment;
                depthHandle = m_DepthAttachment;

                m_CreateLightweightRenderTexturesPass.Setup(baseDescriptor, colorHandle, depthHandle, sampleCount);
                renderer.EnqueuePass(m_CreateLightweightRenderTexturesPass);
            }

            if (renderingData.cameraData.isStereoEnabled)
            {
                renderer.EnqueuePass(m_BeginXrRenderingPass);
            }

            var perObjectFlags = ScriptableRenderer.GetPerObjectLightFlags(renderingData.lightData.mainLightIndex, renderingData.lightData.additionalLightsCount);

            m_SetupLightweightConstants.Setup(renderer.maxVisibleAdditionalLights, renderer.perObjectLightIndices);
            renderer.EnqueuePass(m_SetupLightweightConstants);

            m_RenderOpaqueForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, ScriptableRenderer.GetCameraClearFlag(camera), camera.backgroundColor, perObjectFlags);
            renderer.EnqueuePass(m_RenderOpaqueForwardPass);
            foreach (var pass in m_AfterOpaquePasses)
            {
                renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
            }

            if (renderingData.cameraData.postProcessEnabled &&
                renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(renderer.postProcessingContext))
            {
                m_CreatePostOpaqueColorPass.Setup(baseDescriptor, m_ColorAttachmentAfterOpaquePost, sampleCount);
                renderer.EnqueuePass(m_CreatePostOpaqueColorPass);
                m_OpaquePostProcessPass.Setup(baseDescriptor, colorHandle, m_ColorAttachmentAfterOpaquePost, true, false);
                renderer.EnqueuePass(m_OpaquePostProcessPass);

                colorHandle = m_ColorAttachmentAfterOpaquePost;

                foreach (var pass in m_AfterOpaquePostProcessPasses)
                {
                    renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
                }
            }

            if (camera.clearFlags == CameraClearFlags.Skybox)
            {
                m_DrawSkyboxPass.Setup(colorHandle, depthHandle);
                renderer.EnqueuePass(m_DrawSkyboxPass);
            }

            foreach (var pass in m_AfterSkyboxPasses)
            {
                renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
            }

            if (renderingData.cameraData.requiresDepthTexture && !requiresDepthPrepass)
            {
                m_CopyDepthPass.Setup(depthHandle, m_DepthTexture);
                renderer.EnqueuePass(m_CopyDepthPass);
            }

            if (renderingData.cameraData.requiresOpaqueTexture)
            {
                m_CopyColorPass.Setup(colorHandle, m_OpaqueColor);
                renderer.EnqueuePass(m_CopyColorPass);
            }

            m_RenderTransparentForwardPass.Setup(baseDescriptor, colorHandle, depthHandle, perObjectFlags);
            renderer.EnqueuePass(m_RenderTransparentForwardPass);

            foreach (var pass in m_AfterTransparentPasses)
            {
                renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
            }

#if UNITY_EDITOR
            m_LitGizmoRenderingPass.Setup(true);
            renderer.EnqueuePass(m_LitGizmoRenderingPass);
#endif

            bool afterRenderExists = m_AfterRenderPasses.Count != 0;

            // if we have additional filters
            // we need to stay in a RT
            if (afterRenderExists)
            {
                // perform post with src / dest the same
                if (renderingData.cameraData.postProcessEnabled)
                {
                    m_CreatePostTransparentColorPass.Setup(baseDescriptor, m_ColorAttachmentAfterTransparentPost, sampleCount);
                    renderer.EnqueuePass(m_CreatePostTransparentColorPass);

                    m_PostProcessPass.Setup(baseDescriptor, colorHandle, m_ColorAttachmentAfterTransparentPost, false, false);
                    renderer.EnqueuePass(m_PostProcessPass);

                    colorHandle = m_ColorAttachmentAfterTransparentPost;
                }

                //execute after passes
                foreach (var pass in m_AfterRenderPasses)
                {
                    renderer.EnqueuePass(pass.GetPassToEnqueue(baseDescriptor, colorHandle, depthHandle));
                }

                //now blit into the final target
                if (colorHandle != RenderTargetHandle.CameraTarget)
                {
                    m_FinalBlitPass.Setup(baseDescriptor, colorHandle, Display.main.requiresSrgbBlitToBackbuffer, renderingData.killAlphaInFinalBlit);
                    renderer.EnqueuePass(m_FinalBlitPass);
                }
            }
            else
            {
                if (renderingData.cameraData.postProcessEnabled)
                {
                    m_PostProcessPass.Setup(baseDescriptor, colorHandle, RenderTargetHandle.CameraTarget, false, renderingData.cameraData.camera.targetTexture == null);
                    renderer.EnqueuePass(m_PostProcessPass);
                }
                else if (colorHandle != RenderTargetHandle.CameraTarget)
                {
                    m_FinalBlitPass.Setup(baseDescriptor, colorHandle, Display.main.requiresSrgbBlitToBackbuffer, renderingData.killAlphaInFinalBlit);
                    renderer.EnqueuePass(m_FinalBlitPass);
                }
            }

            if (renderingData.cameraData.isStereoEnabled)
            {
                renderer.EnqueuePass(m_EndXrRenderingPass);
            }

#if UNITY_EDITOR
            m_UnlitGizmoRenderingPass.Setup(false);
            renderer.EnqueuePass(m_UnlitGizmoRenderingPass);

            if (renderingData.cameraData.isSceneViewCamera)
            {
                m_SceneViewDepthCopyPass.Setup(m_DepthTexture);
                renderer.EnqueuePass(m_SceneViewDepthCopyPass);
            }
#endif
        }
예제 #17
0
    private bool PopulateLayer(int mipLevels, bool isHdr, OVRPlugin.Sizei size, int sampleCount, int stage)
    {
        if (isExternalSurface)
        {
            return(true);
        }

        bool ret = false;

        RenderTextureFormat rtFormat = (isHdr) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGB32;

        for (int eyeId = 0; eyeId < texturesPerStage; ++eyeId)
        {
            Texture et = layerTextures[eyeId].swapChain[stage];
            if (et == null)
            {
                continue;
            }

            for (int mip = 0; mip < mipLevels; ++mip)
            {
                int width = size.w >> mip;
                if (width < 1)
                {
                    width = 1;
                }
                int height = size.h >> mip;
                if (height < 1)
                {
                    height = 1;
                }
#if UNITY_2017_1_1 || UNITY_2017_2_OR_NEWER
                RenderTextureDescriptor descriptor = new RenderTextureDescriptor(width, height, rtFormat, 0);
                descriptor.msaaSamples      = sampleCount;
                descriptor.useMipMap        = true;
                descriptor.autoGenerateMips = false;
                descriptor.sRGB             = false;

                var tempRTDst = RenderTexture.GetTemporary(descriptor);
#else
                var tempRTDst = RenderTexture.GetTemporary(width, height, 0, rtFormat, RenderTextureReadWrite.Linear, sampleCount);
#endif

                if (!tempRTDst.IsCreated())
                {
                    tempRTDst.Create();
                }

                tempRTDst.DiscardContents();

                bool dataIsLinear = isHdr || (QualitySettings.activeColorSpace == ColorSpace.Linear);

#if !UNITY_2017_1_OR_NEWER
                var rt = textures[eyeId] as RenderTexture;
                dataIsLinear |= rt != null && rt.sRGB;                 //HACK: Unity 5.6 and earlier convert to linear on read from sRGB RenderTexture.
#endif
#if UNITY_ANDROID && !UNITY_EDITOR
                dataIsLinear = true;                 //HACK: Graphics.CopyTexture causes linear->srgb conversion on target write with D3D but not GLES.
#endif

                if (currentOverlayShape != OverlayShape.Cubemap && currentOverlayShape != OverlayShape.OffcenterCubemap)
                {
                    tex2DMaterial.SetInt("_linearToSrgb", (!isHdr && dataIsLinear) ? 1 : 0);

                    //Resolve, decompress, swizzle, etc not handled by simple CopyTexture.
#if !UNITY_ANDROID || UNITY_EDITOR
                    // The PC compositor uses premultiplied alpha, so multiply it here.
                    tex2DMaterial.SetInt("_premultiply", 1);
#endif
                    Graphics.Blit(textures[eyeId], tempRTDst, tex2DMaterial);
                    Graphics.CopyTexture(tempRTDst, 0, 0, et, 0, mip);
                }
#if UNITY_2017_1_OR_NEWER
                else                 // Cubemap
                {
                    for (int face = 0; face < 6; ++face)
                    {
                        cubeMaterial.SetInt("_linearToSrgb", (!isHdr && dataIsLinear) ? 1 : 0);

#if !UNITY_ANDROID || UNITY_EDITOR
                        // The PC compositor uses premultiplied alpha, so multiply it here.
                        cubeMaterial.SetInt("_premultiply", 1);
#endif
                        cubeMaterial.SetInt("_face", face);
                        //Resolve, decompress, swizzle, etc not handled by simple CopyTexture.
                        Graphics.Blit(textures[eyeId], tempRTDst, cubeMaterial);
                        Graphics.CopyTexture(tempRTDst, 0, 0, et, face, mip);
                    }
                }
#endif
                RenderTexture.ReleaseTemporary(tempRTDst);

                ret = true;
            }
        }

        return(ret);
    }
    public override void Setup(ScriptableRenderContext context, ref RenderingData renderingData)
    {
        Camera camera = renderingData.cameraData.camera;
        RenderTextureDescriptor cameraTargetDescriptor = renderingData.cameraData.cameraTargetDescriptor;

        bool mainLightShadows            = m_MainLightShadowCasterPass.Setup(ref renderingData);
        bool additionalLightShadows      = m_AdditionalLightsShadowCasterPass.Setup(ref renderingData);
        bool resolveShadowsInScreenSpace = mainLightShadows && renderingData.shadowData.requiresScreenSpaceShadowResolve;

        // Depth prepass is generated in the following cases:
        // - We resolve shadows in screen space
        // - Scene view camera always requires a depth texture. We do a depth pre-pass to simplify it and it shouldn't matter much for editor.
        // - If game or offscreen camera requires it we check if we can copy the depth from the rendering opaques pass and use that instead.
        bool requiresDepthPrepass = renderingData.cameraData.isSceneViewCamera ||
                                    (renderingData.cameraData.requiresDepthTexture && (!CanCopyDepth(ref renderingData.cameraData)));

        requiresDepthPrepass |= resolveShadowsInScreenSpace;
        bool createColorTexture = RequiresIntermediateColorTexture(ref renderingData, cameraTargetDescriptor) ||
                                  rendererFeatures.Count != 0;

        // If camera requires depth and there's no depth pre-pass we create a depth texture that can be read
        // later by effect requiring it.
        bool createDepthTexture   = renderingData.cameraData.requiresDepthTexture && !requiresDepthPrepass;
        bool postProcessEnabled   = renderingData.cameraData.postProcessEnabled;
        bool hasOpaquePostProcess = postProcessEnabled &&
                                    renderingData.cameraData.postProcessLayer.HasOpaqueOnlyEffects(RenderingUtils.postProcessRenderContext);

        m_ActiveCameraColorAttachment = (createColorTexture) ? m_CameraColorAttachment : RenderTargetHandle.CameraTarget;
        m_ActiveCameraDepthAttachment = (createDepthTexture) ? m_CameraDepthAttachment : RenderTargetHandle.CameraTarget;
        if (createColorTexture || createDepthTexture)
        {
            CreateCameraRenderTarget(context, ref renderingData.cameraData);
        }
        ConfigureCameraTarget(m_ActiveCameraColorAttachment.Identifier(), m_ActiveCameraDepthAttachment.Identifier());

        for (int i = 0; i < rendererFeatures.Count; ++i)
        {
            rendererFeatures[i].AddRenderPasses(this, ref renderingData);
        }

        int count = activeRenderPassQueue.Count;

        for (int i = count - 1; i >= 0; i--)
        {
            if (activeRenderPassQueue[i] == null)
            {
                activeRenderPassQueue.RemoveAt(i);
            }
        }
        bool hasAfterRendering = activeRenderPassQueue.Find(x => x.renderPassEvent == RenderPassEvent.AfterRendering) != null;

        if (mainLightShadows)
        {
            EnqueuePass(m_MainLightShadowCasterPass);
        }

        if (additionalLightShadows)
        {
            EnqueuePass(m_AdditionalLightsShadowCasterPass);
        }

        if (requiresDepthPrepass)
        {
            m_DepthPrepass.Setup(cameraTargetDescriptor, m_DepthTexture);
            EnqueuePass(m_DepthPrepass);
        }

        if (resolveShadowsInScreenSpace)
        {
            m_ScreenSpaceShadowResolvePass.Setup(cameraTargetDescriptor);
            EnqueuePass(m_ScreenSpaceShadowResolvePass);
            if (renderingData.shadowData.ssShadowDownSampleSize > 1)
            {
                m_SSSDownsamplePass.Setup(cameraTargetDescriptor, renderingData);
                EnqueuePass(m_SSSDownsamplePass);
            }
        }

        EnqueuePass(m_RenderOpaqueForwardPass);

        if (hasOpaquePostProcess)
        {
            m_OpaquePostProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, m_ActiveCameraColorAttachment);
        }

        //EnqueuePass(m_RenderOpaqueDiscardAndBlendPass);

        if (camera.clearFlags == CameraClearFlags.Skybox && RenderSettings.skybox != null)
        {
            EnqueuePass(m_DrawSkyboxPass);
        }

        // If a depth texture was created we necessarily need to copy it, otherwise we could have render it to a renderbuffer
        if (createDepthTexture)
        {
            m_CopyDepthPass.Setup(m_ActiveCameraDepthAttachment, m_DepthTexture);
            EnqueuePass(m_CopyDepthPass);
        }

        if (renderingData.cameraData.requiresOpaqueTexture)
        {
            m_CopyColorPass.Setup(m_ActiveCameraColorAttachment.Identifier(), m_OpaqueColor);
            EnqueuePass(m_CopyColorPass);
        }

        //OIT Pass
        m_BlendWeightedAccumulatePass.Setup(cameraTargetDescriptor, accumulateHandle, m_DepthTexture);
        //m_BlendWeightedAccumulatePass.Setup(new RenderTextureDescriptor(cameraTargetDescriptor.width, cameraTargetDescriptor.height), accumulateHandle, m_DepthTexture);
        EnqueuePass(m_BlendWeightedAccumulatePass);
        m_BlendWeightedRevealagePass.Setup(cameraTargetDescriptor, revealageHandle, m_DepthTexture);
        //m_BlendWeightedRevealagePass.Setup(new RenderTextureDescriptor(cameraTargetDescriptor.width, cameraTargetDescriptor.height), revealageHandle, m_DepthTexture);
        EnqueuePass(m_BlendWeightedRevealagePass);

        //cameraTargetDescriptor.msaaSamples = msaaSamples;
        //cameraTargetDescriptor.bindMS = bindMS;
        //Blit Feature  AddPass(EnqueuePass


        bool afterRenderExists = renderingData.cameraData.captureActions != null ||
                                 hasAfterRendering;

        // if we have additional filters
        // we need to stay in a RT
        if (afterRenderExists)
        {
            // perform post with src / dest the same
            if (postProcessEnabled)
            {
                m_PostProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, m_ActiveCameraColorAttachment);
                EnqueuePass(m_PostProcessPass);
            }

            //now blit into the final target
            if (m_ActiveCameraColorAttachment != RenderTargetHandle.CameraTarget)
            {
                if (renderingData.cameraData.captureActions != null)
                {
                    m_CapturePass.Setup(m_ActiveCameraColorAttachment);
                    EnqueuePass(m_CapturePass);
                }

                m_FinalBlitPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment);
                EnqueuePass(m_FinalBlitPass);
            }
        }
        else
        {
            if (postProcessEnabled)
            {
                m_PostProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, RenderTargetHandle.CameraTarget);
                EnqueuePass(m_PostProcessPass);
            }
            else if (m_ActiveCameraColorAttachment != RenderTargetHandle.CameraTarget)
            {
                m_FinalBlitPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment);
                EnqueuePass(m_FinalBlitPass);
            }
        }

#if UNITY_EDITOR
        if (renderingData.cameraData.isSceneViewCamera)
        {
            m_SceneViewDepthCopyPass.Setup(m_DepthTexture);
            EnqueuePass(m_SceneViewDepthCopyPass);
        }
#endif
    }
예제 #19
0
        /// <summary>
        /// Set RenderBuffer for camera;
        /// </summary>
        private void RefreshRenderBufferForSingleCamera(ScriptableRenderContext context, ref RenderingData renderingData,
                                                        ref CameraData cameraData, out bool requiresDepthPrepass, out bool createDepthTexture)
        {
            Camera camera = renderingData.cameraData.camera;
            RenderTextureDescriptor cameraTargetDescriptor = renderingData.cameraData.cameraTargetDescriptor;
            bool applyPostProcessing = cameraData.postProcessEnabled;

            bool isSceneViewCamera    = cameraData.isSceneViewCamera;
            bool isPreviewCamera      = cameraData.isPreviewCamera;
            bool requiresDepthTexture = cameraData.requiresDepthTexture;
            bool isStereoEnabled      = cameraData.isStereoEnabled;

            // Depth prepass is generated in the following cases:
            // - If game or offscreen camera requires it we check if we can copy the depth from the rendering opaques pass and use that instead.
            // - Scene or preview cameras always require a depth texture. We do a depth pre-pass to simplify it and it shouldn't matter much for editor.
            requiresDepthPrepass  = requiresDepthTexture && !CanCopyDepth(ref renderingData.cameraData);
            requiresDepthPrepass |= isSceneViewCamera;
            requiresDepthPrepass |= isPreviewCamera;

            // The copying of depth should normally happen after rendering opaques.
            // But if we only require it for post processing or the scene camera then we do it after rendering transparent objects
            m_CopyDepthPass.renderPassEvent = (!requiresDepthTexture && (applyPostProcessing || isSceneViewCamera)) ?
                                              RenderPassEvent.AfterRenderingTransparents : RenderPassEvent.AfterRenderingOpaques;

            // TODO: CopyDepth pass is disabled in XR due to required work to handle camera matrices in URP.
            // IF this condition is removed make sure the CopyDepthPass.cs is working properly on all XR modes. This requires PureXR SDK integration.
            if (isStereoEnabled && requiresDepthTexture)
            {
                requiresDepthPrepass = true;
            }

            bool isRunningHololens = false;

#if ENABLE_VR && ENABLE_VR_MODULE
            isRunningHololens = UniversalRenderPipeline.IsRunningHololens(camera);
#endif
            bool createColorTexture = RequiresIntermediateColorTexture(ref cameraData);
            createColorTexture |= (rendererFeatures.Count != 0 && !isRunningHololens);
            createColorTexture &= !isPreviewCamera;

            // If camera requires depth and there's no depth pre-pass we create a depth texture that can be read later by effect requiring it.
            createDepthTexture  = cameraData.requiresDepthTexture && !requiresDepthPrepass;
            createDepthTexture |= (cameraData.renderType == CameraRenderType.Base && !cameraData.resolveFinalTarget);

#if UNITY_ANDROID || UNITY_WEBGL
            if (SystemInfo.graphicsDeviceType != GraphicsDeviceType.Vulkan)
            {
                // GLES can not use render texture's depth buffer with the color buffer of the backbuffer
                // in such case we create a color texture for it too.
                createColorTexture |= createDepthTexture;
            }
#endif
            // Configure all settings require to start a new camera stack (base camera only)
            if (cameraData.renderType == CameraRenderType.Base)
            {
                m_ActiveCameraColorAttachment = (createColorTexture) ? m_CameraColorAttachment : RenderTargetHandle.CameraTarget;
                m_ActiveCameraDepthAttachment = (createDepthTexture) ? m_CameraDepthAttachment : RenderTargetHandle.CameraTarget;

                bool intermediateRenderTexture = createColorTexture || createDepthTexture;

                // Doesn't create texture for Overlay cameras as they are already overlaying on top of created textures.
                bool createTextures = intermediateRenderTexture;
                if (createTextures)
                {
                    CreateCameraRenderTarget(context, ref renderingData.cameraData);
                }

                // if rendering to intermediate render texture we don't have to create msaa backbuffer
                int backbufferMsaaSamples = (intermediateRenderTexture) ? 1 : cameraTargetDescriptor.msaaSamples;

                if (Camera.main == camera && camera.cameraType == CameraType.Game && cameraData.targetTexture == null)
                {
                    SetupBackbufferFormat(backbufferMsaaSamples, isStereoEnabled);
                }
            }
            else
            {
                if (m_SplitUICameraAndSceneCameraRenderer)
                {
                    RefreshCameraColorAttachment(context, ref renderingData.cameraData);
                }
                else
                {
                    m_ActiveCameraColorAttachment = m_CameraColorAttachment;
                    m_ActiveCameraDepthAttachment = m_CameraDepthAttachment;
                }
            }

            ConfigureCameraTarget(m_ActiveCameraColorAttachment.Identifier(), m_ActiveCameraDepthAttachment.Identifier());
        }
        public IEnumerator BakeLightmap()
        {
            RenderTextureDescriptor texArrayDescriptor = new RenderTextureDescriptor
            {
                autoGenerateMips   = false,
                bindMS             = false,
                colorFormat        = RenderTextureFormat.ARGB32,
                depthBufferBits    = 16,
                dimension          = TextureDimension.Tex2DArray,
                enableRandomWrite  = false,
                height             = RESOLUTION,
                width              = RESOLUTION,
                memoryless         = RenderTextureMemoryless.None,
                msaaSamples        = 1,
                shadowSamplingMode = ShadowSamplingMode.None,
                sRGB        = false,
                useMipMap   = true,
                volumeDepth = 6,
                vrUsage     = VRTextureUsage.None
            };

            RenderTexture rt = RenderTexture.GetTemporary(texArrayDescriptor); rt.filterMode = FilterMode.Trilinear;

            rt.Create();
            texArrayDescriptor.volumeDepth = 1;
            texArrayDescriptor.dimension   = TextureDimension.Tex2D;
            RenderTexture tempRT = RenderTexture.GetTemporary(texArrayDescriptor);

            tempRT.Create();
            ComputeShader          shader = resources.shaders.probeCoeffShader;
            Action <CommandBuffer> func   = (cb) =>
            {
                cb.SetComputeBufferParam(shader, 0, "_CoeffTemp", coeffTemp);
                cb.SetComputeBufferParam(shader, 1, "_CoeffTemp", coeffTemp);
                cb.SetComputeBufferParam(shader, 1, "_Coeff", coeff);
                cb.SetComputeTextureParam(shader, 0, "_SourceCubemap", rt);
                cb.SetGlobalVector("_Tex3DSize", new Vector4(probeCount.x + 0.01f, probeCount.y + 0.01f, probeCount.z + 0.01f));
                cb.SetGlobalVector("_SHSize", transform.localScale);
                cb.SetGlobalVector("_LeftDownBack", transform.position - transform.localScale * 0.5f);
            };

            RenderPipeline.ExecuteBufferAtFrameEnding(func);
            yield return(null);

            yield return(null);

            int target = probeCount.x * probeCount.y * probeCount.z;

            for (int x = 0; x < probeCount.x; ++x)
            {
                for (int y = 0; y < probeCount.y; ++y)
                {
                    for (int z = 0; z < probeCount.z; ++z)
                    {
                        BakeMap(int3(x, y, z), rt, tempRT);
                        cbuffer.GenerateMips(rt);
                        cbuffer.SetComputeIntParam(shader, "_OffsetIndex", PipelineFunctions.DownDimension(int3(x, y, z), probeCount.xy));
                        cbuffer.DispatchCompute(shader, 0, RESOLUTION / 32, RESOLUTION / 32, 6);
                        cbuffer.DispatchCompute(shader, 1, 1, 1, 1);
                        yield return(null);
                    }
                }
            }
            isRendering = false;
            yield return(null);

            isRendered = true;
            byte[] byteArray = new byte[coeff.count * coeff.stride];
            coeff.GetData(byteArray);
            string path = "Assets/BinaryData/Irradiance/" + volumeName + ".mpipe";

            File.WriteAllBytes(path, byteArray);
            float4x4 localToWorld = transform.localToWorldMatrix;

            IrradianceResources.Volume volume = new IrradianceResources.Volume
            {
                position     = transform.position,
                localToWorld = float3x3(localToWorld.c0.xyz, localToWorld.c1.xyz, localToWorld.c2.xyz),
                resolution   = (uint3)probeCount,
                volumeName   = volumeName,
                path         = path
            };
            Debug.Log(volume.volumeName);
            saveTarget.allVolume[indexInList] = volume;
            EditorUtility.SetDirty(saveTarget);
            RenderTexture.ReleaseTemporary(rt);
            RenderTexture.ReleaseTemporary(tempRT);
            yield return(null);

            Dispose();
        }
        private static Texture2D Render(
            Camera camera,
            Shader shader,
            Renderer[] renderers,
            int width  = -1,
            int height = -1)
        {
            bool autoSize = width < 0 || height < 0;

            int _width  = autoSize ? (int)camera.pixelRect.width : width;
            int _height = autoSize ? (int)camera.pixelRect.height : height;

            GameObject go        = new GameObject();
            Camera     renderCam = go.AddComponent <Camera>();

            renderCam.CopyFrom(camera);

            renderCam.renderingPath   = RenderingPath.Forward;
            renderCam.enabled         = false;
            renderCam.clearFlags      = CameraClearFlags.SolidColor;
            renderCam.backgroundColor = Color.white;
            renderCam.cullingMask     = 0;

            IRenderPipelineCameraUtility cameraUtility = IOC.Resolve <IRenderPipelineCameraUtility>();

            if (cameraUtility != null)
            {
                cameraUtility.EnablePostProcessing(renderCam, false);
                cameraUtility.SetBackgroundColor(renderCam, Color.white);
            }

            renderCam.allowHDR  = false;
            renderCam.allowMSAA = false;
            renderCam.forceIntoRenderTexture = true;

            float aspect = renderCam.aspect;

            renderCam.rect   = new Rect(Vector2.zero, Vector2.one);
            renderCam.aspect = aspect;

            RenderTextureDescriptor descriptor = new RenderTextureDescriptor()
            {
                width             = _width,
                height            = _height,
                colorFormat       = RenderTextureFormat,
                autoGenerateMips  = false,
                depthBufferBits   = 16,
                dimension         = TextureDimension.Tex2D,
                enableRandomWrite = false,
                memoryless        = RenderTextureMemoryless.None,
                sRGB        = true,
                useMipMap   = false,
                volumeDepth = 1,
                msaaSamples = 1
            };
            RenderTexture rt = RenderTexture.GetTemporary(descriptor);

            RenderTexture prev = RenderTexture.active;

            renderCam.targetTexture = rt;
            RenderTexture.active    = rt;

            Material replacementMaterial = new Material(shader);

            IRTEGraphics graphics  = IOC.Resolve <IRTEGraphics>();
            IRTECamera   rteCamera = graphics.CreateCamera(renderCam, CameraEvent.AfterForwardAlpha, false, true);

            rteCamera.RenderersCache.MaterialOverride = replacementMaterial;
            rteCamera.Camera.name = "BoxSelectionCamera";
            foreach (Renderer renderer in renderers)
            {
                Material[] materials = renderer.sharedMaterials;
                for (int i = 0; i < materials.Length; ++i)
                {
                    if (materials[i] != null)
                    {
                        rteCamera.RenderersCache.Add(renderer);
                    }
                }
            }
            rteCamera.RefreshCommandBuffer();

            if (RenderPipelineInfo.Type != RPType.Standard)
            {
                bool invertCulling = GL.invertCulling;
                GL.invertCulling            = true;
                renderCam.projectionMatrix *= Matrix4x4.Scale(new Vector3(1, -1, 1));
                renderCam.Render();
                GL.invertCulling = invertCulling;
            }
            else
            {
                renderCam.Render();
            }

            Texture2D img = new Texture2D(_width, _height, TextureFormat, false, false);

            img.ReadPixels(new Rect(0, 0, _width, _height), 0, 0);
            img.Apply();

            RenderTexture.active = prev;
            RenderTexture.ReleaseTemporary(rt);

            UnityObject.DestroyImmediate(go);
            UnityObject.Destroy(replacementMaterial);

            rteCamera.Destroy();
            //System.IO.File.WriteAllBytes("Assets/box_selection.png", img.EncodeToPNG());

            return(img);
        }
 /// <summary>
 /// Configure the render pass by configuring the render target and clear values.
 /// </summary>
 /// <param name="commandBuffer">The command buffer for configuration.</param>
 /// <param name="renderTextureDescriptor">The descriptor of the target render texture.</param>
 public override void Configure(CommandBuffer commandBuffer, RenderTextureDescriptor renderTextureDescriptor)
 {
     ConfigureTarget(m_ColorTargetIdentifier, m_DepthTargetIdentifier);
     ConfigureClear(ClearFlag.Depth, Color.clear);
 }
예제 #23
0
        public CBDRSharedData(PipelineResources res)
        {
            dirLightShadowmap  = null;
            availiableDistance = 0;
            spotShadowCount    = 0;
            pointshadowCount   = 0;
            lightFlag          = 0;
            cbdrShader         = res.shaders.cbdrShader;
            RenderTextureDescriptor desc = new RenderTextureDescriptor
            {
                autoGenerateMips   = false,
                bindMS             = false,
                colorFormat        = RenderTextureFormat.ARGBFloat,
                depthBufferBits    = 0,
                enableRandomWrite  = true,
                dimension          = TextureDimension.Tex3D,
                width              = XRES,
                height             = YRES,
                volumeDepth        = 4,
                memoryless         = RenderTextureMemoryless.None,
                msaaSamples        = 1,
                shadowSamplingMode = ShadowSamplingMode.None,
                sRGB      = false,
                useMipMap = false,
                vrUsage   = VRTextureUsage.None
            };

            cubeArrayMap = new RenderTexture(new RenderTextureDescriptor
            {
                autoGenerateMips   = false,
                bindMS             = false,
                colorFormat        = RenderTextureFormat.RHalf,
                depthBufferBits    = 16,
                dimension          = TextureDimension.CubeArray,
                volumeDepth        = 6 * MAXIMUMPOINTLIGHTCOUNT,
                enableRandomWrite  = false,
                height             = MLight.cubemapShadowResolution,
                width              = MLight.cubemapShadowResolution,
                memoryless         = RenderTextureMemoryless.None,
                msaaSamples        = 1,
                shadowSamplingMode = ShadowSamplingMode.None,
                sRGB      = false,
                useMipMap = false,
                vrUsage   = VRTextureUsage.None
            });
            cubeArrayMap.filterMode = FilterMode.Bilinear;
            cubeArrayMap.Create();
            spotArrayMap = new RenderTexture(new RenderTextureDescriptor
            {
                autoGenerateMips   = false,
                bindMS             = false,
                colorFormat        = RenderTextureFormat.Shadowmap,
                depthBufferBits    = 16,
                dimension          = TextureDimension.Tex2DArray,
                enableRandomWrite  = false,
                height             = MLight.perspShadowResolution,
                memoryless         = RenderTextureMemoryless.None,
                msaaSamples        = 1,
                shadowSamplingMode = ShadowSamplingMode.RawDepth,
                sRGB        = false,
                useMipMap   = false,
                volumeDepth = MAXIMUMSPOTLIGHTCOUNT,
                vrUsage     = VRTextureUsage.None,
                width       = MLight.perspShadowResolution
            });
            spotArrayMap.filterMode = FilterMode.Bilinear;
            spotArrayMap.Create();
            xyPlaneTexture            = new RenderTexture(desc);
            xyPlaneTexture.filterMode = FilterMode.Point;
            xyPlaneTexture.Create();
            desc.dimension   = TextureDimension.Tex2D;
            desc.volumeDepth = 1;
            desc.width       = ZRES;
            desc.height      = 2;
            zPlaneTexture    = new RenderTexture(desc);
            zPlaneTexture.Create();
            pointlightIndexBuffer = new ComputeBuffer(XRES * YRES * ZRES * (MAXLIGHTPERCLUSTER + 1), sizeof(int));
            spotlightIndexBuffer  = new ComputeBuffer(XRES * YRES * ZRES * (MAXLIGHTPERCLUSTER + 1), sizeof(int));
            allPointLightBuffer   = new ComputeBuffer(pointLightInitCapacity, sizeof(PointLightStruct));
            allSpotLightBuffer    = new ComputeBuffer(pointLightInitCapacity, sizeof(SpotLight));
            allFogVolumeBuffer    = new ComputeBuffer(30, sizeof(FogVolume));
        }
 ScriptableRenderPass IAfterRender.GetPassToEnqueue(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle, RenderTargetHandle depthHandle)
 {
     return(new BlitPass(colorHandle, depthHandle));
 }
예제 #25
0
 private void MyDebug(Camera camera, ScriptableRenderContext context, RenderTargetIdentifier RTid, RenderTextureDescriptor Desc, CommandBuffer cmd = null)
 {
     if (cmd != null)
     {
         cmd.name = cmd.name + "HaveCMD!!!!!!!!!!!!!!";
         debugRT  = new RenderTexture(Desc);
         cmd.Blit(RTid, debugRT);
         context.ExecuteCommandBuffer(cmd);
         cmd.Release();
         debugRT.Release();
     }
     else
     {
         CommandBuffer cmdTempId = new CommandBuffer();
         cmdTempId.name = "(" + camera.name + ")" + "Setup TempRT";
         debugRT        = new RenderTexture(Desc);
         cmdTempId.Blit(RTid, debugRT);
         context.ExecuteCommandBuffer(cmdTempId);
         cmdTempId.Release();
         debugRT.Release();
     }
 }
 ScriptableRenderPass IBeforeRender.GetPassToEnqueue(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle, RenderTargetHandle depthAttachmentHandle, ClearFlag clearFlag)
 {
     return(new ClearColorPass(colorHandle, clearFlag));
 }
예제 #27
0
 public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
 {
     cmd.GetTemporaryRT(depthAttachmentHandle.id, descriptor, FilterMode.Point);
     ConfigureTarget(depthAttachmentHandle.Identifier());
     ConfigureClear(ClearFlag.All, Color.black);
 }
예제 #28
0
 public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
 {
     m_AdditionalLightsShadowmapTexture = ShadowUtils.GetTemporaryShadowTexture(m_ShadowmapWidth, m_ShadowmapHeight, k_ShadowmapBufferBits);
     ConfigureTarget(new RenderTargetIdentifier(m_AdditionalLightsShadowmapTexture));
     ConfigureClear(ClearFlag.All, Color.black);
 }
예제 #29
0
 //
 protected virtual bool Equals(RenderTextureDescriptor x, RenderTextureDescriptor y)
 {
     return(x.width == y.width && x.height == y.height && x.msaaSamples == y.msaaSamples);               // TODO compare all fields?
 }
예제 #30
0
 /// <summary>
 /// Configure the pass
 /// </summary>
 /// <param name="baseDescriptor"></param>
 /// <param name="colorHandle"></param>
 public void Setup(RenderTextureDescriptor baseDescriptor, RenderTargetHandle colorHandle)
 {
     m_Source           = colorHandle;
     m_TargetDimension  = baseDescriptor.dimension;
     m_IsMobileOrSwitch = Application.isMobilePlatform || Application.platform == RuntimePlatform.Switch;
 }