protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(SceneName, Scene.ExportYAML(container));
node.Add(LightmapsName, Lightmaps.ExportYAML(container));
if (IsReadAOTextures(container.ExportVersion))
{
node.Add(AOTexturesName, GetAOTextures(container.Version).ExportYAML(container));
}
if (IsReadLightmapsCacheFiles(container.Version))
{
node.Add(LightmapsCacheFilesName, GetLightmapsCacheFiles(container.Version).ExportYAML());
}
node.Add(LightProbesName, LightProbes.ExportYAML(container));
node.Add(LightmapsModeName, LightmapsMode);
node.Add(BakedAmbientProbeInLinearName, BakedAmbientProbeInLinear.ExportYAML(container));
node.Add(LightmappedRendererDataName, LightmappedRendererData.ExportYAML(container));
node.Add(LightmappedRendererDataIDsName, LightmappedRendererDataIDs.ExportYAML(container));
node.Add(EnlightenSceneMappingName, EnlightenSceneMapping.ExportYAML(container));
node.Add(EnlightenSceneMappingRendererIDsName, EnlightenSceneMappingRendererIDs.ExportYAML(container));
node.Add(LightsName, Lights.ExportYAML(container));
node.Add(LightBakingOutputsName, LightBakingOutputs.ExportYAML(container));
if (IsReadBakedReflectionProbeCubemapCacheFiles(container.ExportVersion))
{
node.Add(BakedReflectionProbeCubemapCacheFilesName, GetBakedReflectionProbeCubemapCacheFiles(container.Version).ExportYAML());
}
node.Add(BakedReflectionProbeCubemapsName, BakedReflectionProbeCubemaps.ExportYAML(container));
node.Add(BakedReflectionProbesName, BakedReflectionProbes.ExportYAML(container));
node.Add(EnlightenDataName, EnlightenData.ExportYAML());
node.Add(EnlightenDataVersionName, EnlightenDataVersion);
return(node);
}
public override IEnumerable <Object> FetchDependencies(ISerializedFile file, bool isLog = false)
{
foreach (Object @object in base.FetchDependencies(file, isLog))
{
yield return(@object);
}
yield return(Scene.FetchDependency(file, isLog, ToLogString, "m_Scene"));
foreach (LightmapData lightmapData in Lightmaps)
{
foreach (Object @object in lightmapData.FetchDependencies(file, isLog))
{
yield return(@object);
}
}
yield return(LightProbes.FetchDependency(file, isLog, ToLogString, "m_LightProbes"));
foreach (RendererData rendererData in LightmappedRendererData)
{
foreach (Object @object in rendererData.FetchDependencies(file, isLog))
{
yield return(@object);
}
}
foreach (Object @object in EnlightenSceneMapping.FetchDependencies(file, isLog))
{
yield return(@object);
}
foreach (PPtr <Texture> cubemap in BakedReflectionProbeCubemaps)
{
yield return(cubemap.FetchDependency(file, isLog, ToLogString, "m_BakedReflectionProbeCubemaps"));
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
Scene.Read(reader);
m_lightmaps = reader.ReadAssetArray <LightmapData>();
reader.AlignStream(AlignType.Align4);
if (IsReadAOTextures(reader.Version))
{
m_AOTextures = reader.ReadAssetArray <PPtr <Texture2D> >();
}
if (IsReadLightmapsCacheFiles(reader.Version))
{
m_lightmapsCacheFiles = reader.ReadStringArray();
}
LightProbes.Read(reader);
LightmapsMode = reader.ReadInt32();
BakedAmbientProbeInLinear.Read(reader);
m_lightmappedRendererData = reader.ReadAssetArray <RendererData>();
reader.AlignStream(AlignType.Align4);
m_lightmappedRendererDataIDs = reader.ReadAssetArray <SceneObjectIdentifier>();
reader.AlignStream(AlignType.Align4);
EnlightenSceneMapping.Read(reader);
m_enlightenSceneMappingRendererIDs = reader.ReadAssetArray <SceneObjectIdentifier>();
reader.AlignStream(AlignType.Align4);
m_lights = reader.ReadAssetArray <SceneObjectIdentifier>();
reader.AlignStream(AlignType.Align4);
m_lightBakingOutputs = reader.ReadAssetArray <LightBakingOutput>();
reader.AlignStream(AlignType.Align4);
if (IsReadBakedReflectionProbeCubemapCacheFiles(reader.Version))
{
m_bakedReflectionProbeCubemapCacheFiles = reader.ReadStringArray();
}
m_bakedReflectionProbeCubemaps = reader.ReadAssetArray <PPtr <Texture> >();
m_bakedReflectionProbes = reader.ReadAssetArray <SceneObjectIdentifier>();
reader.AlignStream(AlignType.Align4);
m_enlightenData = reader.ReadByteArray();
reader.AlignStream(AlignType.Align4);
EnlightenDataVersion = reader.ReadInt32();
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add("m_Scene", Scene.ExportYAML(container));
node.Add("m_Lightmaps", Lightmaps.ExportYAML(container));
node.Add("m_LightProbes", LightProbes.ExportYAML(container));
node.Add("m_LightmapsMode", LightmapsMode);
node.Add("m_BakedAmbientProbeInLinear", BakedAmbientProbeInLinear.ExportYAML(container));
node.Add("m_LightmappedRendererData", LightmappedRendererData.ExportYAML(container));
node.Add("m_LightmappedRendererDataIDs", LightmappedRendererDataIDs.ExportYAML(container));
node.Add("m_EnlightenSceneMapping", EnlightenSceneMapping.ExportYAML(container));
node.Add("m_EnlightenSceneMappingRendererIDs", EnlightenSceneMappingRendererIDs.ExportYAML(container));
node.Add("m_Lights", Lights.ExportYAML(container));
node.Add("m_LightBakingOutputs", LightBakingOutputs.ExportYAML(container));
node.Add("m_BakedReflectionProbeCubemaps", BakedReflectionProbeCubemaps.ExportYAML(container));
node.Add("m_BakedReflectionProbes", BakedReflectionProbes.ExportYAML(container));
node.Add("m_EnlightenData", EnlightenData.ExportYAML());
node.Add("m_EnlightenDataVersion", EnlightenDataVersion);
return(node);
}
public override IEnumerable <Object> FetchDependencies(ISerializedFile file, bool isLog = false)
{
foreach (Object asset in base.FetchDependencies(file, isLog))
{
yield return(asset);
}
if (IsReadEnlightenSceneMapping(file.Version, file.Flags))
{
foreach (Object asset in EnlightenSceneMapping.FetchDependencies(file, isLog))
{
yield return(asset);
}
}
if (IsReadLightProbes(file.Version, file.Flags))
{
yield return(LightProbes.FetchDependency(file, isLog, ToLogString, "m_LightProbes"));
foreach (LightmapData lightmap in Lightmaps)
{
foreach (Object asset in lightmap.FetchDependencies(file, isLog))
{
yield return(asset);
}
}
}
#if UNIVERSAL
if (IsReadLightmapEditorSettings(file.Version, file.Flags))
{
foreach (Object asset in LightmapEditorSettings.FetchDependencies(file, isLog))
{
yield return(asset);
}
}
if (IsReadLightingDataAsset(file.Version, file.Flags))
{
yield return(LightingDataAsset.FetchDependency(file, isLog, ToLogString, LightingDataAssetName));
}
#endif
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
if (HasLightProbesLegacy(container.ExportVersion))
{
node.Add(LightProbesLegacyName, LightProbesLegacy.ExportYAML(container));
}
if (HasGIWorkflowMode(container.ExportVersion, container.ExportFlags))
{
node.Add(GIWorkflowModeName, (int)GetExportGIWorkflowMode(container.Version, container.Flags));
}
if (HasLightProbes(container.ExportVersion, container.ExportFlags))
{
node.Add(LightProbesName, LightProbes.ExportYAML(container));
}
if (HasLightmaps(container.ExportVersion, container.ExportFlags))
{
node.Add(LightmapsName, Lightmaps.ExportYAML(container));
}
if (HasLightmapsModeLegacy(container.ExportVersion))
{
node.Add(LightmapsModeLegacyName, (int)LightmapsModeLegacy);
}
if (HasLightmapsMode(container.ExportVersion, container.ExportFlags))
{
node.Add(LightmapsModeName, (int)LightmapsMode);
}
if (HasBakedColorSpace(container.ExportVersion))
{
node.Add(BakedColorSpaceName, (int)BakedColorSpace);
}
if (HasUseDualLightmapsInForward(container.ExportVersion))
{
node.Add(UseDualLightmapsInForwardName, UseDualLightmapsInForward);
}
if (HasGISettings(container.ExportVersion))
{
node.Add(GISettingsName, GetExportGISettings(container.Version).ExportYAML(container));
}
#if UNIVERSAL
if (HasLightmapEditorSettings(container.ExportVersion, container.ExportFlags))
{
node.Add(LightmapEditorSettingsName, GetExportLightmapEditorSettings(container).ExportYAML(container));
}
if (HasLightingDataAsset(container.ExportVersion, container.ExportFlags))
{
node.Add(LightingDataAssetName, GetLightingDataAsset(container.Version, container.Flags).ExportYAML(container));
}
#endif
if (HasRuntimeCPUUsage(container.ExportVersion))
{
node.Add(RuntimeCPUUsageName, RuntimeCPUUsage);
}
if (HasUseShadowmask(container.ExportVersion))
{
if (IsBoolShadowmask(container.ExportVersion))
{
node.Add(UseShadowmaskName, GetExportUseShadowmask(container.Version));
}
else
{
node.Add(ShadowMaskModeName, ShadowMaskMode);
}
}
return(node);
}
public override void Write(AssetWriter writer)
{
base.Write(writer);
if (HasLightProbesLegacy(writer.Version))
{
LightProbesLegacy.Write(writer);
}
if (HasEnlightenSceneMapping(writer.Version, writer.Flags))
{
EnlightenSceneMapping.Write(writer);
}
if (HasGIWorkflowMode(writer.Version, writer.Flags))
{
writer.Write((int)GIWorkflowMode);
}
if (HasLightProbes(writer.Version, writer.Flags))
{
LightProbes.Write(writer);
}
if (HasLightmaps(writer.Version, writer.Flags))
{
Lightmaps.Write(writer);
}
if (IsAlign1(writer.Version, writer.Flags))
{
writer.AlignStream();
}
if (HasLightmapsModeLegacy(writer.Version))
{
writer.Write((int)LightmapsModeLegacy);
}
if (HasLightmapsMode(writer.Version, writer.Flags))
{
writer.Write((int)LightmapsMode);
}
if (HasBakedColorSpace(writer.Version))
{
writer.Write((int)BakedColorSpace);
}
if (HasUseDualLightmapsInForward(writer.Version))
{
writer.Write(UseDualLightmapsInForward);
}
if (IsAlign2(writer.Version))
{
writer.AlignStream();
}
if (HasGISettings(writer.Version))
{
GISettings.Write(writer);
}
#if UNIVERSAL
if (HasLightmapEditorSettings(writer.Version, writer.Flags))
{
LightmapEditorSettings.Write(writer);
}
if (HasLightingDataAsset(writer.Version, writer.Flags))
{
LightingDataAsset.Write(writer);
}
#endif
if (HasRuntimeCPUUsage(writer.Version))
{
writer.Write(RuntimeCPUUsage);
}
if (HasUseShadowmask(writer.Version))
{
if (IsBoolShadowmask(writer.Version))
{
writer.Write(UseShadowmask);
}
else
{
writer.Write(ShadowMaskMode);
}
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (HasLightProbesLegacy(reader.Version))
{
LightProbesLegacy.Read(reader);
}
if (HasEnlightenSceneMapping(reader.Version, reader.Flags))
{
EnlightenSceneMapping.Read(reader);
}
if (HasGIWorkflowMode(reader.Version, reader.Flags))
{
GIWorkflowMode = (GIWorkflowMode)reader.ReadInt32();
}
if (HasLightProbes(reader.Version, reader.Flags))
{
LightProbes.Read(reader);
}
if (HasLightmaps(reader.Version, reader.Flags))
{
Lightmaps = reader.ReadAssetArray <LightmapData>();
}
if (IsAlign1(reader.Version, reader.Flags))
{
reader.AlignStream();
}
if (HasLightmapsModeLegacy(reader.Version))
{
LightmapsModeLegacy = (LightmapsMode)reader.ReadInt32();
}
if (HasLightmapsMode(reader.Version, reader.Flags))
{
LightmapsMode = (LightmapsMode)reader.ReadInt32();
}
if (HasBakedColorSpace(reader.Version))
{
BakedColorSpace = (ColorSpace)reader.ReadInt32();
}
if (HasUseDualLightmapsInForward(reader.Version))
{
UseDualLightmapsInForward = reader.ReadBoolean();
}
if (IsAlign2(reader.Version))
{
reader.AlignStream();
}
if (HasGISettings(reader.Version))
{
GISettings.Read(reader);
}
#if UNIVERSAL
if (HasLightmapEditorSettings(reader.Version, reader.Flags))
{
LightmapEditorSettings.Read(reader);
}
if (HasLightingDataAsset(reader.Version, reader.Flags))
{
LightingDataAsset.Read(reader);
}
#endif
if (HasRuntimeCPUUsage(reader.Version))
{
RuntimeCPUUsage = reader.ReadInt32();
}
if (HasUseShadowmask(reader.Version))
{
if (IsBoolShadowmask(reader.Version))
{
UseShadowmask = reader.ReadBoolean();
}
else
{
ShadowMaskMode = reader.ReadInt32();
}
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
if (IsReadEnlightenSceneMapping(reader.Version, reader.Flags))
{
EnlightenSceneMapping.Read(reader);
}
if (IsReadGIWorkflowMode(reader.Version, reader.Flags))
{
GIWorkflowMode = reader.ReadInt32();
}
if (IsReadLightProbes(reader.Version, reader.Flags))
{
LightProbes.Read(reader);
}
if (IsReadLightmaps(reader.Flags))
{
m_lightmaps = reader.ReadAssetArray <LightmapData>();
}
if (IsAlign1(reader.Version, reader.Flags))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadLightmapsMode(reader.Version, reader.Flags))
{
LightmapsMode = (LightmapsMode)reader.ReadInt32();
}
if (IsReadBakedColorSpace(reader.Version))
{
BakedColorSpace = reader.ReadInt32();
}
if (IsReadUseDualLightmapsInForward(reader.Version))
{
UseDualLightmapsInForward = reader.ReadBoolean();
}
if (IsAlign2(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadGISettings(reader.Version))
{
GISettings.Read(reader);
}
if (IsReadLightmapEditorSettings(reader.Version, reader.Flags))
{
LightmapEditorSettings.Read(reader);
}
if (IsReadLightingDataAsset(reader.Version, reader.Flags))
{
LightingDataAsset.Read(reader);
}
if (IsReadRuntimeCPUUsage(reader.Version))
{
RuntimeCPUUsage = reader.ReadInt32();
}
if (IsReadUseShadowmask(reader.Version))
{
if (IsBoolShadowmask(reader.Version))
{
UseShadowmask = reader.ReadBoolean();
}
else
{
UseShadowmask = reader.ReadInt32() == 0 ? false : true;
}
}
}
