Search Unity

  1. We are migrating the Unity Forums to Unity Discussions by the end of July. Read our announcement for more information and let us know if you have any questions.
    Dismiss Notice
  2. Dismiss Notice

Official Introduction of Render Graph in the Universal Render Pipeline (URP)

Discussion in 'Universal Render Pipeline' started by oliverschnabel, Oct 2, 2023.

  1. ManueleB

    ManueleB

    Unity Technologies

    Joined:
    Jul 6, 2020
    Posts:
    110
    Exactly :)
    The frame resources/context container system was designed to give you full control of the pipeline render targets, so at any point you can setup your own targets to become the new cameraColor, or replace any target used by builtin passes, this allows for real full customization with no need of reflection or forking.

    Just a caveat you need to be aware of: if you are using camera stacking, please make sure that if you replaced UniversalRenderingData.cameraColorTarget to point to your own resource, to copy your results back to the original cameraColorTarget attachment by the end of the camera frame, because the next camera in the stack will just reuse this attachment loading its contents, so you won't lose the results of the first camera and the overlay one will render to the right attachment
     
    ElliotB, Yoraiz0r and colin299 like this.
  2. ManueleB

    ManueleB

    Unity Technologies

    Joined:
    Jul 6, 2020
    Posts:
    110
    yeah moving in a dedicated pass at the start of the frame would work.

    Regarding the builtin passes 90% of the operations done in OnCameraSetup were just needed to be executed before the actual pass, so in that case we just moved that code at the start of the specific pass RecordRenderGraph function, so if the setup is only for a single pass that should work too
     
    Yoraiz0r likes this.
  3. ElliotB

    ElliotB

    Joined:
    Aug 11, 2013
    Posts:
    301
    This looks great, I'm genuinely excited by the thought of upgrading to the new system, which is definitely a surprise.

    Thanks for the heads up, that does seem like a 'gotcha' that might catch people in the future. Is that because a new rendergraph is created and executed for each camera?

    I presume by 'pass' here you mean frame? (My calculations are intended to be used by multiple different passes on a per-frame basis).
     
    AljoshaD and oliverschnabel like this.
  4. ManueleB

    ManueleB

    Unity Technologies

    Joined:
    Jul 6, 2020
    Posts:
    110
    Yeah I know it's very painful to go through such a big update (and also to ask users to do it, trust me :) ), but as you are starting to notice we firmly believe that this API will be a game changer for URP and for the customization possibilities, you will have 100% control of the pipeline, same as the internal Unity developers, so the sky is the limit at that point. So it was very important for us to make sure that when URP becomes the default all the new systems are in place, even if that means going to this major update. After that you should expect only minor incremental improvements, but nothing majorly "breaking" anymore

    Yeah currently camera stacking executes a RG per camera. It's something we plan to improve in the future by having all cameras run in a single RG, but not there yet. So just make sure that the original cameraColor RT is updated by the end of the camera frame to guarantee camera stacking functionality

    if your PreCamera code is only used by a single ScriptableRenderPass, then you can just move it at the start of that ScriptableRenderPass RecordRenderGraph override. If it's needed by multiple passes then your solution is fine, just make a new ScriptableRenderPass and enqueue it at the start of your frame
     
    Yoraiz0r, ElliotB, AljoshaD and 2 others like this.
  5. ManueleB

    ManueleB

    Unity Technologies

    Joined:
    Jul 6, 2020
    Posts:
    110
    regarding this, if you want to avoid having to copy back your results to the original RT, you can just do the following:

    • manually manage your custom RT as an RTHandle and IMPORT it in RenderGraph (so don't use RenderGraph.CreateTexture, since that texture lifetime would be bound to that specific camera RG execution)
    • make sure every camera sets your custom imported RT as the cameraColor at the start of the frame
    this way camera stacking would work just fine and no need of extra blits
     
    Jeakim and Yoraiz0r like this.
  6. Yoraiz0r

    Yoraiz0r

    Joined:
    Apr 26, 2015
    Posts:
    96
    I just downloaded 2023.3.0b2 and sadly it's still there :(
     
  7. oliverschnabel

    oliverschnabel

    Unity Technologies

    Joined:
    Mar 13, 2018
    Posts:
    50
    I assume the template is cached on your side. The upwards-facing arrow on the template button indicates that. On the right there is then an "Upgrade" button if that is the case, that downloads the newest template. upload_2024-1-11_9-48-22.png
     
    Yoraiz0r likes this.
  8. Yoraiz0r

    Yoraiz0r

    Joined:
    Apr 26, 2015
    Posts:
    96
    That button isn't there. Anything else that could help diagnose the issue?
    On a fresh 2023.3.0b2 project I still get the allocation leaks.
    URP is on version 17.0.1
    Core RP Library is on 17.0.1 as well, and I've confirmed the line you mentioned earlier is there, yet the leaks persist.

    upload_2024-1-12_0-0-46.png
    Code (CSharp):
    1.  
    2.         public void Clear()
    3.         {
    4.             passData.Clear();
    5.             fences.Clear();
    6.             passNames.Clear();
    7.             inputData.Clear();
    8.             outputData.Clear();
    9.             fragmentData.Clear();
    10.             randomAccessResourceData.Clear();
    11.             resources.Clear();
    12.             nativePassData.Clear();
    13.             nativeSubPassData.Clear();
    14.             createData.Clear();
    15.             destroyData.Clear();
    16.         }
    What steps would you like me to take to figure it out? how can I locally import the core RP library to edit this code?
    I've attached the full console logs (4) as a single txt attachment if it helps...
     

    Attached Files:

  9. arttu_p

    arttu_p

    Unity Technologies

    Joined:
    Jan 15, 2021
    Posts:
    25
    Hi Yoraiz0r, the fix is unfortunately still in the release pipeline and it will arrive in 2023.3.0b4. You can see the fix mirrored to our public repo here. The code you pasted above is from the Clear() method - the issue was a missing Dispose() call inside the Cleanup() method.

    If you want to try it out locally, you can copy the package folder from <projectpath>/Library/PackageCache/ to <projectpath>/Packages/, you'll be able to edit the code there.
     
    Yoraiz0r likes this.
  10. oliverschnabel

    oliverschnabel

    Unity Technologies

    Joined:
    Mar 13, 2018
    Posts:
    50
    I mixed up the questions. This message from me was related to RenderGraph not being enabled by default when starting from templates in the hub. This is fixed and new projects don't show the warning anymore, and have RenderGraph enabled. Upgraded projects start in "Compatibility Mode (RenderGraph disabled)".

    As Arttu confirmed above, the memory leak fix will land later, but you could try it with the local package. Thanks for testing!
     
  11. bugfinders

    bugfinders

    Joined:
    Jul 5, 2018
    Posts:
    2,215
    Yes the "how dare you not be using rendergraph" does seem to have gone but what i did see, is that my main project suddenly lost a load of prefab links in b2, for no obvious reason, but not all - of course not all, no no that would be too simple. It also seems the first time I run it, i get like 90+ fps, next time 70+ and at one point 3.. yes 3 whole fps.. yet, i changed nothing between the runs. Now, admittedly this is with the built in pipeline - why cos lighting is the bane of my life, and so far the only one which does what i believe to be the correct behavior is the built in.. and lifes too short without making more fights. So, it seems there is a big wonky going on in b2 somewhere..
     
  12. kripto289

    kripto289

    Joined:
    Feb 21, 2013
    Posts:
    541
  13. Le_Tai

    Le_Tai

    Joined:
    Jun 20, 2014
    Posts:
    443
    Is there a best practice for storing data for the render pass that is different for each camera? Previously I maintained a dictionary indexed by renderingData.cameraData.camera. The data is initialized when a new camera is seen. It works fine, but there doesn't seem to be a clean and simple way to clean up those data when a camera is removed. It is not a big deal, I just wonder if something like this was done in Unity's SRP code and if so how it was done.
     
  14. ElliotB

    ElliotB

    Joined:
    Aug 11, 2013
    Posts:
    301
    A note for other asset store devs - you are only allowed to have one 'major update' (eg, one that can charge users of a previous version) every 6 months. If you already pushed a major update in the last ~3 months, you likely won't be able to charge for rewriting your asset to use RenderGraph in time for the April release date.
     
    nasos_333 likes this.
  15. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    I think i will keep it as a free Beta for few years.

    An actual release for Render Graph, something so early and that will be in early Alpha fully experimental version when releases and finalized probably years later, would be too risky.

    I just got a 1 star review because Unity crashed on a user, from probably a totally unrelated crash to my asset as i never got it replicated, so with the state Unity and URP are at, any official release seems like a distant dream at this point.

    Plus with how URP is developed, the Graph could be changed to something totally different before it even reaches a stabled well tested release candidate in 2025 or 2026.
     
    JesterGameCraft and BOXOPHOBIC like this.
  16. ElliotB

    ElliotB

    Joined:
    Aug 11, 2013
    Posts:
    301
    Personally, I'm very excited for the ShaderGraph changes - great combo of better performance, nicer API and more flexibility. Painful to change so far into URPs life, but I think it will be well worth it here
     
    AljoshaD likes this.
  17. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    Maybe indeed is better, but for sure is not yet something ready or battle tested.

    It is like the URP release was reset to zero actually, with all cycle of development problems and changes reset.

    Will be years until it reaches anywhere close to a developement ready state, and that given it does not change to a totally different new API in the mean time.

    Because frankly so far seems extremely chaotic, the fact that there is an "unsafe mode" means to me that should avoid it for at least few years.

    I cant even imagine the design document that this new Render Graph system was built on. Seems like there was no design document at all so far. Just add random things as it goes to fill the holes where something is needed. And this just few weeks before a full actual release.
     
    Last edited: Jan 18, 2024
  18. AljoshaD

    AljoshaD

    Unity Technologies

    Joined:
    May 27, 2019
    Posts:
    283
    Thank you for sharing, we share your excitement!

    Since we have an expert crowd here, I can recommend looking at this presentation from Chao Wang at GDC last year "Cross-Platform Mobile and PC Rendering in 'Earth Revivall" about how they modified Unity and URP and built their own RenderGraph in an older Unity version.

    Their reasoning for adopting a RenderGraph system is similar to ours (see below), but we also have the additional benefit of unifying the foundation of the SRPs since HDRP is using RenderGraph already, and by providing a highly flexible and consistent extension API, that will also be adopted by HDRP.

    What Chao Wang mentions in his presentation:
    • Maximum Platform Scalability
      • Platforms x QualitySettings combinations of rendering features require auto dependency resolution.
      • Older mobile devices without tile-based GPU architectures require fallback to forward rendering.
      • The engine is shared across multiple games, requiring customization of various rendering pipelines.
      • Optimization techniques for cross-platform scalability
    • Decoupled passes:
      • No care about render passes or subpasses.
      • Just declare render targets to read/write.
    • Automatically set store action and storage mode.
      • Almost impossible to maintain without render graph.
    • General-purpose pass library
      • Build unique render pipelines by selecting passes.
      • Most are common for both forward and deferred rendering.
      • Has dedicated passes for deferred rendering.
      • Common post-process passes.
     
    tatoforever and ElliotB like this.
  19. AljoshaD

    AljoshaD

    Unity Technologies

    Joined:
    May 27, 2019
    Posts:
    283
    Since you have shared many concerns, happy to read this :)

    The Unsafe Pass is intendent and an important part of the API. The "Unsafe" name was inspired by the C# unsafe keyword, that allows you more freedom in the commands with less guardrails, increasing the power and flexibility but at the cost of allowing you to shoot yourself in the foot. It also enables reducing the RenderGraph CPU cost, to avoid needing to add many RasterPasses that RG needs to analyse, when you know they can't be merged anyway (see URP Bloom). It also facilitates upgrading an existing script, which is a top concern expressed in this thread as well. The general recommendation is ofcourse to use Raster/Compute pass since this is more future proof and likely to give the best GPU performance. The alpha documentation and a number of other posts in this thread explain that in more detail.

    This seems very harsh. There have been many design documents. Do you have an example of something that seems not designed well?

    We of course have a lot of constraints in our design. Like many here have asked, we always need to take backwards compatibility into account, or simplify upgrading and supporting multiple version. And of course we wanted to unify the foundation with HDRP, so we could not radically change RenderGraph as well. We decided to build on the battle tested HDRP RenderGraph system for consistency, etc.

    We'd like to do this in the next months so happy to hear more tangible feedback so we can have a great final release.
     
    Last edited: Jan 18, 2024
  20. ElliotB

    ElliotB

    Joined:
    Aug 11, 2013
    Posts:
    301
    The current (pre-RenderGraph) API was a nightmare for this - for example if you wanted the depth target as input, so you could modify the screen depth, you actually wanted to not use ConfigureInput(ScriptableRenderPassInput.Depth) because doing so would move the CopyDepth pass in front of your pass and make the _CameraDepthTexture unaffected by your shaders (even though you still burn the gpu cycles to compute their results). I think the biggest sell for me is the render target inspector you posted a few shots back, showing the RTHandle read/write through the pipeline, I can see that will be excellent for debugging too.

    I do feel this is fair criticism of URP generally in the last year - I think it's a combination of feature creep (URP piling in more and more and more features as it tries to cover every use case), and presumably devs diverting attention to work on the RenderGraph move. It made the 2022 cycle particularly rough, with that massive memory leak around 2022.3.8-2022.3.10 being especially noteable as a nasty experience in the recommended editor version. There was also the blit rework, which caused API changes (and perhaps more frustratingly for most devs, .shader changes rather than .cs changes) and broke a bunch of older render features.

    The biggest issue for me has been constantly changing behavior of 'how to blit to depth of scene' and 'how to blit to color of scene' across versions. For instance, this snippet below is the only way I could get a render feature to correctly blit to the depth buffer of the scene tab across Unity 2020.3.48f1 + URP 10.10.1, Unity 2021.3.33f1 + URP 12.1.13, Unity 2022.3.16f1 + URP 14.0.9 and Unity 2023.2.3f1 + URP 16.0.4 and Metal, openGL, directX (which took a lot of testing) for the recent v1.8.1 update of ProPixelizer:

    Code (CSharp):
    1. // FIX: Scene and preview camera depth.
    2.             #if UNITY_2020_3_OR_NEWER
    3.                 if (renderingData.cameraData.cameraType == CameraType.SceneView || renderingData.cameraData.cameraType == CameraType.Preview)
    4.                 {
    5.                     #if UNITY_2021_1_OR_NEWER
    6.                         var universalRenderer = renderingData.cameraData.renderer as UniversalRenderer;
    7.                     #else
    8.                         var universalRenderer = renderingData.cameraData.renderer as ForwardRenderer;
    9.                     #endif
    10.                     if (universalRenderer != null)
    11.                     {
    12.                         #if UNITY_2022_1_OR_NEWER
    13.                             var cameraDepthTexture = (RTHandle)CameraDepthTextureGetter.GetValue(universalRenderer);
    14.                         #else
    15.                             var cameraDepthTexture = (RenderTargetHandle)CameraDepthTextureGetter.GetValue(universalRenderer);
    16.                         #endif
    17.  
    18.                         if (!isOverlay && cameraDepthTexture != null)
    19.                         {
    20.                             #if UNITY_2022_1_OR_NEWER
    21.                                 Blit(buffer, _CameraDepthAttachmentTemp, cameraDepthTexture, Materials.CopyDepth);
    22.                             #else
    23.                                 var depthTarget = cameraDepthTexture.Identifier();
    24.                                 if (renderingData.cameraData.renderer.cameraDepthTarget == BuiltinRenderTextureType.CameraTarget)
    25.                                     depthTarget = ColorTarget;
    26.                                 Blit(buffer, _CameraDepthAttachmentTemp, depthTarget, Materials.CopyDepth);
    27.                             #endif
    28.                         }
    29.                     }
    30.                 }
    31.             #endif
    The main pain with these types of behavior change is that they are entirely undocumented 'quirks' of the system. So my main hope for the new API is that it keeps the behavior consistent from here onwards, so that we don't need to spend time hunting down edge cases across multiple engine versions and platforms. Anyway, still excited for the RG API!
     
  21. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    Thanks for the feedback, hopefully this time will be something more final we can work on for long time without breaking changes, remains to be seen.

    In my mind, when i saw the unsafe mode, instantly came the question why have to change our current effects at all and you dont just internally convert them to the unsafe commands and if anyone wants to use the graph do so on top of all that.

    That is my main concern with an unsafe API that does what the previous one did.
     
  22. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    Very interesting, so there is a verified big memory leak in some versions ? Could be the reason my asset user got crashes, while i cant replicate it in any of my projects. Will check on it, thanks!
     
  23. ElliotB

    ElliotB

    Joined:
    Aug 11, 2013
    Posts:
    301
    nasos_333 likes this.
  24. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
  25. Kabinet13

    Kabinet13

    Joined:
    Jun 13, 2019
    Posts:
    154
    I really hope rendergraph doesn't make us subscribe to AssemblyReloadEvents.beforeAssemblyReload() to dispose compute buffers before a code reload. Dispose isn't called for render passes before a reload, and it has led a bunch of annoying memory leaks.
     
  26. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    I just got my 1st one star review because of the memory leaks, hopefully will not have anything like that in the coming versions.

    I also had no idea Unity actually released a version with such memory leak and was trying in vein to replicate the issue on another Unity version, so lost many days until found out was actually nothing related to my system that is perfectly stable.

    I frankly would rather see the first Render Graph release in April 2025 and not this year, so can be tested properly than have a release full of bugs.
     
    JesterGameCraft likes this.
  27. AljoshaD

    AljoshaD

    Unity Technologies

    Joined:
    May 27, 2019
    Posts:
    283
    I'm sorry to read that Nasos_333. To be clear for anyone coming into this thread, this was in 22.3 and is unrelated to RenderGraph. In general, RG aims to simplify the URP code and do automatic resource management first and foremost to reduce the chance for bugs like this.
     
    nasos_333 likes this.
  28. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    Hi, thanks for the feedback

    I am trying to convert from the Alpha to Beta and have one strange issue

    Cannot implicitly convert type 'void' to 'UnityEngine.Rendering.RenderGraphModule.TextureHandle'

    I use the TextureHandle tmpBuffer2A; as input to the

    builder.SetRenderAttachmentDepth(tmpBuffer2A, AccessFlags.Write);

    also says the same for

    UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();

    passData.src = builder.UseTexture(resourceData.cameraDepth, AccessFlags.Read);

    Is there any way to restore those ?

    Unity 2023.3.0b4

    thanks a lot in advance
     
    Last edited: Jan 29, 2024
  29. ManueleB

    ManueleB

    Unity Technologies

    Joined:
    Jul 6, 2020
    Posts:
    110
    the UseTexture signature has been changed, used to return a TextureHandle, now it returns void. It was done for safety to avoid resource versioning issues.

    You want to change your code in 2 separate lines:

    Code (CSharp):
    1. builder.UseTexture(resourceData.cameraDepth, AccessFlags.Read);
    2. passData.src = resourceData.cameraDepth;
     
    nasos_333 likes this.
  30. oliverschnabel

    oliverschnabel

    Unity Technologies

    Joined:
    Mar 13, 2018
    Posts:
    50
    Recently, we added the new Render Graph Viewer to 2023.3.0b5 and above. You'll find this updated tool under Window > Analysis > Render Graph Viewer.

    The Render Graph Viewer window displays the sequence of all render passes in the frame. It displays all render passes that come with URP, as well as any custom render passes you create. You can also see how each render pass uses the resources of the frame.

    RenderGraph-Viewer_OverviewWithCustomEffect.png

    One highlight is that you can directly jump to the source line where the pass is added to the Render Graph. This is a very handy way to navigate and learn the URP source code, as well as working with your own code. We hope this tool is a good way for you to extend URP to your needs or to provide awesome assets on the store.

    RenderGraph-Viewer_JumpToSource.gif

    Let us know what you think about the new viewer here.

    One additional nice thing: It also works with HDRP since the two pipelines share the same RenderGraph core under the hood. You can use the same tool to inspect HDRP's passes and jump to the sources.
     
    PaulMDev, ontrigger, OCASM and 9 others like this.
  31. Saniell

    Saniell

    Joined:
    Oct 24, 2015
    Posts:
    216
    Hey this looks really cool. What is does the planet icon on some textures mean?
     
    AljoshaD likes this.
  32. oliverschnabel

    oliverschnabel

    Unity Technologies

    Joined:
    Mar 13, 2018
    Posts:
    50
    This icon shows that the texture is set as a global texture that all shaders and render passes in the scene can use.
     
  33. Saniell

    Saniell

    Joined:
    Oct 24, 2015
    Posts:
    216
    Huh. Sorry I might be missing some context, is there a new API to communicate this? I'm on 2022.3 still, can't find anything looking at SRP Core 17 docs
     
  34. oliverschnabel

    oliverschnabel

    Unity Technologies

    Joined:
    Mar 13, 2018
    Posts:
    50
    This API is related to the new RenderGraph API introduced in 2023.3. You can find more info in the section "Setting Global Textures" in the alpha documentation linked in the first post. Does this help?
     
    OCASM and Saniell like this.
  35. tatoforever

    tatoforever

    Joined:
    Apr 16, 2009
    Posts:
    4,408
    I've been working at my dayjob with UE sources for a couple of months now. We are writing custom render passes and shading models. Unfortunately this requires engines moddifications but not a big deal though, UE sources are clean.
    I can already see some design similatiries with Unity's RG (minus raw pointers and RHI API differencies). But I wanted to mention that this is a great move by Unity. I have a custom renderer for two of our existing Unity projects that I will soon start upgrading to the new RenderGraph.
    I will provide feedback as I move forward with. :)
     
  36. Saniell

    Saniell

    Joined:
    Oct 24, 2015
    Posts:
    216
    Yes, thanks! This is quite nice actually, I was just revisiting some AO code and thought would be great to have better support for globals in render graph
    Hopefully this will help to reduce code coupling somewhat with my SRP
     
    AljoshaD and oliverschnabel like this.
  37. colin299

    colin299

    Joined:
    Sep 2, 2013
    Posts:
    183
    Thank you for the "jump to source" button, I tried it and it is a very pleasing way to read the URP RG source code in the order of rendering event.
     
    Last edited: Feb 12, 2024
    oliverschnabel likes this.
  38. camerondus

    camerondus

    Joined:
    Dec 15, 2018
    Posts:
    65
    I've just spent the last couple of hours trying to convert my asset to use render graph. all my asset needs is a simple blit using a material. I was using cmd.Blit before, which sets "source" to "_MainTex" in the shader. but now i have to use Blitter, which sets "_BlitTexture". changing the shader to be blitter compatible sucks, but its something i can live with. the part that I cant seem to solve, is how can I make my asset work with both Render Graph and Compatibility mode?

    Why is there no simple example for using Blitter to Blit to a temporary destination texture, then back to the camera color target, that works in both Render Graph mode and compatibility mode? This whole upgrade process has been extremely frustrating so far.
     
    nasos_333 likes this.
  39. wwWwwwW1

    wwWwwwW1

    Joined:
    Oct 31, 2021
    Posts:
    791
    Hi, the Blitter (URP 14 and above) also works in non-RG mode and is the replacement of cmd.Blit.
     
    nasos_333 likes this.
  40. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    Imagine how it is with very complex effects, that implement temporal AA and multiple render targets.

    It has been a real hell and i am not even supporting currently both RG and older methods in same time globally, plus everything need months more work at the least, after multiple months porting work already.

    That is if nothing breaks or changes again.

    At this point i plan to create a separate 2023 version that will only support Render Graph and leave my 2022 versions for 2023.3 non RG path support. That way remove a MASSIVE complexity factor that will also hit hard when require to remove the old methods.
     
  41. oliverschnabel

    oliverschnabel

    Unity Technologies

    Joined:
    Mar 13, 2018
    Posts:
    50
    Thanks for the feedback. We are currently creating Utilities to make this much easier. We hope to be able to release a first version soon. Blits will certainly be different between RenderGraph/No-RG but indeed the plan is to be able to share Shaders (and thus material & parameter setting code as well) between both paths. The design is more compatible with the "old" core engine blit (and thus uses _MainTex by default but this can be configured).

    We will share an update in this thread once we are ready. We had to first prioritize to land all required engine changes before we could focus on these utilities.

    There is a new Custom Post-Processing template that you can access in the assets window through Create > Rendering > URP Post-processing Effect (Renderer Feature with Volume).

    upload_2024-2-14_10-28-16.png

    This template has both paths implemented and organizes them nicely in regions:

    upload_2024-2-14_10-33-16.png

    It simply inverses the colors as soon as you add the Renderer Feature to the Renderer:

    upload_2024-2-14_10-34-43.png

    The template also creates a Volume component that controls the intensity of the effect:
    CustomPostProcessingEffect_Template_Volume.gif

    Let us know if this example helps you to support both pathes at the same time. We are also happy to support you here with other concrete questions.
     
  42. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    Thanks, though if have to port hundred of image effects and very complex ones, the biggest help would be to release the Graph after lot of trial and testing in end of year and not in April, the fact that the release is so close is extremely scary. We simply not have the time to not only port the effects but make sure are proper optimized and support the old system as well.

    It is simply not possible.

    Or at least have it as an advanced option until end of year and not the initial default option.
     
    Last edited: Feb 14, 2024
  43. camerondus

    camerondus

    Joined:
    Dec 15, 2018
    Posts:
    65
    The issue is that blitter sets _BlitTexture, not _MainTex. right now, I can get away with using the same image effect shaders for both URP and BIRP, which is less maintenance on my end. I am okay with doing extra maintenance if it means my system will run faster in URP, but I was not even able to get blitter to work with compatibility mode on, my shaders would produce a full pink screen. I will go over the Custom Post Process template today, and hopefully produce better results.
     
    wwWwwwW1 and nasos_333 like this.
  44. ElliotB

    ElliotB

    Joined:
    Aug 11, 2013
    Posts:
    301
    What is the current timeline for RG introduction? Has anything changed in the past weeks/months or are you still looking at ~April sometime for a release? If so, do you have any closer idea on the date yet? Cheers!
     
  45. wwWwwwW1

    wwWwwwW1

    Joined:
    Oct 31, 2021
    Posts:
    791
    In this case, I think you need to use a shader keyword to make it compatible with both RPs if Unity finally doesn't provide a solution.

    I totally agree with this because non-RG mode will be removed in the future, and then people will have to remove them to keep the code clean.
     
    nasos_333 likes this.
  46. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    It is still April and Render Graph will be default.

    I cant even imagine what will happen when the million of users convert their projects to 2023.3 latest version, with nothing custom working.

    But given there is an actual plan to remove the BiRP pipeline, i suppose there is much more devastating events in the calendar than this one :)

    How i miss the days where i was actually productive and created things in Unity, than recreate the same over and over again in different APIs, with zero major differences. The loss of time is just unthinkable.
     
    Last edited: Feb 14, 2024
    kripto289 likes this.
  47. AljoshaD

    AljoshaD

    Unity Technologies

    Joined:
    May 27, 2019
    Posts:
    283
    We have a few other posts in this thread that go into the details of how we want to support asset store providers and our users with this transistion (eg, compatibility mode, etc) so I won't repeat that here and focus on the expected timeline for user adoption.

    We expect adoption to start ramping up at the end of this year. Most users stay on an older LTS for quite some time. Also, this 23 cycle is a bit different than before. We added another tech release so 23.3 is a tech release, not the LTS. We typically see adoption of a release increase significantly once it becomes an LTS. This is planned around October.

    One thing to note here as well is that we expect the adoption of URP to increase significantly in 23, at the expense of BiRP. We wanted to make sure that this new API is ready before this large increase in users.
     
    ElliotB likes this.
  48. AljoshaD

    AljoshaD

    Unity Technologies

    Joined:
    May 27, 2019
    Posts:
    283
    One thing I want to repeat again is that we really are here to support you and help you with this transition. I hope that is clear from the many people that are here to respond to questions. There are a number of things still in development to simplify the upgrading so it will definitely simplify further and the benefits will become more clear as well.
     
    echu33 and ElliotB like this.
  49. nasos_333

    nasos_333

    Joined:
    Feb 13, 2013
    Posts:
    13,583
    I have got a 1 star review for Unity crashing because of a Unity bug, user thinking my system had a RAM leak. Has been a month and the review report has not even been considered yet.

    When this 1 star reviews become the norm after not a single of my effects work in 2023.3 in April, will there be any actual help to stay in this business when our asset sales turn to zero for example ? Is there any plan for this case ?

    The problem is not the responsiveness, is the magnitude of the change coming that we are hardly close to 10% ready for yet. Without your help we would be at 0% though, so this is really very appreciated. But on the other hand would be more appreciated if those changes had a much larger window before become the default and forced to users.

    If Render Graph is default when users import their project for 2023.3 conversion and the assets not work at all, will not think about this be a tech release or anything, will just expect everything to just work and it wont.
     
  50. AljoshaD

    AljoshaD

    Unity Technologies

    Joined:
    May 27, 2019
    Posts:
    283
    When a project upgrades the Compatibility mode should be set on by default, ie, RenderGraph turned off. There's been an issue flagged when a user doesn't have the right setting asset in their project yet but we're looking to address that.

    The question is, what else can we improve, assuming we have RenderGraph on by default in the 23.3 tech release for newly created projects? What else could we do to make sure that users don't blame your assets? We'll definitely consider your ideas that can make sure that you are not impacted by not having RG support yet.