Search Unity

  1. Welcome to the Unity Forums! Please take the time to read our Code of Conduct to familiarize yourself with the forum rules and how to post constructively.
  2. Dismiss Notice

[Unity 2018.2.x - 2018.3.x] Multiscene setup warning spam issue

Discussion in 'Editor & General Support' started by xVergilx, Jul 14, 2018.

  1. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    In my project multi-scene setup is used, and the order of their loading doesn't change, like ever.
    That is ensured by my own tool. Which always loads the scene with proper lightning settings first, then, every auxilary scene. It never causes the lighting to be different.

    With the addition of fool-proof check warning system, I keep getting console spam about lighting settings missmatch, each time I load scene setup in editor, or runtime.

    upload_2018-7-14_14-11-38.png

    Thing is - I don't need those checks. Since I do only set the lighting settings once, for the "core" scene.
    I need my console be clean, so I'd rather catch my own warnings if those occur.

    There's four options in my case:
    Either get rid of every Debug.LogWarning in the project and replace it with .Log / .LogError and disable warnings completely.

    Or, replace hundreds of scene lighting settings manually, since there's no access to the lighting settings in the script.

    Or, write a horrible workaround that hooks to the PlayStateChanged event and clear the console. That would lead to the errors that crop up on load to be undetected though, so it's not really an option.

    Or, rollback to the 2018.1. I like the changes done to the ECS & Addressables, so I'd rather want to stick to the 2018.2.


    Simple solution from UT side would be to place the "warning" check box somewhere along Editor settings, or preferences.
    This went completely ignored in the beta section throughout the beta dev cycle.
    It went ignored in RC. Now it's in the release. Well done.

    Here's previous thread to this:
    https://forum.unity.com/threads/war...up-has-inconsistent-lighting-settings.527997/

    @kemalakay @thefranke Will there be any future changes to this behaviour?

    Edit: Still a problem for 2018.3.x
     
    Last edited: Sep 15, 2018
    halley and Peter77 like this.
  2. Peter77

    Peter77

    QA Jesus

    Joined:
    Jun 12, 2013
    Posts:
    6,394
    I wrote a script that allows to copy lighting settings. Perhaps it's useful if you want to write a tool to adjust those hundreds of scenes automatically.
    https://bitbucket.org/snippets/pschraut/LeykeL
     
  3. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Thank you, that will definately make it easier.

    But I don't think it's possible to automate the process, since it grabs the lighting settings directly from the editor window, and then pastes it to different editor window. Unless it's used along with some clever click bot. Or maybe an automatic lighting settings window opener.

    Setting scene active, openning lighting window, pasting settings.
    Might work actually, but I'm not sure if it's possible to open the the lighting window from the script. Will have to investigate that.
     
    Last edited: Jul 14, 2018
    Peter77 likes this.
  4. JonMoon

    JonMoon

    Joined:
    Feb 26, 2015
    Posts:
    10
    Same problem here, but instead I get the warning
    Code (CSharp):
    1. Your multi-scene setup may be improved by tending to the following issues:
    2. 1/2 scenes use a different bake backend.
    . Is it wrong to have UI in it's own scene? Or have a "dontdestroy" scene? I don't see why ALL scenes need to have the same baking or lighting settings.
     
  5. Peter77

    Peter77

    QA Jesus

    Joined:
    Jun 12, 2013
    Posts:
    6,394
    halley likes this.
  6. halley

    halley

    Joined:
    Aug 26, 2013
    Posts:
    1,802
    Yeah, that thread ended with Unity saying "it'll be addressed (somehow) in 2018.2" but here we are.

    If I disable the GI options, if I disable the lightmap options, it should stop spamming these errors. Pretty simple, huh?

    I had two scenes with everything disabled and it still whined that the DISABLED GRAYED OUT OPTIONS were different between the two scenes. Argh.
     
    Shorely and mgregoirelds like this.
  7. Fera_KM

    Fera_KM

    Joined:
    Nov 7, 2013
    Posts:
    307
    I agree
     
    Shorely likes this.
  8. kbm

    kbm

    Joined:
    Aug 7, 2014
    Posts:
    84
    This is terrible and I can't believe this hasn't been fixed yet. Has anyone found a workaround? The Warning spam is driving me nuts :///
     
    Shorely and Fera_KM like this.
  9. codestage

    codestage

    Joined:
    Jul 27, 2012
    Posts:
    1,904
    Also looking for the solutions of this issue.
    I'm working on Maintainer plugin, which loads scenes to scan them for issues or references and unloads them back.
    Scenes are loaded additive to avoid resetting Hierarchy state of the current scene where user works.

    And as you could guess, it generates lots of such warnings.

    Would be nice at least have a chance to disable those warning temporary from editor scripting.
     
  10. kbm

    kbm

    Joined:
    Aug 7, 2014
    Posts:
    84
    It would be fantastic to get ANY update on this from a dev. This should not take long to put into the next hotfix, right? Please, either disable the warnings completely or give us the option...
     
    Shorely, xVergilx and Fera_KM like this.
  11. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Does anyone tested the recent Unity 2018.3 beta? Is it the same behavior there?
     
    kbm likes this.
  12. codestage

    codestage

    Joined:
    Jul 27, 2012
    Posts:
    1,904
    kbm likes this.
  13. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Yeah, can confirm that this is still an issue with the 2018.3.x beta.

    Bump
     
  14. HZ51

    HZ51

    Joined:
    Jul 28, 2016
    Posts:
    42
    Same problem here. Don't know what to do with that.

    Your multi-scene setup may be improved by tending to the following issues:
    1/2 scenes use a different bake backend.

    I have 2D mobile project and I don't use lighting and baking at all. I just open AdditiveScene.
     
  15. Peter77

    Peter77

    QA Jesus

    Joined:
    Jun 12, 2013
    Posts:
    6,394
  16. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    It's only related to GI turning off. Haven't tested it, but on my current setup nothing has changed. (Unity 2018.3.0b1)

    What we want is complete disable option for these types of warnings. It will still trigger if you've got anything that missmatch with the current active scene.
     
  17. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Now I really think I need to write a proper, separate, logger and replace the default one.
     
  18. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Ended up using UberLogger and writing a custom filter for it. Now every annoying warning can be blocked at last. Although, now Uber Console renders default Console completely useless.

    (free @ github)
    https://github.com/bbbscarter/UberLogger

    Also, I've experimented with default Unity's API related to logging. ILogHandler override also does the trick, but for some reason it completely ignores messages from the Editor (which is Lighting Settings warnings are). So it's useless as well.
     
    codestage likes this.
  19. hippocoder

    hippocoder

    Digital Ape Moderator

    Joined:
    Apr 11, 2010
    Posts:
    29,723
    This is what happens when Unity sticks to it's guns and doesn't provide suitable API so we can match scene settings.
     
  20. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Problem is, they aren't even required to be matched because those settings never used for those scenes. Warnings are simply nuisance at this point.

    I can imagine why Unity Team decided why the warnings needed. Because it's easier for beginners to find out where they've messed up.

    Second problem - almost no beginner use multiscene setup. And if they do - it's more than likely they'll understand what's went wrong with their lighting setup.

    Unity 2018.3.0b1 introduced extendable settings menu. Adding another option for these messages doesn't seems to me as something extremely hard to implement, and would save a lot of time wasted on unnecessary headache.
     
    Shorely likes this.
  21. hippocoder

    hippocoder

    Digital Ape Moderator

    Joined:
    Apr 11, 2010
    Posts:
    29,723
    I would like an API to ensure I can control all the lighting settings per scene in code, as it's a chore to constantly go through manually. I had to use reflection and dark arts (tm) and I'm still at a loss why that's acceptable.
     
    Joe-Censored likes this.
  22. kbm

    kbm

    Joined:
    Aug 7, 2014
    Posts:
    84
    While this getting an official fix might be some time off - did anyone here come up with a workable solution to suppress ONLY this specific warning?
     
    codestage likes this.
  23. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    UberLogger allows you to write custom IFilter to suppress your desired warnings. Although, it's basically whole console replacement with it's own cons.

    Here's how I did it.
    1. Download UberLogger from the repo: https://github.com/bbbscarter/UberLogger
    2. Add the following class / .cs file:
    Code (CSharp):
    1. #if DEBUG
    2. using UnityEngine;
    3.  
    4. namespace UberLogger.Filters {
    5.    public class UnwantedStringsLogFilter : IFilter {
    6.       private static readonly string[] UnwantedString = {
    7.                                                   "Lighting settings",
    8.                                                   "CS0649",
    9.                                                   "SendMessage cannot be called during Awake, CheckConsistency, or OnValidate"
    10.                                                };
    11.  
    12.       public bool ApplyFilter(string channel,
    13.                               Object source,
    14.                               LogSeverity severity,
    15.                               object message,
    16.                               params object[] par) {
    17.          return true; }
    18.  
    19.       public bool ApplyUnityFilter(string message, string stackTrace, LogType logType) {
    20.          if (string.IsNullOrEmpty(message)) return true;
    21.  
    22.          if (logType == LogType.Warning) {
    23.             foreach (string unwantedString in UnwantedString) {
    24.                if (message.Contains(unwantedString)) {
    25.                   return false;
    26.                }
    27.             }
    28.          }
    29.  
    30.          return true;
    31.       }
    32.    }
    33. }
    34. #endif
    3. Replace the UberLogger.cs with the following (I've already modified the code to inject the filter where it should be. You can as well do it elsewhere as well):
    Code (CSharp):
    1. using UnityEngine;
    2. using System.Collections.Generic;
    3. using System.Diagnostics;
    4. using System;
    5. using System.Reflection;
    6. using System.Text.RegularExpressions;
    7. using UberLogger.Filters;
    8. using Debug = UnityEngine.Debug;
    9. #if UNITY_EDITOR
    10. using UnityEditor;
    11.  
    12. #endif
    13.  
    14. namespace UberLogger {
    15.    //Use this to exclude methods from the stack trace
    16.    [AttributeUsage(AttributeTargets.Method)]
    17.    public class StackTraceIgnore : Attribute { }
    18.  
    19.    //Use this to stop UberLogger handling logs with this in the callstack.
    20.    [AttributeUsage(AttributeTargets.Method)]
    21.    public class LogUnityOnly : Attribute { }
    22.  
    23.    public enum LogSeverity {
    24.       Message,
    25.       Warning,
    26.       Error,
    27.    }
    28.  
    29.    /// <summary>
    30.    /// Interface for deriving new logger backends.
    31.    /// Add a new logger via Logger.AddLogger()
    32.    /// </summary>
    33.    public interface ILogger {
    34.       /// <summary>
    35.       /// Logging backend entry point. logInfo contains all the information about the logging request.
    36.       /// </summary>
    37.       void Log(LogInfo logInfo);
    38.    }
    39.  
    40.    /// <summary>
    41.    /// Interface for implementing new log message filter methods.
    42.    /// Filters will be applied to log messages before they are forwarded to any loggers or Unity itself.
    43.    /// </summary>
    44.    public interface IFilter {
    45.       /// <summary>
    46.       /// Apply filter to log message.
    47.       /// Should return true if the message is to be kept, and false if the message is to be silenced.
    48.       /// </summary>
    49.       bool ApplyFilter(string channel,
    50.                        UnityEngine.Object source,
    51.                        LogSeverity severity,
    52.                        object message,
    53.                        params object[] par);
    54.  
    55.       bool ApplyUnityFilter(string message, string stackTrace, LogType logType);
    56.    }
    57.  
    58.    //Information about a particular frame of a callstack
    59.    [System.Serializable]
    60.    public class LogStackFrame {
    61.       public string MethodName;
    62.       public string DeclaringType;
    63.       public string ParameterSig;
    64.  
    65.       public int LineNumber;
    66.       public string FileName;
    67.  
    68.       string FormattedMethodNameWithFileName;
    69.       string FormattedMethodName;
    70.       string FormattedFileName;
    71.  
    72.       /// <summary>
    73.       /// Convert from a .Net stack frame
    74.       /// </summary>
    75.       public LogStackFrame(StackFrame frame) {
    76.          var method = frame.GetMethod();
    77.          MethodName = method.Name;
    78.          DeclaringType = method.DeclaringType.FullName;
    79.  
    80.          var pars = method.GetParameters();
    81.          for (int c1 = 0; c1 < pars.Length; c1++) {
    82.             ParameterSig += String.Format("{0} {1}", pars[c1].ParameterType, pars[c1].Name);
    83.             if (c1 + 1 < pars.Length) {
    84.                ParameterSig += ", ";
    85.             }
    86.          }
    87.  
    88.          FileName = frame.GetFileName();
    89.          LineNumber = frame.GetFileLineNumber();
    90.          MakeFormattedNames();
    91.       }
    92.  
    93.       /// <summary>
    94.       /// Convert from a Unity stack frame (for internal Unity errors rather than excpetions)
    95.       /// </summary>
    96.       public LogStackFrame(string unityStackFrame) {
    97.          if (Logger.ExtractInfoFromUnityStackInfo(unityStackFrame,
    98.                                                   ref DeclaringType,
    99.                                                   ref MethodName,
    100.                                                   ref FileName,
    101.                                                   ref LineNumber)) {
    102.             MakeFormattedNames();
    103.          } else {
    104.             FormattedMethodNameWithFileName = unityStackFrame;
    105.             FormattedMethodName = unityStackFrame;
    106.             FormattedFileName = unityStackFrame;
    107.          }
    108.       }
    109.  
    110.  
    111.       /// <summary>
    112.       /// Basic stack frame info when we have nothing else
    113.       /// </summary>
    114.       public LogStackFrame(string message, string filename, int lineNumber) {
    115.          FileName = filename;
    116.          LineNumber = lineNumber;
    117.          FormattedMethodNameWithFileName = message;
    118.          FormattedMethodName = message;
    119.          FormattedFileName = message;
    120.       }
    121.  
    122.  
    123.       public string GetFormattedMethodNameWithFileName() { return FormattedMethodNameWithFileName; }
    124.  
    125.       public string GetFormattedMethodName() { return FormattedMethodName; }
    126.  
    127.       public string GetFormattedFileName() { return FormattedFileName; }
    128.  
    129.       /// <summary>
    130.       /// Make a nice string showing the stack information - used by the loggers
    131.       /// </summary>
    132.       void MakeFormattedNames() {
    133.          FormattedMethodName = String.Format("{0}.{1}({2})", DeclaringType, MethodName, ParameterSig);
    134.  
    135.          string filename = FileName;
    136.          if (!String.IsNullOrEmpty(FileName)) {
    137.             var startSubName = FileName.IndexOf("Assets", StringComparison.OrdinalIgnoreCase);
    138.  
    139.             if (startSubName > 0) {
    140.                filename = FileName.Substring(startSubName);
    141.             }
    142.          }
    143.  
    144.          FormattedFileName = String.Format("{0}:{1}", filename, LineNumber);
    145.  
    146.          FormattedMethodNameWithFileName = String.Format("{0} (at {1})", FormattedMethodName, FormattedFileName);
    147.       }
    148.    }
    149.  
    150.    /// <summary>
    151.    /// A single item of logging information
    152.    /// </summary>
    153.    [System.Serializable]
    154.    public struct LogInfo {
    155.       public UnityEngine.Object Source;
    156.       public string Channel;
    157.       public LogSeverity Severity;
    158.       public string Message;
    159.       public List<LogStackFrame> Callstack;
    160.       public LogStackFrame OriginatingSourceLocation;
    161.       public double RelativeTimeStamp;
    162.       string RelativeTimeStampAsString;
    163.       public DateTime AbsoluteTimeStamp;
    164.       string AbsoluteTimeStampAsString;
    165.  
    166.       public string GetRelativeTimeStampAsString() { return RelativeTimeStampAsString; }
    167.       public string GetAbsoluteTimeStampAsString() { return AbsoluteTimeStampAsString; }
    168.  
    169.       public LogInfo(UnityEngine.Object source,
    170.                      string channel,
    171.                      LogSeverity severity,
    172.                      List<LogStackFrame> callstack,
    173.                      LogStackFrame originatingSourceLocation,
    174.                      object message,
    175.                      params object[] par) {
    176.          Source = source;
    177.          Channel = channel;
    178.          Severity = severity;
    179.          Message = "";
    180.          OriginatingSourceLocation = originatingSourceLocation;
    181.  
    182.          var messageString = message as String;
    183.          if (messageString != null) {
    184.             if (par.Length > 0) {
    185.                Message = System.String.Format(messageString, par);
    186.             } else {
    187.                Message = messageString;
    188.             }
    189.          } else {
    190.             if (message != null) {
    191.                Message = message.ToString();
    192.             }
    193.          }
    194.  
    195.          Callstack = callstack;
    196.          RelativeTimeStamp = Logger.GetRelativeTime();
    197.          AbsoluteTimeStamp = DateTime.UtcNow;
    198.          RelativeTimeStampAsString = String.Format("{0:0.0000}", RelativeTimeStamp);
    199.          AbsoluteTimeStampAsString =
    200.          AbsoluteTimeStamp.ToString("yyyy-MM-dd HH:mm:ss.fff", System.Globalization.CultureInfo.InvariantCulture);
    201.       }
    202.    }
    203.  
    204.    /// <summary>
    205.    /// The core of UberLogger - the entry point for logging information
    206.    /// </summary>
    207.    public static class Logger {
    208.       // Controls how many historical messages to keep to pass into newly registered loggers
    209.       public static int MaxMessagesToKeep = 1000;
    210.  
    211.       // If true, any logs sent to UberLogger will be forwarded on to the Unity logger.
    212.       // Useful if you want to use both systems
    213.       public static bool ForwardMessages = true;
    214.  
    215.       // Unity uses \n for line termination in internal multi-line strings. Use this instead of
    216.       //  System.Environment.NewLine when you want to split multi-line strings which are emitted
    217.       //  by Unity's internal APIs.
    218.       public static string UnityInternalNewLine = "\n";
    219.  
    220.       // Unity uses forward-slashes as directory separators, regardless of OS.
    221.       // Convert from this separator to System.IO.Path.DirectorySeparatorChar before passing any Unity-originated
    222.       //  paths to APIs which expect OS-native paths.
    223.       public static char UnityInternalDirectorySeparator = '/';
    224.  
    225.       static List<ILogger> Loggers = new List<ILogger>();
    226.       static LinkedList<LogInfo> RecentMessages = new LinkedList<LogInfo>();
    227.       static long StartTick;
    228.       static bool AlreadyLogging = false;
    229.       static Regex UnityMessageRegex;
    230.       static List<IFilter> Filters = new List<IFilter>();
    231.  
    232.       static Logger() {
    233.          UnwantedStringsLogFilter lsFilter = new UnwantedStringsLogFilter();
    234.          AddFilter(lsFilter);
    235.  
    236.          // Register with Unity's logging system
    237. // _OR_NEWER only available from 5.3+
    238. #if UNITY_5 || UNITY_5_3_OR_NEWER
    239.          Application.logMessageReceivedThreaded += UnityLogHandler;
    240. #else
    241.             Application.RegisterLogCallback(UnityLogHandler);
    242. #endif
    243.          StartTick = DateTime.Now.Ticks;
    244.          UnityMessageRegex = new Regex(@"(.*)\((\d+).*\)");
    245.       }
    246.  
    247.       /// <summary>
    248.       /// Registered Unity error handler
    249.       /// </summary>
    250.       [StackTraceIgnore]
    251.       static void UnityLogHandler(string logString, string stackTrace, UnityEngine.LogType logType) {
    252.          foreach (IFilter filter in Filters) {
    253.             // Avoid unity messages right away
    254.             if (!filter.ApplyUnityFilter(logString, stackTrace, logType)) return;
    255.          }
    256.  
    257.          UnityLogInternal(logString, stackTrace, logType);
    258.       }
    259.  
    260.       static public double GetRelativeTime() {
    261.          long ticks = DateTime.Now.Ticks;
    262.          return TimeSpan.FromTicks(ticks - StartTick).TotalSeconds;
    263.       }
    264.  
    265.       /// <summary>
    266.       /// Registers a new logger backend, which we be told every time there's a new log.
    267.       /// if populateWithExistingMessages is true, UberLogger will immediately pump the new logger with past messages
    268.       /// </summary>
    269.       static public void AddLogger(ILogger logger, bool populateWithExistingMessages = true) {
    270.          lock (Loggers) {
    271.             if (populateWithExistingMessages) {
    272.                foreach (var oldLog in RecentMessages) {
    273.                   logger.Log(oldLog);
    274.                }
    275.             }
    276.  
    277.             if (!Loggers.Contains(logger)) {
    278.                Loggers.Add(logger);
    279.             }
    280.          }
    281.       }
    282.  
    283.       /// <summary>
    284.       /// Registers a new filter mechanism, which will be able to silence any future log messages
    285.       /// </summary>
    286.       static public void AddFilter(IFilter filter) {
    287.          lock (Loggers) {
    288.             Filters.Add(filter);
    289.          }
    290.       }
    291.  
    292.       /// <summary>
    293.       /// Paths provided by Unity will contain forward slashes as directory separators on all OSes.
    294.       /// This method changes all forward slashes to OS-specific directory separators.
    295.       /// </summary>
    296.       static public string ConvertDirectorySeparatorsFromUnityToOS(string unityFileName) {
    297.          return unityFileName.Replace(UnityInternalDirectorySeparator, System.IO.Path.DirectorySeparatorChar);
    298.       }
    299.  
    300.       /// <summary>
    301.       /// Tries to extract useful information about the log from a Unity error message.
    302.       /// Only used when handling a Unity error message and we can't get a useful callstack
    303.       /// </summary>
    304.       static public bool ExtractInfoFromUnityMessage(string log, ref string filename, ref int lineNumber) {
    305.          // log = "Assets/Code/Debug.cs(140,21): warning CS0618: 'some error'
    306.          var match = UnityMessageRegex.Matches(log);
    307.  
    308.          if (match.Count > 0) {
    309.             filename = match[0].Groups[1].Value;
    310.             lineNumber = Convert.ToInt32(match[0].Groups[2].Value);
    311.             return true;
    312.          }
    313.  
    314.          return false;
    315.       }
    316.  
    317.  
    318.       /// <summary>
    319.       /// Tries to extract useful information about the log from a Unity stack trace
    320.       /// </summary>
    321.       static public bool ExtractInfoFromUnityStackInfo(string log,
    322.                                                        ref string declaringType,
    323.                                                        ref string methodName,
    324.                                                        ref string filename,
    325.                                                        ref int lineNumber) {
    326.          // log = "DebugLoggerEditorWindow.DrawLogDetails () (at Assets/Code/Editor.cs:298)";
    327.          var match = Regex.Matches(log, @"(.*)\.(.*)\s*\(.*\(at (.*):(\d+)");
    328.  
    329.          if (match.Count > 0) {
    330.             declaringType = match[0].Groups[1].Value;
    331.             methodName = match[0].Groups[2].Value;
    332.             filename = match[0].Groups[3].Value;
    333.             lineNumber = Convert.ToInt32(match[0].Groups[4].Value);
    334.             return true;
    335.          }
    336.  
    337.          return false;
    338.       }
    339.  
    340.  
    341.       struct IgnoredUnityMethod {
    342.          public enum Mode {
    343.             Show,
    344.             ShowIfFirstIgnoredMethod,
    345.             Hide
    346.          };
    347.  
    348.          public string DeclaringTypeName;
    349.          public string MethodName;
    350.          public Mode ShowHideMode;
    351.       }
    352.  
    353.       // Example callstack when invoking Debug.LogWarning under Unity 5.5:
    354.       //   Application.CallLogCallback
    355.       //   DebugLogHandler.Internal_Log
    356.       //   DebugLogHandler.LogFormat
    357.       //   Logger.Log
    358.       //   Debug.LogWarning
    359.       //   <application callstack>
    360.  
    361.  
    362.       static IgnoredUnityMethod[] IgnoredUnityMethods = {
    363.                                                            // Internal trampoline, which invokes UberLogger's log callback
    364.                                                            new IgnoredUnityMethod {
    365.                                                                                      DeclaringTypeName
    366.                                                                                         = "Application",
    367.                                                                                      MethodName
    368.                                                                                         = "CallLogCallback",
    369.                                                                                      ShowHideMode
    370.                                                                                         = IgnoredUnityMethod
    371.                                                                                           .Mode
    372.                                                                                           .Hide
    373.                                                                                   },
    374.  
    375.                                                            // Internal log-handling methods in Unity
    376.                                                            new IgnoredUnityMethod {
    377.                                                                                      DeclaringTypeName
    378.                                                                                         = "DebugLogHandler",
    379.                                                                                      MethodName
    380.                                                                                         = null,
    381.                                                                                      ShowHideMode
    382.                                                                                         = IgnoredUnityMethod
    383.                                                                                           .Mode
    384.                                                                                           .Hide
    385.                                                                                   },
    386.  
    387.                                                            // There are several entry points to Logger. These are primarily called by Unity's own code, but could also be called directly by 3rd party code.
    388.                                                            // These are helpful to have on the callstack in case source code is not available (they help pinpoint the exact source code location that printed the message),
    389.                                                            //   but remaining ignored methods can safely be hidden
    390.                                                            new IgnoredUnityMethod {
    391.                                                                                      DeclaringTypeName
    392.                                                                                         = "Logger",
    393.                                                                                      MethodName
    394.                                                                                         = null,
    395.                                                                                      ShowHideMode
    396.                                                                                         = IgnoredUnityMethod
    397.                                                                                           .Mode
    398.                                                                                           .ShowIfFirstIgnoredMethod
    399.                                                                                   },
    400.  
    401.                                                            // Many of the Debug.* entry points result in log messages being printed
    402.                                                            // These are helpful to have on the callstack in case source code is not available (they help pinpoint the exact source code location that printed the message),
    403.                                                            //   but remaining ignored methods can safely be hidden
    404.                                                            new IgnoredUnityMethod {
    405.                                                                                      DeclaringTypeName
    406.                                                                                         = "Debug",
    407.                                                                                      MethodName
    408.                                                                                         = null,
    409.                                                                                      ShowHideMode
    410.                                                                                         = IgnoredUnityMethod
    411.                                                                                           .Mode
    412.                                                                                           .ShowIfFirstIgnoredMethod
    413.                                                                                   },
    414.  
    415.                                                            // Many of the Assert.* entry points result in log messages being printed
    416.                                                            // These are not helpful having on the callstack
    417.                                                            // These are helpful to have on the callstack in case source code is not available (they help pinpoint the exact source code location that printed the message),
    418.                                                            //   but remaining ignored methods can safely be hidden
    419.                                                            new IgnoredUnityMethod {
    420.                                                                                      DeclaringTypeName
    421.                                                                                         = "Assert",
    422.                                                                                      MethodName
    423.                                                                                         = null,
    424.                                                                                      ShowHideMode
    425.                                                                                         = IgnoredUnityMethod
    426.                                                                                           .Mode
    427.                                                                                           .ShowIfFirstIgnoredMethod
    428.                                                                                   },
    429.                                                         };
    430.  
    431.       /// <summary>
    432.       /// Identify a number of Unity methods which we would like to scrub from a stacktrace
    433.       /// Returns true if the method is part of scrubbing
    434.       /// </summary>
    435.       static IgnoredUnityMethod.Mode ShowOrHideMethod(MethodBase method) {
    436.          foreach (IgnoredUnityMethod ignoredUnityMethod in IgnoredUnityMethods) {
    437.             if ((method.DeclaringType.Name == ignoredUnityMethod.DeclaringTypeName)
    438.                 && ((ignoredUnityMethod.MethodName == null) || (method.Name == ignoredUnityMethod.MethodName))) {
    439.                return ignoredUnityMethod.ShowHideMode;
    440.             }
    441.          }
    442.  
    443.          return IgnoredUnityMethod.Mode.Show;
    444.       }
    445.  
    446.       /// <summary>
    447.       /// Converts the curent stack trace into a list of UberLogger's LogStackFrame.
    448.       /// Excludes any methods with the StackTraceIgnore attribute
    449.       /// Excludes all methods (bar the first, sometimes) from a pre-defined list of ignored Unity methods/classes
    450.       /// Returns false if the stack frame contains any methods flagged as LogUnityOnly
    451.       /// </summary>
    452.       [StackTraceIgnore]
    453.       static bool GetCallstack(ref List<LogStackFrame> callstack, out LogStackFrame originatingSourceLocation) {
    454.          callstack.Clear();
    455.          StackTrace stackTrace = new StackTrace(true); // get call stack
    456.          StackFrame[] stackFrames = stackTrace.GetFrames(); // get method calls (frames)
    457.  
    458.          bool encounteredIgnoredMethodPreviously = false;
    459.  
    460.          originatingSourceLocation = null;
    461.  
    462.          // Iterate backwards over stackframes; this enables us to show the "first" ignored Unity method if need be, but hide subsequent ones
    463.          for (int i = stackFrames.Length - 1; i >= 0; i--) {
    464.             StackFrame stackFrame = stackFrames[i];
    465.  
    466.             var method = stackFrame.GetMethod();
    467.             if (method.IsDefined(typeof(LogUnityOnly), true)) {
    468.                return true;
    469.             }
    470.  
    471.             if (!method.IsDefined(typeof(StackTraceIgnore), true)) {
    472.                IgnoredUnityMethod.Mode showHideMode = ShowOrHideMethod(method);
    473.  
    474.                bool setOriginatingSourceLocation = (showHideMode == IgnoredUnityMethod.Mode.Show);
    475.  
    476.                if (showHideMode == IgnoredUnityMethod.Mode.ShowIfFirstIgnoredMethod) {
    477.                   // "show if first ignored" methods are part of the stack trace only if no other ignored methods have been encountered already
    478.                   if (!encounteredIgnoredMethodPreviously) {
    479.                      encounteredIgnoredMethodPreviously = true;
    480.                      showHideMode = IgnoredUnityMethod.Mode.Show;
    481.                   } else showHideMode = IgnoredUnityMethod.Mode.Hide;
    482.                }
    483.  
    484.                if (showHideMode == IgnoredUnityMethod.Mode.Show) {
    485.                   var logStackFrame = new LogStackFrame(stackFrame);
    486.  
    487.                   callstack.Add(logStackFrame);
    488.  
    489.                   if (setOriginatingSourceLocation) originatingSourceLocation = logStackFrame;
    490.                }
    491.             }
    492.          }
    493.  
    494.          // Callstack has been processed backwards -- correct order for presentation
    495.          callstack.Reverse();
    496.  
    497.          return false;
    498.       }
    499.  
    500.       /// <summary>
    501.       /// Converts a Unity callstack string into a list of UberLogger's LogStackFrame
    502.       /// Doesn't do any filtering, since this should only be dealing with internal Unity errors rather than client code
    503.       /// </summary>
    504.       static List<LogStackFrame> GetCallstackFromUnityLog(string unityCallstack,
    505.                                                           out LogStackFrame originatingSourceLocation) {
    506.          var lines = System.Text.RegularExpressions.Regex.Split(unityCallstack, UberLogger.Logger.UnityInternalNewLine);
    507.  
    508.          var stack = new List<LogStackFrame>();
    509.          foreach (var line in lines) {
    510.             var frame = new LogStackFrame(line);
    511.             if (!string.IsNullOrEmpty(frame.GetFormattedMethodNameWithFileName())) {
    512.                stack.Add(new LogStackFrame(line));
    513.             }
    514.          }
    515.  
    516.          if (stack.Count > 0) originatingSourceLocation = stack[0];
    517.          else originatingSourceLocation = null;
    518.  
    519.          return stack;
    520.       }
    521.  
    522.       /// <summary>
    523.       /// The core entry point of all logging coming from Unity. Takes a log request, creates the call stack and pumps it to all the backends
    524.       /// </summary>
    525.       [StackTraceIgnore()]
    526.       static void UnityLogInternal(string unityMessage, string unityCallStack, UnityEngine.LogType logType) {
    527.          //Make sure only one thread can do this at a time.
    528.          //This should mean that most backends don't have to worry about thread safety (unless they do complicated stuff)
    529.          lock (Loggers) {
    530.             //Prevent nasty recursion problems
    531.             if (!AlreadyLogging) {
    532.                try {
    533.                   AlreadyLogging = true;
    534.  
    535.                   var callstack = new List<LogStackFrame>();
    536.                   LogStackFrame originatingSourceLocation;
    537.                   var unityOnly = GetCallstack(ref callstack, out originatingSourceLocation);
    538.                   if (unityOnly) {
    539.                      return;
    540.                   }
    541.  
    542.                   //If we have no useful callstack, fall back to parsing Unity's callstack
    543.                   if (callstack.Count == 0) {
    544.                      callstack = GetCallstackFromUnityLog(unityCallStack, out originatingSourceLocation);
    545.                   }
    546.  
    547.                   LogSeverity severity;
    548.                   switch (logType) {
    549.                      case UnityEngine.LogType.Error:
    550.                         severity = LogSeverity.Error;
    551.                         break;
    552.                      case UnityEngine.LogType.Assert:
    553.                         severity = LogSeverity.Error;
    554.                         break;
    555.                      case UnityEngine.LogType.Exception:
    556.                         severity = LogSeverity.Error;
    557.                         break;
    558.                      case UnityEngine.LogType.Warning:
    559.                         severity = LogSeverity.Warning;
    560.                         break;
    561.                      default:
    562.                         severity = LogSeverity.Message;
    563.                         break;
    564.                   }
    565.  
    566.                   string filename = "";
    567.                   int lineNumber = 0;
    568.  
    569.                   //Finally, parse the error message so we can get basic file and line information
    570.                   if (ExtractInfoFromUnityMessage(unityMessage, ref filename, ref lineNumber)) {
    571.                      callstack.Insert(0, new LogStackFrame(unityMessage, filename, lineNumber));
    572.                   }
    573.  
    574.                   var logInfo = new LogInfo(null, "", severity, callstack, originatingSourceLocation, unityMessage);
    575.  
    576.                   //Add this message to our history
    577.                   RecentMessages.AddLast(logInfo);
    578.  
    579.                   //Make sure our history doesn't get too big
    580.                   TrimOldMessages();
    581.  
    582.                   //Delete any dead loggers and pump them with the new log
    583.                   Loggers.RemoveAll(l => l == null);
    584.                   foreach (ILogger logger in Loggers) {
    585.                      logger.Log(logInfo);
    586.                   }
    587.                } finally {
    588.                   AlreadyLogging = false;
    589.                }
    590.             }
    591.          }
    592.       }
    593.  
    594.  
    595.       /// <summary>
    596.       /// The core entry point of all logging coming from client code.
    597.       /// Takes a log request, creates the call stack and pumps it to all the backends
    598.       /// </summary>
    599.       [StackTraceIgnore()]
    600.       static public void Log(string channel,
    601.                              UnityEngine.Object source,
    602.                              LogSeverity severity,
    603.                              object message,
    604.                              params object[] par) {
    605.          lock (Loggers) {
    606.             if (!AlreadyLogging) {
    607.                try {
    608.                   AlreadyLogging = true;
    609.  
    610.                   foreach (IFilter filter in Filters) {
    611.                      if (!filter.ApplyFilter(channel, source, severity, message, par)) return;
    612.                   }
    613.  
    614.                   var callstack = new List<LogStackFrame>();
    615.                   LogStackFrame originatingSourceLocation;
    616.                   var unityOnly = GetCallstack(ref callstack, out originatingSourceLocation);
    617.                   if (unityOnly) {
    618.                      return;
    619.                   }
    620.  
    621.                   var logInfo = new LogInfo(source,
    622.                                             channel,
    623.                                             severity,
    624.                                             callstack,
    625.                                             originatingSourceLocation,
    626.                                             message,
    627.                                             par);
    628.  
    629.                   //Add this message to our history
    630.                   RecentMessages.AddLast(logInfo);
    631.  
    632.                   //Make sure our history doesn't get too big
    633.                   TrimOldMessages();
    634.  
    635.                   //Delete any dead loggers and pump them with the new log
    636.                   Loggers.RemoveAll(l => l == null);
    637.                   foreach (ILogger logger in Loggers) {
    638.                      logger.Log(logInfo);
    639.                   }
    640.  
    641.                   //If required, pump this message back into Unity
    642.                   if (ForwardMessages) {
    643.                      ForwardToUnity(source, severity, message, par);
    644.                   }
    645.                } finally {
    646.                   AlreadyLogging = false;
    647.                }
    648.             }
    649.          }
    650.       }
    651.  
    652.       /// <summary>
    653.       /// Forwards an UberLogger log to Unity so it's visible in the built-in console
    654.       /// </summary>
    655.       [LogUnityOnly()]
    656.       static void ForwardToUnity(UnityEngine.Object source, LogSeverity severity, object message, params object[] par) {
    657.          object showObject = null;
    658.          if (message != null) {
    659.             var messageAsString = message as string;
    660.             if (messageAsString != null) {
    661.                showObject = par.Length > 0 ? string.Format(messageAsString, par) : message;
    662.             } else {
    663.                showObject = message;
    664.             }
    665.          }
    666.  
    667.          if (source == null) {
    668.             if (severity == LogSeverity.Message) UnityEngine.Debug.Log(showObject);
    669.             else if (severity == LogSeverity.Warning) UnityEngine.Debug.LogWarning(showObject);
    670.             else if (severity == LogSeverity.Error) UnityEngine.Debug.LogError(showObject);
    671.          } else {
    672.             if (severity == LogSeverity.Message) UnityEngine.Debug.Log(showObject, source);
    673.             else if (severity == LogSeverity.Warning) UnityEngine.Debug.LogWarning(showObject, source);
    674.             else if (severity == LogSeverity.Error) UnityEngine.Debug.LogError(showObject, source);
    675.          }
    676.       }
    677.  
    678.       /// <summary>
    679.       /// Finds a registered logger, if it exists
    680.       /// </summary>
    681.       static public T GetLogger<T>() where T : class {
    682.          foreach (var logger in Loggers) {
    683.             if (logger is T) {
    684.                return logger as T;
    685.             }
    686.          }
    687.  
    688.          return null;
    689.       }
    690.  
    691.       static void TrimOldMessages() {
    692.          while (RecentMessages.Count > MaxMessagesToKeep) {
    693.             RecentMessages.RemoveFirst();
    694.          }
    695.       }
    696.    }
    697. }
    4. Open the Uber Console via Window/Uber Console, close the actual console.
    Should do the trick.

    Any message can be ignored by tweaking this property inside the filter
    Code (CSharp):
    1. private static readonly string[] UnwantedString;
    I've also removed some warnings that cropped up with the 2018.3.0b1 update as well. You can remove them or ignore them, as they're already should be ignored by any other version of Unity.

    Note that am I not affiliated with the UberLogger in any way. I've just found free logger that doesn't based on the console output and modified it.
     
    Last edited: Sep 17, 2018
    Boegi likes this.
  24. codestage

    codestage

    Joined:
    Jul 27, 2012
    Posts:
    1,904
    I've tried to override internal sealed class method DebugLogHandler.LogFormat() with some unsafe tricks to try filter logs but obviously that log is sent from the native side through the native Internal_Log method so we can't intercept it on the managed side, unfortunately.
     
  25. kbm

    kbm

    Joined:
    Aug 7, 2014
    Posts:
    84
    @VergilUa thanks a bunch, i will try this out!
     
  26. DavidLlewelyn

    DavidLlewelyn

    Unity Technologies

    Joined:
    Aug 14, 2012
    Posts:
    29
    @VergilUa from your screenshot, it looks like the reason for the warning is because you have Auto enabled in your Scenes. This is problematic when using Multi-Scene setups as Lighting data is not serialized to disk following a successful bake.

    Auto mode is intended really for rapid iteration and quick experimentation. To reduce disk access problems when iterating, the output of the lighting data (lightmaps, cubemaps etc) are attached directly to MeshRenders during play. The only versions of these assets which exist on disk are stored locally in the GI Cache on Scene save. If the GI Cache is purged, these lighting assets will be destroyed.

    Disabling Auto mode ensures that an actual Lighting Data asset is robustly serialized to disk.This LightingData.asset contains all references between MeshRenderers and associated lighting assets. This Lighting Data is written-to and linked-by the current Active Scene when the bake was initiated. In a Multi-Scene setup, all sub Scenes will then reference this Lighting Data. Lighting Data previously linked to Scene files will be purged to ensure data on disk is always current.

    A common problem is that opening sub-Scenes with Auto enabled will then unlink any paths to this Lighting Data in the sub Scenes and generate the new GI Cache version as described above. Saving the Scene with auto enabled permanently breaks the link to the serialized Lighitng Data asset.

    If using Multi-Scene, it is highly recommended that Auto should be disabled for these reasons.Otherwise Auto mode is breaking connections every time a Scene is saved and reloaded.

    The reason you are getting the warning is likely because your Lighting Scene has Auto disabled. Previously - and incorrectly - we did not used to generate the warning and therefore it was likely that your lighting would have been breaking without you realizing. Arguably, this is worse than the annoying warnings.

    Granted, not having a way to permeate Lighting Settings across multiple Scenes means a lot of redundant manual work, which is bad. We are currently in discussions about ways to solve this. The idea of a prefab-able bake component is likely solution we are investigating. This would allow changes to the prefab which would then automatically appear in all Scenes referencing the prefab.

    I hope this helps explain the situation.
     
    codestage and xVergilx like this.
  27. hippocoder

    hippocoder

    Digital Ape Moderator

    Joined:
    Apr 11, 2010
    Posts:
    29,723
    Why not an asset like ScriptableObject? We could then just reference it in every scene. This is what everything else does... including Animator, HDRP, post, our own code even...
     
  28. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    I've got my own multi-scene setup loading tool, that ensures that none of the subscenes are loaded separately. Thus, no unlinking occurs. Moreover, when I bake scenes in multiscene setup, I check scene lighting settings that I'm baking. Some scene aren't even bake-ready at the point those warning popup. Spamming them like so is a really nasty practice. Why not just output them when the actual bake has started (and a bonus - disable the auto-backing by default)?

    "x/x Scene has mismatch" isn't even telling me which scene has mismatching settings. It's absurd.

    And the main problem is - there's mismatches beyond simply unticking the flag at settings, and multiple settings are messy, redundant data.

    Those messages are useless and annoying.

    I, and probably lots of other people, would highly appreciate simple removal of these warnings while you're working on a proper solution. Or the check box somewhere in new Settings window.
     
    Last edited: Sep 18, 2018
    Shorely likes this.
  29. halley

    halley

    Joined:
    Aug 26, 2013
    Posts:
    1,802
    Unity is all about quick iteration development. And not every scene has lighting, but every scene has lighting SETTINGS. Unity should not complain about lighting until there are two renderers which have conflict, not two scenes. Multi-scene composition of Game, GUI, and World is common and the Game and GUI layers don't apply to lighting the World. Read my note above, where even if I disable lighting settings, Unity complains about the state of grayed out settings.
     
    Shorely and xVergilx like this.
  30. Peter77

    Peter77

    QA Jesus

    Joined:
    Jun 12, 2013
    Posts:
    6,394
    Using a ScriptableObject .asset for Lighting Settings is a nifty idea!
     
    xVergilx likes this.
  31. codestage

    codestage

    Joined:
    Jul 27, 2012
    Posts:
    1,904
    @FrakkleRogg thanks for chiming in and explaining all the background!

    Still it would be nice to be able to mute that warning somehow to keep the console clean when loading and unloading scenes from Editor scripting.

    Or, even better, why not print it only in PlayMode?
     
  32. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Same behaviour on 2018.3.0b2 & b3.
     
    Last edited: Sep 30, 2018
  33. Baste

    Baste

    Joined:
    Jan 24, 2013
    Posts:
    6,174
    @FrakkleRogg, I'm running into this issue. Problem is, I'm getting it for deactivated settings.

    We have all light baking off. No Realtime. No Mixed. No nothing. There's over 50 scenes loaded. This means that we get an incredible amount of warning spam for settings that are not in use. Hell, the settings we're getting warnings about are grayed out, we have to enable settings we have disabled to even get to edit them.

    IE:
    upload_2018-10-1_12-5-26.png

    Could you at least check if the settings you are puking warnings about are in use?
     
    Shorely, MD_Reptile, gawoon and 4 others like this.
  34. LW

    LW

    Joined:
    Jun 23, 2013
    Posts:
    22
    Any updates on this? It is very frustrating....
     
    Shorely likes this.
  35. jonasmora

    jonasmora

    Joined:
    May 12, 2015
    Posts:
    5
    I had a similar issue and fix it using this code:

    Code (CSharp):
    1. for (var i = 0; i < EditorSceneManager.sceneCountInBuildSettings; ++i) {
    2.     var scenePath = UnityEngine.SceneManagement.SceneUtility.GetScenePathByBuildIndex(i);
    3.     EditorSceneManager.OpenScene(scenePath);
    4.     var scene = EditorSceneManager.GetSceneByBuildIndex(i);
    5.     RenderSettings.skybox = null;
    6.     Lightmapping.bakedGI = false;
    7.     Lightmapping.realtimeGI = false;
    8.     Lightmapping.giWorkflowMode = Lightmapping.GIWorkflowMode.OnDemand;
    9.     LightmapEditorSettings.lightmapper = LightmapEditorSettings.Lightmapper.Enlighten;
    10.     EditorSceneManager.SaveScene(scene);
    11. }
     
  36. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    I don't think that wiping all scenes lightning settings would be anyhow viable solution.

    Unless somebody doesn't use lighting at all.
     
    halley likes this.
  37. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Any news on this one? b5, nothing have changed.
     
  38. hippocoder

    hippocoder

    Digital Ape Moderator

    Joined:
    Apr 11, 2010
    Posts:
    29,723
    Managed to use editor scene callbacks to resolve these issues temporally as they arise, so when an artist makes a new scene, it's already setup without camera or light and with the correct lighting settings. When the artist uses bake (from our menu) it also verifies all scenes are valid lighting.

    It may be something people can look at. Just Unity needs to ensure that the lighting information is properly scriptable - and often hasn't been in the past.
     
  39. MrPhil

    MrPhil

    Joined:
    Sep 22, 2010
    Posts:
    40
    I'm getting these warnings and I don't even see what is different between my scenes (in the Lighting Settings window.)
     
    Shorely and Boegi like this.
  40. dgoyette

    dgoyette

    Joined:
    Jul 1, 2016
    Posts:
    4,106
    I was getting this because one scene was using Enlighten for Baked, and the other was using Progressive for Baked. However, both scene have baked lighting disabled/unchecked in the lighting settings. It seems pretty obnoxious that I was getting warned about settings that aren't actually used in my scenes.
     
    Shorely, halley and xVergilx like this.
  41. DavidLlewelyn

    DavidLlewelyn

    Unity Technologies

    Joined:
    Aug 14, 2012
    Posts:
    29
    Picking this thread up again. Specifically in context to the the issue reported by @Baste

    It is valid that a setting mismatch warning would still be flagged in the console despite Realtime or Baked GI being disabled. This will likely be caused by Scenes having different skyboxes:

    " Your current multi-scene setup has inconsistent Lighting settings which may lead to different lighting when loading scenes individually or in a different order! Consider homogenizing the following: 1/2 scenes use different skyboxes. "

    This can mean that Reflection Probes in the Scenes will be recording a different visual environment and cause notable mismatches. Also, with the behavior we have in Unity where the first Scene loaded is the active Scene and that used for Lighting Settings, loading Scenes in anything other than the original order would mean a different skybox was used than the one used for reflections, ambient and GI. Agree that it is frustrating to not be told which Scene specifically.

    Multi-Scene is generally a hot topic right now internally so these issues and others will be hopefully addressed by any future development work in this area.

    Regarding suppressing specific warning types, I think this is a great idea and a more general concern about the Editor. Please give it some love at https://feedback.unity3d.com/
     
    optimise likes this.
  42. Baste

    Baste

    Joined:
    Jan 24, 2013
    Posts:
    6,174
    When thinking harder about this, the best solution would not be to be able to turn off that warning. The best solution would be to completely decouple lighting settings from the scene.
    That would allow for a bunch of very, very convenient things:
    - Sharing light settings between scenes. Our last game had over a hundred seperate levels - decisions like "we want outdoors scenes to have stronger lighting" was a nightmare.
    - Rapidly switch between different lighting setups for the same scene to figure out which one looks good.
    - No reason for the warning we're complaining about here to exist.

    Yeah, turning off the warning when we don't need it would be good, but light being tied to the scene is an old, bad idea, that should probably be re-thunk. You did it with navmeshes, light could be the next thing.


    *sigh*.

    See, so whenever some of you ask us to go to feedback and tell us that you look at those posts, I know you mean well and all, but.

    All of my votes have been tied up for several years. This is probably the case for most of your long-time users. The setup where you get 10 votes and that's it leads to people naturally over time putting their votes into things that doesn't get prioritized, and then there's never any reason for us to go back to feedback ever.

    Combine that with the fact that you seem to almost never mark something you won't do as "we won't do this"; meaning that there's even less chance that votes get back, and the end result is that you're probably only getting ideas and votes from very new users. Those people are important too, by all means, but you probably don't want beginners as the main source of what you need to change.

    I have never, not a single time, felt that interacting with the feedback site had any effect whatsoever. We don't put these posts up on the forums instead of on feedback because we don't know about feedback, we do it because actually talking to you instead of posting to what feels like a dead board gets a lot more results.
     
    Last edited: Nov 26, 2018
  43. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    +1 for decoupling lighting settings;

    And screw the feedback site, it sucks on multiple levels.
     
    Shorely likes this.
  44. DavidLlewelyn

    DavidLlewelyn

    Unity Technologies

    Joined:
    Aug 14, 2012
    Posts:
    29
    Decoupling Lighting Settings from the Scene makes total sense and something that has been discussed internally for a long time.

    This will likely be a key characteristic of a new approach to multi-Scene.
     
    karmington2, Baste and Peter77 like this.
  45. thefranke

    thefranke

    Unity Technologies

    Joined:
    Jun 20, 2015
    Posts:
    153
    Hello everyone,

    as I'm the one responsible for your pain I'd like to address all your concerns. First of all, I have a branch ready to fix the spam (it's being tested right now) that will hopefully make the situation much better. The key changes are the following:

    • Warnings will no longer be issued when adding or removing scenes
    • Warnings will be issued when a bake is triggered and the combined settings show issues
    • Re-bakes with identical settings will not issue warnings (you can move stuff around without constant spam)
    • Auto issues will only be identified if the main scene has any baking enabled
    In the previously mentioned thread the issue that was identified were the ambient settings, which cannot be reasonably merged with the current system, but not auto-mode.

    The issue of @Baste should be addressed by the changes above, however we still need to check a scene even when it isn't using any baking, as it could be an added scene with static objects in it that need to be baked because the main scene has baking enabled.

    As @VergilUa suggested, Auto baking will be disabled by default soon (TM).

    I'll keep you updated once the fixes hit the release.

    Cheers
     
    karmington2, Peter77 and xVergilx like this.
  46. xVergilx

    xVergilx

    Joined:
    Dec 22, 2014
    Posts:
    3,283
    Any chance of it being a part of 2018.3 RC?
     
  47. thefranke

    thefranke

    Unity Technologies

    Joined:
    Jun 20, 2015
    Posts:
    153
    Yes, the changes will be backported!
     
    Baste and xVergilx like this.
  48. hippocoder

    hippocoder

    Digital Ape Moderator

    Joined:
    Apr 11, 2010
    Posts:
    29,723
    @thefranke
    Honestly, I would rather the lighting panel reference an asset so that we may just drag and drop the asset per scene, thereby designing out any problems. Is there a reason why not?
     
    Shorely likes this.
  49. thefranke

    thefranke

    Unity Technologies

    Joined:
    Jun 20, 2015
    Posts:
    153
    This is an item on our roadmap. However, please note that the changes to the system are quite drastic and it will take some time to get in place.
     
    hippocoder likes this.
  50. hippocoder

    hippocoder

    Digital Ape Moderator

    Joined:
    Apr 11, 2010
    Posts:
    29,723
    I see, thanks! I am going to make the assumption this might include probes being multi-scene as well? Currently we have to reveal all our multi-scene geometry as part of a bake process.

    Our world is set up similar to firewatch or dark souls, we load scenes as we get near to them. Initially we tried open world, but probes die there too, and it got to the point where we had no choice but to wait a little for Unity to sort all this lighting stuff out in modular fashion first.

    Thanks for responding though, its more helpful than you'd expect and I know better than to push for a date :)