protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(ToSerializedVersion(container.ExportVersion));
node.Add(TypeName, (int)Type);
if (HasShape(container.ExportVersion))
{
node.Add(ShapeName, (int)Shape);
}
node.Add(ColorName, Color.ExportYAML(container));
node.Add(IntensityName, Intensity);
node.Add(RangeName, Range);
node.Add(SpotAngleName, SpotAngle);
if (HasInnerSpotAngle(container.ExportVersion))
{
node.Add(InnerSpotAngleName, InnerSpotAngle);
}
node.Add(CookieSizeName, CookieSize);
node.Add(ShadowsName, Shadows.ExportYAML(container));
node.Add(CookieName, Cookie.ExportYAML(container));
node.Add(DrawHaloName, DrawHalo);
if (HasBakingOutput(container.ExportVersion, container.ExportFlags))
{
node.Add(BakingOutputName, BakingOutput.ExportYAML(container));
}
node.Add(FlareName, Flare.ExportYAML(container));
node.Add(RenderModeName, (int)RenderMode);
node.Add(CullingMaskName, CullingMask.ExportYAML(container));
if (HasRenderingLayerMask(container.ExportVersion))
{
node.Add(RenderingLayerMaskName, RenderingLayerMask);
}
node.Add(LightmappingName, (int)Lightmapping);
node.Add(AreaSizeName, AreaSize.ExportYAML(container));
node.Add(BounceIntensityName, BounceIntensity);
node.Add(ColorTemperatureName, ColorTemperature);
node.Add(UseColorTemperatureName, UseColorTemperature);
if (HasBoundingSphereOverride(container.ExportVersion))
{
node.Add(BoundingSphereOverrideName, BoundingSphereOverride.ExportYAML(container));
node.Add(UseBoundingSphereOverrideName, UseBoundingSphereOverride);
}
node.Add(ShadowRadiusName, GetShadowRadius(container.Version, container.Flags));
node.Add(ShadowAngleName, GetShadowAngle(container.Version, container.Flags));
return(node);
}
public override void Read(AssetReader reader)
{
base.Read(reader);
Type = (LightType)reader.ReadInt32();
if (HasShape(reader.Version))
{
Shape = (LightShape)reader.ReadInt32();
}
Color.Read(reader);
if (HasAttenuate(reader.Version))
{
Attenuate = reader.ReadBoolean();
if (IsAlign(reader.Version))
{
reader.AlignStream();
}
}
if (HasIntensity(reader.Version))
{
Intensity = reader.ReadSingle();
}
Range = reader.ReadSingle();
SpotAngle = reader.ReadSingle();
if (HasInnerSpotAngle(reader.Version))
{
InnerSpotAngle = reader.ReadSingle();
}
if (HasCookieSize(reader.Version))
{
CookieSize = reader.ReadSingle();
}
if (HasShadows(reader.Version))
{
Shadows.Read(reader);
}
Cookie.Read(reader);
DrawHalo = reader.ReadBoolean();
if (HasActuallyLightmapped(reader.Version))
{
ActuallyLightmapped = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream();
}
if (HasBakedIndex(reader.Version))
{
BakedIndex = reader.ReadInt32();
}
if (HasBakingOutput(reader.Version, reader.Flags))
{
BakingOutput.Read(reader);
}
Flare.Read(reader);
RenderMode = (LightRenderMode)reader.ReadInt32();
if (HasCullingMask(reader.Version))
{
CullingMask.Read(reader);
}
if (HasRenderingLayerMask(reader.Version))
{
RenderingLayerMask = reader.ReadInt32();
}
if (HasLightmapping(reader.Version))
{
Lightmapping = (LightmappingMode)reader.ReadInt32();
}
if (HasLightShadowCasterMode(reader.Version))
{
LightShadowCasterMode = (LightShadowCasterMode)reader.ReadInt32();
}
if (HasAreaSize(reader.Version))
{
AreaSize.Read(reader);
}
if (HasBounceIntensity(reader.Version))
{
BounceIntensity = reader.ReadSingle();
}
if (HasFalloffTable(reader.Version))
{
FalloffTable.Read(reader);
}
if (HasColorTemperature(reader.Version))
{
ColorTemperature = reader.ReadSingle();
}
if (HasUseColorTemperature(reader.Version))
{
UseColorTemperature = reader.ReadBoolean();
reader.AlignStream();
}
if (HasBoundingSphereOverride(reader.Version))
{
BoundingSphereOverride.Read(reader);
UseBoundingSphereOverride = reader.ReadBoolean();
reader.AlignStream();
}
#if UNIVERSAL
if (HasShadowRadius(reader.Version, reader.Flags))
{
ShadowRadius = reader.ReadSingle();
ShadowAngle = reader.ReadSingle();
}
#endif
}
