Example #1
0
 public RenderTexture Get(int width, int height, int depthBuffer = 0, RenderTextureFormat format = RenderTextureFormat.ARGBHalf, RenderTextureReadWrite rw = RenderTextureReadWrite.Default, FilterMode filterMode = FilterMode.Bilinear, TextureWrapMode wrapMode = TextureWrapMode.Clamp, string name = "FactoryTempTexture")
 {
     var rt = RenderTexture.GetTemporary(width, height, depthBuffer, format);
     rt.filterMode = filterMode;
     rt.wrapMode = wrapMode;
     rt.name = name;
     m_TemporaryRTs.Add(rt);
     return rt;
 }
 /// <summary>
 /// <para>Creates a new RenderTexture object.</para>
 /// </summary>
 /// <param name="width">Texture width in pixels.</param>
 /// <param name="height">Texture height in pixels.</param>
 /// <param name="depth">Number of bits in depth buffer (0, 16 or 24). Note that only 24 bit depth has stencil buffer.</param>
 /// <param name="format">Texture color format.</param>
 /// <param name="readWrite">How or if color space conversions should be done on texture read/write.</param>
 public RenderTexture(int width, int height, int depth, RenderTextureFormat format, RenderTextureReadWrite readWrite)
 {
     Internal_CreateRenderTexture(this);
     this.width = width;
     this.height = height;
     this.depth = depth;
     this.format = format;
     bool sRGB = readWrite == RenderTextureReadWrite.sRGB;
     if (readWrite == RenderTextureReadWrite.Default)
     {
         sRGB = QualitySettings.activeColorSpace == ColorSpace.Linear;
     }
     Internal_SetSRGBReadWrite(this, sRGB);
 }
Example #3
0
        void DrawBackgroundTexture(Rect rect, int pass)
        {
            if (s_MaterialGrid == null)
            {
                s_MaterialGrid = new Material(Shader.Find("Hidden/PostProcessing/Editor/CurveGrid"))
                {
                    hideFlags = HideFlags.HideAndDontSave
                }
            }
            ;

            float scale = EditorGUIUtility.pixelsPerPoint;

#if UNITY_2018_1_OR_NEWER
            const RenderTextureReadWrite kReadWrite = RenderTextureReadWrite.sRGB;
#else
            const RenderTextureReadWrite kReadWrite = RenderTextureReadWrite.Linear;
#endif

            var oldRt = RenderTexture.active;
            var rt    = RenderTexture.GetTemporary(Mathf.CeilToInt(rect.width * scale), Mathf.CeilToInt(rect.height * scale), 0, RenderTextureFormat.ARGB32, kReadWrite);
            s_MaterialGrid.SetFloat("_DisabledState", GUI.enabled ? 1f : 0.5f);
            s_MaterialGrid.SetFloat("_PixelScaling", EditorGUIUtility.pixelsPerPoint);

            Graphics.Blit(null, rt, s_MaterialGrid, pass);
            RenderTexture.active = oldRt;

            GUI.DrawTexture(rect, rt);
            RenderTexture.ReleaseTemporary(rt);
        }

        int DoCurveSelectionPopup(int id, bool hdr)
        {
            GUILayout.Label(s_Curves[id], EditorStyles.toolbarPopup, GUILayout.MaxWidth(150f));

            var lastRect = GUILayoutUtility.GetLastRect();
            var e        = Event.current;

            if (e.type == EventType.MouseDown && e.button == 0 && lastRect.Contains(e.mousePosition))
            {
                var menu = new GenericMenu();

                for (int i = 0; i < s_Curves.Length; i++)
                {
                    if (i == 4)
                    {
                        menu.AddSeparator("");
                    }

                    if (hdr && i < 4)
                    {
                        menu.AddDisabledItem(s_Curves[i]);
                    }
                    else
                    {
                        int current = i; // Capture local for closure
                        menu.AddItem(s_Curves[i], current == id, () => GlobalSettings.currentCurve = current);
                    }
                }

                menu.DropDown(new Rect(lastRect.xMin, lastRect.yMax, 1f, 1f));
            }

            return(id);
        }
    }
        internal RenderTextureDescriptor GetDescriptor(int depthBufferBits = 0, RenderTextureFormat colorFormat = RenderTextureFormat.Default, RenderTextureReadWrite readWrite = RenderTextureReadWrite.Default)
        {
            var modifiedDesc = new RenderTextureDescriptor(m_sourceDescriptor.width, m_sourceDescriptor.height,
                                                           m_sourceDescriptor.colorFormat, depthBufferBits);

            modifiedDesc.dimension   = m_sourceDescriptor.dimension;
            modifiedDesc.volumeDepth = m_sourceDescriptor.volumeDepth;
            modifiedDesc.vrUsage     = m_sourceDescriptor.vrUsage;
            modifiedDesc.msaaSamples = m_sourceDescriptor.msaaSamples;
            modifiedDesc.memoryless  = m_sourceDescriptor.memoryless;

            modifiedDesc.useMipMap          = m_sourceDescriptor.useMipMap;
            modifiedDesc.autoGenerateMips   = m_sourceDescriptor.autoGenerateMips;
            modifiedDesc.enableRandomWrite  = m_sourceDescriptor.enableRandomWrite;
            modifiedDesc.shadowSamplingMode = m_sourceDescriptor.shadowSamplingMode;

#if UNITY_2019_1_OR_NEWER
            if (m_Camera.allowDynamicResolution)
            {
                modifiedDesc.useDynamicScale = true;
            }
#endif

            if (colorFormat != RenderTextureFormat.Default)
            {
                modifiedDesc.colorFormat = colorFormat;
            }

#if UNITY_2019_1_OR_NEWER
            if (readWrite == RenderTextureReadWrite.sRGB)
            {
                modifiedDesc.sRGB = true;
            }
            else if (readWrite == RenderTextureReadWrite.Linear)
            {
                modifiedDesc.sRGB = false;
            }
            else if (readWrite == RenderTextureReadWrite.Default)
            {
                modifiedDesc.sRGB = QualitySettings.activeColorSpace != ColorSpace.Gamma;
            }
#else
            modifiedDesc.sRGB = readWrite != RenderTextureReadWrite.Linear;
#endif

            return(modifiedDesc);
        }
 public void GetTemporaryRTArray(int nameID, int width, int height, int slices, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite, int antiAliasing, bool enableRandomWrite)
 {
     GetTemporaryRTArray(nameID, width, height, slices, depthBuffer, filter, format, readWrite, antiAliasing, enableRandomWrite, false);
 }
 public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite, int antiAliasing)
 {
     GetTemporaryRT(nameID, width, height, depthBuffer, filter, format, readWrite, antiAliasing, false);
 }
