devbox
盐析白兔
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Unity Lighting Window 属性的序列化与反序列化_unity lightingdata.asset 序列化

作者：盐析白兔 | 2024-05-28 10:23:51

赞

踩

unity lightingdata.asset 序列化

由于业务场景存在 光照环境设置的移植，所以对光照所有属性做读写操作，整合成工具。

序列化 Scriptable 对象的属性名称与Lighting 窗口面板上的名称大体相同，

属性顺序除逻辑需求外，大体相同。

工具使用方法：

美术调整完场景后，ReadLightingSetting ，生成如下序列化文件 LightingAsset.asset

移植时，write 读取配置，自动烘焙场景

 

具体代码：

编辑器工具类：LightingSetting.cs

  1. using System.IO;
  2. using UnityEngine;
  3. using UnityEditor;
  4. using UnityEngine.Rendering;
  5. using Object = UnityEngine.Object;
  6.  
  7. /// <summary>
  8. /// 使用RenderSettings、 LightmapEditorSettings 和 Lightmapping API。
  9. /// </summary>
  10. public class LightingSetting 
  11. {
  12.     static string real_path = Application.dataPath+"/Lighting/Assets/LightingAsset.asset";
  13.     static string light_path = "Assets/Lighting/Assets/LightingAsset.asset";
  14.     
  15.     [MenuItem("LightLing/ReadLightingSetting")]
  16.     public static void ReadLightingSetting()
  17.     {
  18.         Debug.Log("read light setting");
  19.         LightingAsset dataInfo = ScriptableObject.CreateInstance<LightingAsset>();
  20.         if (dataInfo != null) {
  21.             //Skybox Material
  22.             dataInfo.SkyboxMaterial = RenderSettings.skybox;
  23.             //Sun Source  无序列化
  24.             // dataInfo.SunSource = RenderSettings.sun;   
  25.             
  26.             //Realtime Lighting
  27.             dataInfo.realtimeGI = Lightmapping.realtimeGI;
  28.             //mixed lighting
  29.             dataInfo.bakedGI = Lightmapping.bakedGI;
  30.  
  31.             //Environment Lighting
  32.             dataInfo.ambientMode = RenderSettings.ambientMode;
  33.  
  34.             switch (dataInfo.ambientMode) {
  35.                 case AmbientMode.Skybox:
  36.                     dataInfo.ambientIntensity = RenderSettings.ambientIntensity;
  37.                     break;
  38.                 case AmbientMode.Trilight: //gradient
  39.                     dataInfo.ambientSkyColor = RenderSettings.ambientSkyColor;
  40.                     dataInfo.ambientEquatorColor = RenderSettings.ambientEquatorColor;
  41.                     dataInfo.ambientGroundColor = RenderSettings.ambientGroundColor;
  42.                     break;
  43.                 case AmbientMode.Flat: //color
  44.                     dataInfo.ambientColorLight = RenderSettings.ambientLight;
  45.                     break;
  46.             }
  47.  
  48.             //Ambient Mode
  49.             if (Lightmapping.realtimeGI) {
  50.                 //默认 Baked
  51.             }
  52.  
  53.             //Environment Reflections
  54.             //Source
  55.             dataInfo.defaultReflectionMode = RenderSettings.defaultReflectionMode;
  56.             switch (dataInfo.defaultReflectionMode) {
  57.                 case DefaultReflectionMode.Skybox:
  58.                     dataInfo.defaultReflectionResolution = RenderSettings.defaultReflectionResolution ; //Resolution
  59.                     break;
  60.                 case DefaultReflectionMode.Custom:
  61.                     dataInfo.customReflection = RenderSettings.customReflection;
  62.                     break;
  63.             }
  64.             dataInfo.reflectionCubemapCompression = LightmapEditorSettings.reflectionCubemapCompression; //Compression
  65.             dataInfo.ambientIntensity = RenderSettings.reflectionIntensity;
  66.             dataInfo.reflectionBounces = RenderSettings.reflectionBounces;
  67.  
  68.             if (Lightmapping.bakedGI) {
  69.                 //Lighting mode
  70.                 dataInfo.mixedLightingMode = LightmapEditorSettings.mixedBakeMode;
  71.  
  72.                 switch (dataInfo.mixedLightingMode) {
  73.                     case MixedLightingMode.Shadowmask:
  74.                     case MixedLightingMode.IndirectOnly:
  75.                         break;
  76.                     case MixedLightingMode.Subtractive:
  77.                         dataInfo.RealtimeShadowColor = RenderSettings.subtractiveShadowColor;
  78.                         break;
  79.                 }
  80.             }
  81.             //Lightmapping Setting
  82.             if (Lightmapping.bakedGI) {
  83.                 dataInfo.Lightmapper = LightmapEditorSettings.lightmapper;
  84.                 switch (dataInfo.Lightmapper) {
  85.                     case LightmapEditorSettings.Lightmapper.ProgressiveCPU:
  86.                     case LightmapEditorSettings.Lightmapper.ProgressiveGPU:
  87.                         dataInfo.defaultReflectionResolution = RenderSettings.defaultReflectionResolution; //Resolution
  88.                         dataInfo.prioritizeView = LightmapEditorSettings.prioritizeView;
  89.                         // Multiple Importance Sampling : false
  90.                         dataInfo.directSampleCount = LightmapEditorSettings.directSampleCount;
  91.                         dataInfo.indirectSampleCount = LightmapEditorSettings.indirectSampleCount;
  92.                         dataInfo.environmentSampleCount = LightmapEditorSettings.environmentSampleCount;
  93.  
  94.                         dataInfo.Bounces = LightmapEditorSettings.bounces;
  95.                         //Filtering
  96.                         dataInfo.Filtering = LightmapEditorSettings.filteringMode;
  97.                         switch (dataInfo.Filtering) {
  98.                             case LightmapEditorSettings.FilterMode.None:
  99.                             case LightmapEditorSettings.FilterMode.Auto:
  100.                                 break;
  101.                             case LightmapEditorSettings.FilterMode.Advanced:
  102.                                 //Direct Filtering
  103.                                 dataInfo.DirectDenoiser = LightmapEditorSettings.denoiserTypeDirect;
  104.                                 dataInfo.DirectFilter = LightmapEditorSettings.filterTypeDirect;
  105.                                 switch (dataInfo.DirectFilter) {
  106.                                     case LightmapEditorSettings.FilterType.Gaussian:
  107.                                         dataInfo.filteringGaussRadiusDirect = LightmapEditorSettings.filteringGaussRadiusDirect;
  108.                                         break;
  109.                                     case LightmapEditorSettings.FilterType.ATrous:
  110.                                         dataInfo.filteringAtrousPositionSigmaDirect = LightmapEditorSettings.filteringAtrousPositionSigmaDirect;
  111.                                         break;
  112.                                     case LightmapEditorSettings.FilterType.None:
  113.                                         break;
  114.                                 }
  115.  
  116.                                 //Indirect Filtering
  117.                                 dataInfo.DirectDenoiser = LightmapEditorSettings.denoiserTypeIndirect;
  118.                                 dataInfo.InirectFilter = LightmapEditorSettings.filterTypeIndirect;
  119.                                 switch (dataInfo.InirectFilter) {
  120.                                     case LightmapEditorSettings.FilterType.Gaussian:
  121.                                         dataInfo.filteringGaussRadiusIndirect = LightmapEditorSettings.filteringGaussRadiusIndirect;
  122.                                         break;
  123.                                     case LightmapEditorSettings.FilterType.ATrous:
  124.                                         dataInfo.filteringAtrousPositionSigmaIndirect = LightmapEditorSettings.filteringAtrousPositionSigmaIndirect;
  125.                                         break;
  126.                                     case LightmapEditorSettings.FilterType.None:
  127.                                         break;
  128.                                 }
  129.  
  130.                                 //Ambient Occlusion
  131.                                 dataInfo.AmbientOcclusion = LightmapEditorSettings.enableAmbientOcclusion;
  132.                                 if (LightmapEditorSettings.enableAmbientOcclusion) {
  133.                                     //Ambient Occlusion Filtering
  134.                                     dataInfo.AmbientOcclutionDenoiser = LightmapEditorSettings.denoiserTypeAO;
  135.                                     dataInfo.AmbientOcclutionFilter = LightmapEditorSettings.filterTypeAO;
  136.                                     switch (dataInfo.AmbientOcclutionFilter) {
  137.                                         case LightmapEditorSettings.FilterType.Gaussian:
  138.                                             dataInfo.filteringGaussRadiusAO = LightmapEditorSettings.filteringGaussRadiusAO;
  139.                                             break;
  140.                                         case LightmapEditorSettings.FilterType.ATrous:
  141.                                             dataInfo.filteringAtrousPositionSigmaAO = LightmapEditorSettings.filteringAtrousPositionSigmaAO;
  142.                                             break;
  143.                                         case LightmapEditorSettings.FilterType.None:
  144.                                             break;
  145.                                     }
  146.                                     break;
  147.                                 } else
  148.                                     break;
  149.                         }
  150.  
  151.                         //Indirect Resolution
  152.                         dataInfo.IndirectResolution = LightmapEditorSettings.realtimeResolution;
  153.                         dataInfo.LightmapResolution = LightmapEditorSettings.bakeResolution;
  154.                         dataInfo.LightmapPadding = LightmapEditorSettings.padding;
  155.                         dataInfo.LightmapSize = LightmapEditorSettings.maxAtlasSize;
  156.                         dataInfo.CompressLightmaps = LightmapEditorSettings.textureCompression;
  157.                         if (LightmapEditorSettings.enableAmbientOcclusion) {
  158.                             dataInfo.AOMaxDistance = LightmapEditorSettings.aoMaxDistance;
  159.                             dataInfo.AOInDirectContribution = LightmapEditorSettings.aoExponentIndirect;
  160.                             dataInfo.AODirectContribution = LightmapEditorSettings.aoExponentDirect;
  161.                         }
  162.                         dataInfo.DirectionalMode = LightmapEditorSettings.lightmapsMode;
  163.  
  164.                         dataInfo.IndirectIntensity = Lightmapping.indirectOutputScale;
  165.                         dataInfo.AlbedoBoost = Lightmapping.bounceBoost;
  166.  
  167.                         break;
  168.                     case LightmapEditorSettings.Lightmapper.Enlighten:
  169.                         dataInfo.customReflection = RenderSettings.customReflection;
  170.                         break;
  171.                 }
  172.  
  173.             }
  174.         }
  175.  
  176.         AssetDatabase.DeleteAsset(light_path);
  177.         AssetDatabase.CreateAsset(dataInfo, light_path);
  178.         AssetDatabase.SaveAssets();
  179.         AssetDatabase.Refresh();
  180. //        Debug.LogError(LightmapEditorSettings.trainingDataDestination);
  181. //        Debug.LogError(Lightmapping.lightingDataAsset);
  182.         Debug.Log("Read complete");
  183.     }
  184.     
  185.     [MenuItem("LightLing/WriteLightingSetting")]
  186.     public static void SettingLightPCConfig()
  187.     {
  188.          Debug.Log("path:"+light_path);
  189.         LightingAsset dataInfo = AssetDatabase.LoadAssetAtPath(light_path, typeof(ScriptableObject)) as LightingAsset;
  190.         if (dataInfo != null)
  191.         {
  192. //            Lightmapping.lightingDataAsset = dataInfo.lightingDataAsset;//自动bake 关联
  193.             RenderSettings.skybox =  dataInfo.SkyboxMaterial;     
  194.             Light[] objs = (Light[])Object.FindObjectsOfType(typeof(Light));
  195.             for (int i = 0; i < objs.Length; i++)
  196.             {
  197.                 if(objs[i].name =="Directional Light")
  198.                 {
  199.                     RenderSettings.sun =  objs[i];
  200.                     break;
  201.                 }
  202.             }
  203.  
  204.             //Realtime Lighting
  205.             Lightmapping.realtimeGI = dataInfo.realtimeGI;
  206.              //mixed lighting
  207.             Lightmapping.bakedGI = dataInfo.bakedGI;
  208.  
  209.             //Environment Lighting
  210.             RenderSettings.ambientMode = dataInfo.ambientMode;
  211.             switch (dataInfo.ambientMode)
  212.             {
  213.                 case AmbientMode.Skybox:
  214.                     RenderSettings.ambientIntensity = dataInfo.ambientIntensity;
  215.                     break;
  216.                 case AmbientMode.Trilight://gradient
  217.                     RenderSettings.ambientSkyColor=dataInfo.ambientSkyColor;
  218.                     RenderSettings.ambientEquatorColor=dataInfo.ambientEquatorColor;
  219.                     RenderSettings.ambientGroundColor=dataInfo.ambientGroundColor;
  220.                     break;
  221.                 case AmbientMode.Flat://color
  222.                     RenderSettings.ambientLight=dataInfo.ambientColorLight;
  223.                     break;
  224.             }
  225.             
  226.             //Ambient Mode
  227.             if (Lightmapping.realtimeGI) {
  228.                 //默认 Baked
  229.             }
  230.  
  231.             //Environment Reflections
  232.             //Source
  233.             RenderSettings.defaultReflectionMode =dataInfo.defaultReflectionMode;
  234.             switch (dataInfo.defaultReflectionMode)
  235.             {
  236.                 case DefaultReflectionMode.Skybox:
  237.                     RenderSettings.defaultReflectionResolution = dataInfo.defaultReflectionResolution; //Resolution
  238.                     break;
  239.                 case DefaultReflectionMode.Custom:
  240.                     RenderSettings.customReflection = dataInfo.customReflection;
  241.                     break;
  242.             }
  243.             LightmapEditorSettings.reflectionCubemapCompression = dataInfo.reflectionCubemapCompression;//Compression
  244.             RenderSettings.reflectionIntensity = dataInfo.ambientIntensity;
  245.             RenderSettings.reflectionBounces = dataInfo.reflectionBounces;
  246.             
  247.             if (Lightmapping.bakedGI)
  248.             {
  249.                 //Lighting mode
  250.                 LightmapEditorSettings.mixedBakeMode = dataInfo.mixedLightingMode;
  251.  
  252.                 switch (dataInfo.mixedLightingMode)
  253.                 {
  254.                     case MixedLightingMode.Shadowmask:
  255.                     case MixedLightingMode.IndirectOnly:
  256.                         break;
  257.                     case MixedLightingMode.Subtractive:
  258.                         RenderSettings.subtractiveShadowColor = dataInfo.RealtimeShadowColor;
  259.                         break;
  260.                 }
  261.             }
  262.             //Lightmapping Setting
  263.             if (Lightmapping.bakedGI)
  264.             {
  265.                 LightmapEditorSettings.lightmapper = dataInfo.Lightmapper;
  266.                 switch (dataInfo.Lightmapper)
  267.                 {
  268.                     case LightmapEditorSettings.Lightmapper.ProgressiveCPU:
  269.                     case LightmapEditorSettings.Lightmapper.ProgressiveGPU:
  270.                         RenderSettings.defaultReflectionResolution = dataInfo.defaultReflectionResolution; //Resolution
  271.                         LightmapEditorSettings.prioritizeView = dataInfo.prioritizeView;
  272.                         // Multiple Importance Sampling : false
  273.                         LightmapEditorSettings .directSampleCount= dataInfo.directSampleCount;
  274.                         LightmapEditorSettings .indirectSampleCount= dataInfo.indirectSampleCount;
  275.                         LightmapEditorSettings .environmentSampleCount= dataInfo.environmentSampleCount;
  276.                         
  277.                         LightmapEditorSettings.bounces=dataInfo.Bounces;
  278.                         //Filtering
  279.                         LightmapEditorSettings.filteringMode = dataInfo.Filtering;
  280.                         switch (dataInfo.Filtering)
  281.                         {
  282.                              case LightmapEditorSettings.FilterMode.None:
  283.                              case LightmapEditorSettings.FilterMode.Auto:
  284.                                  break;
  285.                              case LightmapEditorSettings.FilterMode.Advanced:
  286.                                  //Direct Filtering
  287.                                  LightmapEditorSettings.denoiserTypeDirect = dataInfo.DirectDenoiser;
  288.                                  LightmapEditorSettings.filterTypeDirect =  dataInfo.DirectFilter;
  289.                                  switch (dataInfo.DirectFilter)
  290.                                  {
  291.                                      case LightmapEditorSettings.FilterType.Gaussian:
  292.                                          LightmapEditorSettings.filteringGaussRadiusDirect = dataInfo.filteringGaussRadiusDirect;
  293.                                          break;
  294.                                      case LightmapEditorSettings.FilterType.ATrous:
  295.                                          LightmapEditorSettings.filteringAtrousPositionSigmaDirect = dataInfo.filteringAtrousPositionSigmaDirect;
  296.                                          break;
  297.                                      case LightmapEditorSettings.FilterType.None:
  298.                                          break;
  299.                                  }
  300.                                  
  301.                                  //Indirect Filtering
  302.                                  LightmapEditorSettings.denoiserTypeIndirect =  dataInfo.DirectDenoiser;
  303.                                  LightmapEditorSettings.filterTypeIndirect = dataInfo.InirectFilter;
  304.                                  switch (dataInfo.InirectFilter)
  305.                                  {
  306.                                      case LightmapEditorSettings.FilterType.Gaussian:
  307.                                          LightmapEditorSettings.filteringGaussRadiusIndirect = dataInfo.filteringGaussRadiusIndirect;
  308.                                          break;
  309.                                      case LightmapEditorSettings.FilterType.ATrous:
  310.                                          LightmapEditorSettings.filteringAtrousPositionSigmaIndirect=dataInfo.filteringAtrousPositionSigmaIndirect;
  311.                                          break;
  312.                                      case LightmapEditorSettings.FilterType.None:
  313.                                          break;
  314.                                  }
  315.                                  
  316.                                  //Ambient Occlusion
  317.                                  LightmapEditorSettings.enableAmbientOcclusion=dataInfo.AmbientOcclusion;
  318.                                  if (LightmapEditorSettings.enableAmbientOcclusion)
  319.                                  {
  320.                                      //Ambient Occlusion Filtering
  321.                                      LightmapEditorSettings.denoiserTypeAO =  dataInfo.AmbientOcclutionDenoiser;
  322.                                      LightmapEditorSettings.filterTypeAO = dataInfo.AmbientOcclutionFilter;
  323.                                      switch (dataInfo.AmbientOcclutionFilter)
  324.                                      {
  325.                                          case LightmapEditorSettings.FilterType.Gaussian:
  326.                                              LightmapEditorSettings.filteringGaussRadiusAO = dataInfo.filteringGaussRadiusAO;
  327.                                              break;
  328.                                          case LightmapEditorSettings.FilterType.ATrous:
  329.                                              LightmapEditorSettings.filteringAtrousPositionSigmaAO=dataInfo.filteringAtrousPositionSigmaAO;
  330.                                              break;
  331.                                          case LightmapEditorSettings.FilterType.None:
  332.                                              break;
  333.                                      }
  334.                                      break;
  335.                                  }
  336.                                  else
  337.                                      break;
  338.                         }
  339.                         
  340.                         //Indirect Resolution
  341.                         LightmapEditorSettings.realtimeResolution=dataInfo.IndirectResolution;
  342.                         LightmapEditorSettings.bakeResolution = dataInfo.LightmapResolution;
  343.                         LightmapEditorSettings.padding = dataInfo.LightmapPadding;
  344.                         LightmapEditorSettings.maxAtlasSize = dataInfo.LightmapSize;
  345.                         LightmapEditorSettings.textureCompression=dataInfo.CompressLightmaps;
  346.                         if (LightmapEditorSettings.enableAmbientOcclusion)
  347.                         {
  348.                             LightmapEditorSettings.aoMaxDistance = dataInfo.AOMaxDistance;
  349.                             LightmapEditorSettings.aoExponentIndirect = dataInfo.AOInDirectContribution;
  350.                             LightmapEditorSettings.aoExponentDirect = dataInfo.AODirectContribution;
  351.                         }
  352.                         LightmapEditorSettings.lightmapsMode=dataInfo.DirectionalMode;
  353.                         
  354.                         Lightmapping.indirectOutputScale=dataInfo.IndirectIntensity;
  355.                         Lightmapping.bounceBoost=dataInfo.AlbedoBoost;
  356.                         
  357.                         break;
  358.                     case LightmapEditorSettings.Lightmapper.Enlighten:
  359.                         RenderSettings.customReflection = dataInfo.customReflection;
  360.                         break;
  361.                 }
  362.                 
  363.                 
  364.             }
  365.  
  366.             Debug.Log("baking...");
  367.             Lightmapping.Bake();
  368.             Debug.Log("baking completed");
  369.         }
  370.         else
  371.         {
  372.             Debug.LogError("not found Lighting assets");
  373.             return;
  374.         }
  375.  
  376.         
  377.     }
  378.     
  379. }

 

 