Example #7
0
 void SafeCreateRenderTexture(ref RenderTexture rt, string name, int depth, RenderTextureFormat fmt, RenderTextureReadWrite rw, FilterMode fm)
 {
     if (rt == null)
     {
         rt            = new RenderTexture(m_width, m_height, depth, fmt, rw);
         rt.name       = name;
         rt.wrapMode   = TextureWrapMode.Clamp;
         rt.filterMode = fm;
         rt.hideFlags  = HideFlags.DontSave;
         rt.Create();
     }
 }
Example #8
0
        public RenderTexture Get(int width, int height, int depthBuffer = 0, RenderTextureFormat format = RenderTextureFormat.ARGBHalf, RenderTextureReadWrite rw = RenderTextureReadWrite.Default, FilterMode filterMode = FilterMode.Bilinear, TextureWrapMode wrapMode = TextureWrapMode.Clamp, string name = "FactoryTempTexture")
        {
            var rt = RenderTexture.GetTemporary(width, height, depthBuffer, format, rw); // add forgotten param rw

            rt.filterMode = filterMode;
            rt.wrapMode   = wrapMode;
            rt.name       = name;
            m_TemporaryRTs.Add(rt);
            return(rt);
        }
		public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite)
		{
			int antiAliasing = 1;
			this.GetTemporaryRT(nameID, width, height, depthBuffer, filter, format, readWrite, antiAliasing);
		}
Example #10
0
 public static RenderTexture GetTemporary(int width, int height, [UnityEngine.Internal.DefaultValue("0")] int depthBuffer, [UnityEngine.Internal.DefaultValue("RenderTextureFormat.Default")] RenderTextureFormat format, [UnityEngine.Internal.DefaultValue("RenderTextureReadWrite.Default")] RenderTextureReadWrite readWrite, [UnityEngine.Internal.DefaultValue("1")] int antiAliasing, [UnityEngine.Internal.DefaultValue("RenderTextureMemoryless.None")] RenderTextureMemoryless memorylessMode)
 {
     return(RenderTexture.GetTemporary(new RenderTextureDescriptor(width, height)
     {
         depthBufferBits = depthBuffer,
         vrUsage = VRTextureUsage.None,
         colorFormat = format,
         sRGB = (readWrite != RenderTextureReadWrite.Linear),
         msaaSamples = antiAliasing,
         memoryless = memorylessMode
     }));
 }
Example #11
0
        public static RenderTexture GetTemporary(int width, int height, int depthBuffer, RenderTextureFormat format, RenderTextureReadWrite readWrite)
        {
            RenderTextureMemoryless memorylessMode = RenderTextureMemoryless.None;
            int antiAliasing = 1;

            return(RenderTexture.GetTemporary(width, height, depthBuffer, format, readWrite, antiAliasing, memorylessMode));
        }
Example #12
0
        public RenderTexture(int width, int height, int depth, RenderTextureFormat format, RenderTextureReadWrite readWrite)
        {
            RenderTexture.Internal_CreateRenderTexture(this);
            this.width  = width;
            this.height = height;
            this.depth  = depth;
            this.format = format;
            bool sRGB = readWrite == RenderTextureReadWrite.sRGB;

            if (readWrite == RenderTextureReadWrite.Default)
            {
                sRGB = (QualitySettings.activeColorSpace == ColorSpace.Linear);
            }
            RenderTexture.Internal_SetSRGBReadWrite(this, sRGB);
        }
                public static GraphicsFormat GetGraphicsFormat(RenderTextureFormat format, RenderTextureReadWrite readWrite)
                {
                    bool defaultSRGB = QualitySettings.activeColorSpace == ColorSpace.Linear;
                    bool sRGB        = readWrite == RenderTextureReadWrite.Default ? defaultSRGB : readWrite == RenderTextureReadWrite.sRGB;

                    return(GetGraphicsFormat(format, sRGB));
                }
 public static void SafeCreateRenderTexture(ref RenderTexture rt, string name, int depth, RenderTextureFormat fmt, RenderTextureReadWrite rw, int width, int height)
 {
     if (rt == null)
     {
         rt = new RenderTexture(width, height, depth, fmt, rw);
         rt.set_name(name);
         rt.set_wrapMode(1);
         rt.set_filterMode(1);
         rt.set_hideFlags(52);
         rt.Create();
     }
 }
Example #15
0
    RenderTexture SafeAllocateRT(string name, int width, int height, RenderTextureFormat format, RenderTextureReadWrite readWrite)
    {
        width  = Mathf.Max(width, 1);
        height = Mathf.Max(height, 1);

        RenderTexture rt = new RenderTexture(width, height, 0, format, readWrite)
        {
            hideFlags = HideFlags.DontSave
        };

        rt.name       = name;
        rt.filterMode = FilterMode.Point;
        rt.wrapMode   = TextureWrapMode.Clamp;
        rt.Create();
        return(rt);
    }
        public void GetScreenSpaceTemporaryRT(CommandBuffer cmd, int nameID,
                                              int depthBufferBits = 0, RenderTextureFormat colorFormat     = RenderTextureFormat.Default, RenderTextureReadWrite readWrite = RenderTextureReadWrite.Default,
                                              FilterMode filter   = FilterMode.Bilinear, int widthOverride = 0, int heightOverride = 0)
        {
#if UNITY_2017_2_OR_NEWER
            var desc = GetDescriptor(depthBufferBits, colorFormat, readWrite);
            if (widthOverride > 0)
            {
                desc.width = widthOverride;
            }
            if (heightOverride > 0)
            {
                desc.height = heightOverride;
            }

            cmd.GetTemporaryRT(nameID, desc, filter);
#else
            int actualWidth  = width;
            int actualHeight = height;
            if (widthOverride > 0)
            {
                actualWidth = widthOverride;
            }
            if (heightOverride > 0)
            {
                actualHeight = heightOverride;
            }

            cmd.GetTemporaryRT(nameID, actualWidth, actualHeight, depthBufferBits, filter, colorFormat, readWrite);
            // TODO: How to handle MSAA for XR in older versions?  Query cam?
            // TODO: Pass in vrUsage into the args
#endif
        }
Example #17
0
 public RenderTexture(int width, int height, int depth, [uei.DefaultValue("RenderTextureFormat.Default")] RenderTextureFormat format, [uei.DefaultValue("RenderTextureReadWrite.Default")] RenderTextureReadWrite readWrite)
     : this(width, height, depth, GraphicsFormatUtility.GetGraphicsFormat(format, readWrite))
 {
 }
Example #18
0
        public RenderTexture AddRenderTexture(int nwidth, int nheight, RenderTextureFormat format, RenderTextureReadWrite dataType, FilterMode filterMode, string global)
        {
            if (destination == TexTarget.RenderTexture)
            {
                RenderTexture_To_Texture2D();
            }


            width  = nwidth;
            height = nheight;

            renderTexture = new RenderTexture(width, height, 0, format, dataType)
            {
                filterMode = filterMode,

                name = saveName
            };

            if (!global.IsNullOrEmpty())
            {
                Shader.SetGlobalTexture(global, renderTexture);
            }

            if (destination == TexTarget.RenderTexture)
            {
                Texture2D_To_RenderTexture();
            }

            return(renderTexture);
        }
	RenderTexture CreateRenderTexture( string name, int depth, RenderTextureFormat fmt, RenderTextureReadWrite rw, FilterMode fm )
	{
		RenderTexture rt = new RenderTexture( m_width, m_height, depth, fmt, rw );
		rt.hideFlags = HideFlags.DontSave;
		rt.name = name;
		rt.wrapMode = TextureWrapMode.Clamp;
		rt.filterMode = fm;
		rt.Create();
		return rt;
	}