Scriptable 灯光数据：LightingAsset.asset

  1. using System;
  2. using UnityEditor;
  3. using UnityEditor.AddressableAssets.Build;
  4. using UnityEditor.AddressableAssets.Settings;
  5. using UnityEngine;
  6. using UnityEngine.Playables;
  7. using UnityEngine.Rendering;
  8.  
  9. [Serializable]
  10. [CreateAssetMenu(fileName = "LightingAsset", menuName = "Creat Lighting Asset")]
  11. public class LightingAsset : PlayableAsset
  12. {
  13.     public LightingDataAsset lightingDataAsset;
  14.     public Material SkyboxMaterial;
  15.     public Light SunSource;
  16.     [Space]
  17.     public int defaultReflectionResolution; 
  18.     public AmbientMode ambientMode; 
  19.     public float ambientIntensity;
  20.     [Space]
  21.     public Color ambientSkyColor;
  22.     public Color ambientEquatorColor;
  23.     public Color ambientGroundColor;
  24.     [Space]
  25.     public Color ambientColorLight;
  26.     [Space]
  27.     public DefaultReflectionMode defaultReflectionMode; 
  28.     public ReflectionCubemapCompression reflectionCubemapCompression; 
  29.     public float reflectionIntensity; 
  30.     public int reflectionBounces;
  31.     public Cubemap customReflection;
  32.     [Space]
  33.     public bool realtimeGI;
  34.     public bool bakedGI;
  35.     public MixedLightingMode mixedLightingMode;
  36.     public Color RealtimeShadowColor;
  37.     [Space]
  38.     public LightmapEditorSettings.Lightmapper Lightmapper;
  39.     public bool prioritizeView;
  40.     public bool multipleSampling;
  41.     public int directSampleCount;
  42.     public int indirectSampleCount;
  43.     public int environmentSampleCount;
  44.     public int LightProbeSampleMultiplier;
  45.     public int Bounces;
  46.     public LightmapEditorSettings.FilterMode Filtering;
  47.     [Space]
  48.     public LightmapEditorSettings.DenoiserType DirectDenoiser;
  49.     public LightmapEditorSettings.FilterType DirectFilter;
  50.     public int filteringGaussRadiusDirect;
  51.     public float filteringAtrousPositionSigmaDirect;
  52.     [Space]
  53.     public LightmapEditorSettings.DenoiserType IndirectDenoiser;
  54.     public LightmapEditorSettings.FilterType InirectFilter;
  55.     public int filteringGaussRadiusIndirect;
  56.     public float filteringAtrousPositionSigmaIndirect;
  57.     [Space]
  58.     public LightmapEditorSettings.DenoiserType AmbientOcclutionDenoiser;
  59.     public LightmapEditorSettings.FilterType AmbientOcclutionFilter;
  60.     public int filteringGaussRadiusAO;
  61.     public float filteringAtrousPositionSigmaAO;
  62.     [Space]
  63.     public float IndirectResolution;
  64.     public float LightmapResolution;
  65.     public int LightmapPadding=2;
  66.     public int LightmapSize=1024;
  67.     public bool CompressLightmaps;
  68.     [Space]
  69.     public bool AmbientOcclusion;
  70.     public float AOMaxDistance;
  71.     public float AOInDirectContribution;
  72.     public float AODirectContribution;
  73.     [Space]
  74.     public LightmapsMode DirectionalMode;
  75.     public float IndirectIntensity;
  76.     public float AlbedoBoost;
  77.  
  78.     // Factory method that generates a playable based on this asset
  79.     public override Playable CreatePlayable(PlayableGraph graph, GameObject go)
  80.     {
  81.         
  82.         return Playable.Create(graph);
  83.     }
  84. }

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/盐析白兔/article/detail/637079
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号