Example #20
0
        internal static UnityEngine.Texture2D BlitTexture(UnityEngine.Texture2D texture, UnityEngine.TextureFormat format, bool alphaOnly = false)
        {
            var texPath = AssetDatabase.GetAssetPath(texture);
            var asset   = AssetDatabase.LoadMainAssetAtPath(texPath);
            RenderTextureReadWrite rtReadWrite = UnityEngine.RenderTextureReadWrite.sRGB;

            if (asset is Texture2D)
            {
                var importer = (TextureImporter)AssetImporter.GetAtPath(texPath);
                if (importer != null)
                {
                    rtReadWrite = importer.sRGBTexture ? UnityEngine.RenderTextureReadWrite.sRGB : UnityEngine.RenderTextureReadWrite.Linear;
                }
            }

            // hack to support text mesh pro
            var fontAssetType = Type.GetType("TMPro.TMP_FontAsset, Unity.TextMeshPro, Version=0.0.0.0, Culture=neutral, PublicKeyToken=null");

            if (fontAssetType != null && fontAssetType.IsInstanceOfType(asset))
            {
                // TMPro texture atlases are always Linear space
                rtReadWrite = UnityEngine.RenderTextureReadWrite.Linear;
            }

            // Create a temporary RenderTexture of the same size as the texture
            var tmp = UnityEngine.RenderTexture.GetTemporary(
                texture.width,
                texture.height,
                0,
                UnityEngine.RenderTextureFormat.Default,
                rtReadWrite);

            // Blit the pixels on texture to the RenderTexture
            UnityEngine.Graphics.Blit(texture, tmp);

            // Backup the currently set RenderTexture
            var previous = UnityEngine.RenderTexture.active;

            // Set the current RenderTexture to the temporary one we created
            UnityEngine.RenderTexture.active = tmp;

            // Create a new readable Texture2D to copy the pixels to it
            var result = new UnityEngine.Texture2D(texture.width, texture.height, format, false);

            // Copy the pixels from the RenderTexture to the new Texture
            result.ReadPixels(new UnityEngine.Rect(0, 0, tmp.width, tmp.height), 0, 0);
            result.Apply();

            // Broadcast alpha to color
            if (alphaOnly || !HasColor(texture))
            {
                var pixels = result.GetPixels();
                for (var i = 0; i < pixels.Length; i++)
                {
                    pixels[i].r = pixels[i].a;
                    pixels[i].g = pixels[i].a;
                    pixels[i].b = pixels[i].a;
                }

                result.SetPixels(pixels);
                result.Apply();
            }

            // Reset the active RenderTexture
            UnityEngine.RenderTexture.active = previous;

            // Release the temporary RenderTexture
            UnityEngine.RenderTexture.ReleaseTemporary(tmp);
            return(result);
        }
Example #21
0
 public void SetBufferDescription(int index, string stringId, RenderTextureFormat inFormat, RenderTextureReadWrite inSRGBWrite)
 {
     IDs[index]        = Shader.PropertyToID(stringId);
     RTIDs[index]      = new RenderTargetIdentifier(IDs[index]);
     formats[index]    = inFormat;
     sRGBWrites[index] = inSRGBWrite;
 }
Example #22
0
    public void Init()
    {
        switch (captureType)
        {
        case CaptureType.Capture:
            rtFormat    = RenderTextureFormat.ARGB32;
            rtReadWrite = RenderTextureReadWrite.sRGB;
            rtDepth     = 24;
            break;

        case CaptureType.Segmentation:
            rtFormat    = RenderTextureFormat.ARGB32;
            rtReadWrite = RenderTextureReadWrite.sRGB;
            rtDepth     = 24;
            break;

        case CaptureType.Depth:
            rtFormat    = RenderTextureFormat.ARGB32;
            rtReadWrite = RenderTextureReadWrite.Linear;
            rtDepth     = 24;
            break;

        default:
            break;
        }

        switch (resolutionType)
        {
        case ResolutionType.SD:
            videoWidth  = 640;
            videoHeight = 480;
            break;

        case ResolutionType.HD:
            videoWidth  = 1920;
            videoHeight = 1080;
            break;

        default:
            break;
        }

        RenderTexture activeRT = new RenderTexture(videoWidth, videoHeight, rtDepth, rtFormat, rtReadWrite)
        {
            dimension       = UnityEngine.Rendering.TextureDimension.Tex2D,
            antiAliasing    = 1,
            useMipMap       = false,
            useDynamicScale = false,
            wrapMode        = TextureWrapMode.Clamp,
            filterMode      = FilterMode.Bilinear
        };

        activeRT.name = captureType.ToString() + resolutionType.ToString();
        activeRT.Create();

        renderCam = GetComponent <Camera>();
        renderCam.targetTexture = activeRT;

        Reader = new AsyncTextureReader <byte>(renderCam.targetTexture);

        GetComponentInParent <CameraSettingsManager>().AddCamera(renderCam);

        addUIElement();
    }
 public void GetTemporaryRT(int nameID, int width, int height, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite, int antiAliasing, bool enableRandomWrite)
 {
     GetTemporaryRT(nameID, width, height, depthBuffer, filter, format, readWrite, antiAliasing, enableRandomWrite, RenderTextureMemoryless.None);
 }
Example #24
0
        PropertySheet PreRender(PostProcessRenderContext context, int occlusionSource)
        {
            radius = Mathf.Max(radius, 1e-4f);
            var cmd = context.command;

            // Material setup
            // Always use a quater-res AO buffer unless High/Ultra quality is set.
            bool  downsampling = (int)quality < (int)Quality.High;
            float px           = intensity;
            float py           = radius;
            float pz           = downsampling ? 0.5f : 1f;
            float pw           = m_SampleCount[(int)quality];

            var sheet = context.propertySheets.Get(context.resources.shaders.ambientOcclusion);

            sheet.ClearKeywords();
            sheet.properties.SetVector(ShaderIDs.AOParams, new Vector4(px, py, pz, pw));

            // In forward fog is applied at the object level in the grometry pass so we need to
            // apply it to AO as well or it'll drawn on top of the fog effect.
            // Not needed in Deferred.
            if (context.camera.actualRenderingPath == RenderingPath.Forward && RenderSettings.fog)
            {
                sheet.properties.SetVector(ShaderIDs.FogParams, new Vector3(RenderSettings.fogDensity, RenderSettings.fogStartDistance, RenderSettings.fogEndDistance));

                switch (RenderSettings.fogMode)
                {
                case FogMode.Linear:
                    sheet.EnableKeyword("FOG_LINEAR");
                    break;

                case FogMode.Exponential:
                    sheet.EnableKeyword("FOG_EXP");
                    break;

                case FogMode.ExponentialSquared:
                    sheet.EnableKeyword("FOG_EXP2");
                    break;
                }
            }

            // Texture setup
            int tw = context.width;
            int th = context.height;
            int ts = downsampling ? 2 : 1;
            const RenderTextureFormat    kFormat = RenderTextureFormat.ARGB32;
            const RenderTextureReadWrite kRWMode = RenderTextureReadWrite.Linear;
            const FilterMode             kFilter = FilterMode.Bilinear;

            // AO buffer
            var rtMask = ShaderIDs.OcclusionTexture1;

            cmd.GetTemporaryRT(rtMask, tw / ts, th / ts, 0, kFilter, kFormat, kRWMode);

            // AO estimation
            cmd.BlitFullscreenTriangle(BuiltinRenderTextureType.None, rtMask, sheet, (int)Pass.OcclusionEstimationForward + occlusionSource);

            // Blur buffer
            var rtBlur = ShaderIDs.OcclusionTexture2;

            // Separable blur (horizontal pass)
            cmd.GetTemporaryRT(rtBlur, tw, th, 0, kFilter, kFormat, kRWMode);
            cmd.BlitFullscreenTriangle(rtMask, rtBlur, sheet, (int)Pass.HorizontalBlurForward + occlusionSource);
            cmd.ReleaseTemporaryRT(rtMask);

            // Separable blur (vertical pass)
            rtMask = ShaderIDs.OcclusionTexture;
            cmd.GetTemporaryRT(rtMask, tw, th, 0, kFilter, kFormat, kRWMode);
            cmd.BlitFullscreenTriangle(rtBlur, rtMask, sheet, (int)Pass.VerticalBlur);
            cmd.ReleaseTemporaryRT(rtBlur);

            return(sheet);
        }
 extern public void GetTemporaryRTArray(int nameID, int width, int height, int slices, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite, int antiAliasing, bool enableRandomWrite, bool useDynamicScale);
Example #26
0
    // Token: 0x06006ADB RID: 27355 RVA: 0x00349B90 File Offset: 0x00347D90
    public RenderTexture JOLPMHHECLG(int KJGMGPCEJJD, int DFKQMMIQDOO, int MBDMCBIEFMD = 0, RenderTextureFormat EIBOBKJIGQB = RenderTextureFormat.ARGBHalf, RenderTextureReadWrite OQMJFJDFJND = RenderTextureReadWrite.Default, FilterMode COONGPMDHLH = FilterMode.Bilinear, TextureWrapMode JPHMBHNQPNO = TextureWrapMode.Clamp, string IHIHHCCEDHQ = "FactoryTempTexture")
    {
        RenderTexture temporary = RenderTexture.GetTemporary(KJGMGPCEJJD, DFKQMMIQDOO, MBDMCBIEFMD, EIBOBKJIGQB, OQMJFJDFJND);

        temporary.filterMode = COONGPMDHLH;
        temporary.wrapMode   = JPHMBHNQPNO;
        temporary.name       = IHIHHCCEDHQ;
        this.PJPCIMJDMBB.Add(temporary);
        return(temporary);
    }
 public void GetTemporaryRTArray(int nameID, int width, int height, int slices, int depthBuffer, FilterMode filter, RenderTextureFormat format, RenderTextureReadWrite readWrite)
 {
     GetTemporaryRTArray(nameID, width, height, slices, depthBuffer, filter, format, readWrite, 1);
 }
Example #28
0
        public RenderTexture Get(int width, int height, int depthBuffer = 0, RenderTextureFormat format = RenderTextureFormat.ARGBHalf, RenderTextureReadWrite rw = RenderTextureReadWrite.Default, FilterMode filterMode = FilterMode.Bilinear, TextureWrapMode wrapMode = TextureWrapMode.Clamp, string name = "FactoryTempTexture")
        {
            RenderTexture temporary = RenderTexture.GetTemporary(width, height, depthBuffer, format, rw);

            temporary.filterMode = filterMode;
            temporary.wrapMode   = wrapMode;
            temporary.name       = name;
            this.m_TemporaryRTs.Add(temporary);
            return(temporary);
        }
        /// <summary>
        /// Grabs a temporary render target with the current display size.
        /// </summary>
        /// <param name="cmd">The command buffer to grab a render target from</param>
        /// <param name="nameID">The shader property name for this texture</param>
        /// <param name="depthBufferBits">The number of bits to use for the depth buffer</param>
        /// <param name="colorFormat">The render texture format</param>
        /// <param name="readWrite">The color space conversion mode</param>
        /// <param name="filter">The texture filtering mode</param>
        /// <param name="widthOverride">Override the display width; use <c>0</c> to disable the override</param>
        /// <param name="heightOverride">Override the display height; use <c>0</c> to disable the override</param>
        public void GetScreenSpaceTemporaryRT(CommandBuffer cmd, int nameID,
                                              int depthBufferBits = 0, RenderTextureFormat colorFormat     = RenderTextureFormat.Default, RenderTextureReadWrite readWrite = RenderTextureReadWrite.Default,
                                              FilterMode filter   = FilterMode.Bilinear, int widthOverride = 0, int heightOverride = 0)
        {
#if UNITY_2017_2_OR_NEWER
            var desc = GetDescriptor(depthBufferBits, colorFormat, readWrite);
            if (widthOverride > 0)
            {
                desc.width = widthOverride;
            }
            if (heightOverride > 0)
            {
                desc.height = heightOverride;
            }

            //intermediates in VR are unchanged
            if (stereoActive && desc.dimension == Rendering.TextureDimension.Tex2DArray)
            {
                desc.dimension = Rendering.TextureDimension.Tex2D;
            }

#if UNITY_2019_1_OR_NEWER
            cmd.GetTemporaryRT(nameID, desc, filter);
#elif UNITY_2017_3_OR_NEWER
            cmd.GetTemporaryRT(nameID, desc.width, desc.height, desc.depthBufferBits, filter, desc.colorFormat, readWrite, desc.msaaSamples, desc.enableRandomWrite, desc.memoryless, m_Camera.allowDynamicResolution);
#else
            cmd.GetTemporaryRT(nameID, desc.width, desc.height, desc.depthBufferBits, filter, desc.colorFormat, readWrite, desc.msaaSamples, desc.enableRandomWrite, desc.memoryless);
#endif
#else
            int actualWidth  = width;
            int actualHeight = height;
            if (widthOverride > 0)
            {
                actualWidth = widthOverride;
            }
            if (heightOverride > 0)
            {
                actualHeight = heightOverride;
            }

            cmd.GetTemporaryRT(nameID, actualWidth, actualHeight, depthBufferBits, filter, colorFormat, readWrite);
            // TODO: How to handle MSAA for XR in older versions?  Query cam?
            // TODO: Pass in vrUsage into the args
#endif
        }
Example #30
0
 public RenderTexture(int width, int height, int depth, [uei.DefaultValue("RenderTextureFormat.Default")] RenderTextureFormat format, [uei.DefaultValue("RenderTextureReadWrite.Default")] RenderTextureReadWrite readWrite)
     : this(width, height, depth, GetCompatibleFormat(format, readWrite))
 {
 }
        private RenderTextureDescriptor GetDescriptor(int depthBufferBits = 0, RenderTextureFormat colorFormat = RenderTextureFormat.Default, RenderTextureReadWrite readWrite = RenderTextureReadWrite.Default)
        {
            var modifiedDesc = new RenderTextureDescriptor(m_sourceDescriptor.width, m_sourceDescriptor.height,
                                                           m_sourceDescriptor.colorFormat, depthBufferBits);

            modifiedDesc.dimension   = m_sourceDescriptor.dimension;
            modifiedDesc.volumeDepth = m_sourceDescriptor.volumeDepth;
            modifiedDesc.vrUsage     = m_sourceDescriptor.vrUsage;
            modifiedDesc.msaaSamples = m_sourceDescriptor.msaaSamples;
            modifiedDesc.memoryless  = m_sourceDescriptor.memoryless;

            modifiedDesc.useMipMap          = m_sourceDescriptor.useMipMap;
            modifiedDesc.autoGenerateMips   = m_sourceDescriptor.autoGenerateMips;
            modifiedDesc.enableRandomWrite  = m_sourceDescriptor.enableRandomWrite;
            modifiedDesc.shadowSamplingMode = m_sourceDescriptor.shadowSamplingMode;

            if (colorFormat != RenderTextureFormat.Default)
            {
                modifiedDesc.colorFormat = colorFormat;
            }
            if (readWrite != RenderTextureReadWrite.Default)
            {
                modifiedDesc.sRGB = (readWrite != RenderTextureReadWrite.Linear);
            }

            return(modifiedDesc);
        }
Example #32
0
 // Be careful. We can't call base constructor here because it would create the native object twice.
 public CustomRenderTexture(int width, int height, RenderTextureFormat format, RenderTextureReadWrite readWrite)
     : this(width, height, GetCompatibleFormat(format, readWrite))
 {
 }
Example #33
0
    static int GetTemporary(IntPtr L)
    {
        int count = LuaDLL.lua_gettop(L);

        if (count == 2)
        {
            int           arg0 = (int)LuaScriptMgr.GetNumber(L, 1);
            int           arg1 = (int)LuaScriptMgr.GetNumber(L, 2);
            RenderTexture o    = RenderTexture.GetTemporary(arg0, arg1);
            LuaScriptMgr.Push(L, o);
            return(1);
        }
        else if (count == 3)
        {
            int           arg0 = (int)LuaScriptMgr.GetNumber(L, 1);
            int           arg1 = (int)LuaScriptMgr.GetNumber(L, 2);
            int           arg2 = (int)LuaScriptMgr.GetNumber(L, 3);
            RenderTexture o    = RenderTexture.GetTemporary(arg0, arg1, arg2);
            LuaScriptMgr.Push(L, o);
            return(1);
        }
        else if (count == 4)
        {
            int arg0 = (int)LuaScriptMgr.GetNumber(L, 1);
            int arg1 = (int)LuaScriptMgr.GetNumber(L, 2);
            int arg2 = (int)LuaScriptMgr.GetNumber(L, 3);
            RenderTextureFormat arg3 = LuaScriptMgr.GetNetObject <RenderTextureFormat>(L, 4);
            RenderTexture       o    = RenderTexture.GetTemporary(arg0, arg1, arg2, arg3);
            LuaScriptMgr.Push(L, o);
            return(1);
        }
        else if (count == 5)
        {
            int arg0 = (int)LuaScriptMgr.GetNumber(L, 1);
            int arg1 = (int)LuaScriptMgr.GetNumber(L, 2);
            int arg2 = (int)LuaScriptMgr.GetNumber(L, 3);
            RenderTextureFormat    arg3 = LuaScriptMgr.GetNetObject <RenderTextureFormat>(L, 4);
            RenderTextureReadWrite arg4 = LuaScriptMgr.GetNetObject <RenderTextureReadWrite>(L, 5);
            RenderTexture          o    = RenderTexture.GetTemporary(arg0, arg1, arg2, arg3, arg4);
            LuaScriptMgr.Push(L, o);
            return(1);
        }
        else if (count == 6)
        {
            int arg0 = (int)LuaScriptMgr.GetNumber(L, 1);
            int arg1 = (int)LuaScriptMgr.GetNumber(L, 2);
            int arg2 = (int)LuaScriptMgr.GetNumber(L, 3);
            RenderTextureFormat    arg3 = LuaScriptMgr.GetNetObject <RenderTextureFormat>(L, 4);
            RenderTextureReadWrite arg4 = LuaScriptMgr.GetNetObject <RenderTextureReadWrite>(L, 5);
            int           arg5          = (int)LuaScriptMgr.GetNumber(L, 6);
            RenderTexture o             = RenderTexture.GetTemporary(arg0, arg1, arg2, arg3, arg4, arg5);
            LuaScriptMgr.Push(L, o);
            return(1);
        }
        else
        {
            LuaDLL.luaL_error(L, "invalid arguments to method: RenderTexture.GetTemporary");
        }

        return(0);
    }
        void Render(PostProcessRenderContext context, CommandBuffer cmd, int occlusionSource)
        {
            DoLazyInitialization(context);
            m_Settings.radius.value = Mathf.Max(m_Settings.radius.value, 1e-4f);

            // Material setup
            // Always use a quater-res AO buffer unless High/Ultra quality is set.
            bool  downsampling = (int)m_Settings.quality.value < (int)AmbientOcclusionQuality.High;
            float px           = m_Settings.intensity.value;
            float py           = m_Settings.radius.value;
            float pz           = downsampling ? 0.5f : 1f;
            float pw           = m_SampleCount[(int)m_Settings.quality.value];

            var sheet = m_PropertySheet;

            sheet.ClearKeywords();
            sheet.properties.SetVector(ShaderIDs.AOParams, new Vector4(px, py, pz, pw));
            sheet.properties.SetVector(ShaderIDs.AOColor, Color.white - m_Settings.color.value);

            // In forward fog is applied at the object level in the grometry pass so we need to
            // apply it to AO as well or it'll drawn on top of the fog effect.
            // Not needed in Deferred.
            if (context.camera.actualRenderingPath == RenderingPath.Forward && RenderSettings.fog)
            {
                sheet.EnableKeyword("APPLY_FORWARD_FOG");
                sheet.properties.SetVector(
                    ShaderIDs.FogParams,
                    new Vector3(RenderSettings.fogDensity, RenderSettings.fogStartDistance, RenderSettings.fogEndDistance)
                    );
            }

            // Texture setup
            int ts = downsampling ? 2 : 1;
            const RenderTextureFormat    kFormat = RenderTextureFormat.ARGB32;
            const RenderTextureReadWrite kRWMode = RenderTextureReadWrite.Linear;
            const FilterMode             kFilter = FilterMode.Bilinear;

            // AO buffer
            var rtMask       = ShaderIDs.OcclusionTexture1;
            int scaledWidth  = context.width / ts;
            int scaledHeight = context.height / ts;

            context.GetScreenSpaceTemporaryRT(cmd, rtMask, 0, kFormat, kRWMode, kFilter, scaledWidth, scaledHeight);

            // AO estimation
            cmd.BlitFullscreenTriangle(BuiltinRenderTextureType.None, rtMask, sheet, (int)Pass.OcclusionEstimationForward + occlusionSource);

            // Blur buffer
            var rtBlur = ShaderIDs.OcclusionTexture2;

            context.GetScreenSpaceTemporaryRT(cmd, rtBlur, 0, kFormat, kRWMode, kFilter);

            // Separable blur (horizontal pass)
            cmd.BlitFullscreenTriangle(rtMask, rtBlur, sheet, (int)Pass.HorizontalBlurForward + occlusionSource);
            cmd.ReleaseTemporaryRT(rtMask);

            // Separable blur (vertical pass)
            cmd.BlitFullscreenTriangle(rtBlur, m_Result, sheet, (int)Pass.VerticalBlur);
            cmd.ReleaseTemporaryRT(rtBlur);

            if (context.IsDebugOverlayEnabled(DebugOverlay.AmbientOcclusion))
            {
                context.PushDebugOverlay(cmd, m_Result, sheet, (int)Pass.DebugOverlay);
            }
        }
Example #35
0
        /// <summary>
        /// Called when the object is instanciated, but before Update()
        /// is called for the first time
        /// </summary>
        void Start()
        {
            // Initialize mask textures if needed
            if (_UseBodyMasks) { InitializeBodyMask(); }

            // If we have skinned items that aren't initialized, do that now
            for (int i = 0; i < SkinnedItems.Count; i++)
            {
                SkinnedItem lItem = SkinnedItems[i];
                if (lItem._InstantiateOnStart || lItem.GameObject != null)
                {
                    if (lItem.ResourcePath.Length > 0 && lItem.GameObject == null)
                    {
                        lItem.CreateInstance(this);
                    }

                    if (_UseBodyMasks && lItem.MaskPath.Length > 0)
                    {
                        lItem.CreateMask();
                    }
                }
            }

            if (QualitySettings.activeColorSpace != ColorSpace.Linear)
            {
                mRenderTextureColorSpace = RenderTextureReadWrite.Default;
            }

            // Apply the body masks if needed
            ApplyBodyMasks();
        }
		public static RenderTexture GetTemporary(int width, int height, int depthBuffer, RenderTextureFormat format, RenderTextureReadWrite readWrite){}
		public static RenderTexture GetTemporary(int width, int height, int depthBuffer, RenderTextureFormat format, RenderTextureReadWrite readWrite)
		{
			int antiAliasing = 1;
			return RenderTexture.GetTemporary(width, height, depthBuffer, format, readWrite, antiAliasing);
		}
		public RenderTexture(int width, int height, int depth, RenderTextureFormat format, RenderTextureReadWrite readWrite){}