protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add(ClearFlagsName, ClearFlags);
node.Add(BackGroundColorName, BackGroundColor.ExportYAML(container));
// 2018
node.Add(ProjectionMatrixModeName, (int)ProjectionMatrixMode);
node.Add(SensorSizeName, SensorSize.ExportYAML(container));
node.Add(LensShiftName, LensShift.ExportYAML(container));
node.Add(FocalLengthName, FocalLength);
node.Add(NormalizedViewPortRectName, NormalizedViewPortRect.ExportYAML(container));
node.Add(NearClipPlaneName, NearClipPlane);
node.Add(FarClipPlaneName, FarClipPlane);
node.Add(FieldOfViewName, FieldOfView);
node.Add(OrthographicName, Orthographic);
node.Add(OrthographicSizeName, OrthographicSize);
node.Add(DepthName, Depth);
node.Add(CullingMaskName, CullingMask.ExportYAML(container));
node.Add(RenderingPathName, (int)RenderingPath);
node.Add(TargetTextureName, TargetTexture.ExportYAML(container));
node.Add(TargetDisplayName, TargetDisplay);
node.Add(TargetEyeName, (int)TargetEye);
node.Add(HDRName, HDR);
node.Add(AllowMSAAName, AllowMSAA);
node.Add(AllowDynamicResolutionName, AllowDynamicResolution);
node.Add(ForceIntoRTName, ForceIntoRT);
node.Add(OcclusionCullingName, OcclusionCulling);
node.Add(StereoConvergenceName, StereoConvergence);
node.Add(StereoSeparationName, StereoSeparation);
return(node);
}
public override void Read(AssetStream stream)
{
base.Read(stream);
ClearFlags = stream.ReadUInt32();
BackGroundColor.Read(stream);
if (IsReadProjectionMatrixMode(stream.Version))
{
ProjectionMatrixMode = (ProjectionMatrixMode)stream.ReadInt32();
SensorSize.Read(stream);
LensShift.Read(stream);
FocalLength = stream.ReadSingle();
}
NormalizedViewPortRect.Read(stream);
NearClipPlane = stream.ReadSingle();
FarClipPlane = stream.ReadSingle();
FieldOfView = stream.ReadSingle();
Orthographic = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
OrthographicSize = stream.ReadSingle();
Depth = stream.ReadSingle();
CullingMask.Read(stream);
if (IsReadRenderingPath(stream.Version))
{
RenderingPath = (RenderingPath)stream.ReadInt32();
}
TargetTexture.Read(stream);
if (IsReadTargetDisplay(stream.Version))
{
TargetDisplay = stream.ReadInt32();
}
if (IsReadTargetEye(stream.Version))
{
TargetEye = (StereoTargetEyeMask)stream.ReadInt32();
}
if (IsReadHDR(stream.Version))
{
HDR = stream.ReadBoolean();
}
if (IsReadAllowMSAA(stream.Version))
{
AllowMSAA = stream.ReadBoolean();
}
if (IsReadAllowDynamicResolution(stream.Version))
{
AllowDynamicResolution = stream.ReadBoolean();
}
if (IsReadForceIntoRT(stream.Version))
{
ForceIntoRT = stream.ReadBoolean();
}
if (IsReadOcclusionCulling(stream.Version))
{
OcclusionCulling = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadStereoConvergence(stream.Version))
{
StereoConvergence = stream.ReadSingle();
StereoSeparation = stream.ReadSingle();
}
if (IsReadStereoMirrorMode(stream.Version))
{
StereoMirrorMode = stream.ReadBoolean();
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
ClearFlags = reader.ReadUInt32();
BackGroundColor.Read(reader);
if (HasProjectionMatrixMode(reader.Version))
{
ProjectionMatrixMode = (ProjectionMatrixMode)reader.ReadInt32();
}
if (HasGateFitMode(reader.Version))
{
if (HasGateFitModeFirst(reader.Version))
{
GateFitMode = (GateFitMode)reader.ReadInt32();
}
}
#if UNIVERSAL
if (HasFOVAxisMode(reader.Version, reader.Flags))
{
FOVAxisMode = (FieldOfViewAxis)reader.ReadInt32();
}
#endif
if (IsAlign1(reader.Version))
{
reader.AlignStream();
}
if (HasSensorSize(reader.Version))
{
SensorSize.Read(reader);
LensShift.Read(reader);
}
if (HasGateFitMode(reader.Version))
{
if (!HasGateFitModeFirst(reader.Version))
{
GateFitMode = (GateFitMode)reader.ReadInt32();
}
}
if (HasFocalLength(reader.Version))
{
FocalLength = reader.ReadSingle();
}
NormalizedViewPortRect.Read(reader);
NearClipPlane = reader.ReadSingle();
FarClipPlane = reader.ReadSingle();
FieldOfView = reader.ReadSingle();
Orthographic = reader.ReadBoolean();
reader.AlignStream();
OrthographicSize = reader.ReadSingle();
Depth = reader.ReadSingle();
CullingMask.Read(reader);
if (HasRenderingPath(reader.Version))
{
RenderingPath = (RenderingPath)reader.ReadInt32();
}
TargetTexture.Read(reader);
if (HasTargetDisplay(reader.Version))
{
TargetDisplay = reader.ReadInt32();
}
if (HasTargetEye(reader.Version))
{
TargetEye = (StereoTargetEyeMask)reader.ReadInt32();
}
if (HasHDR(reader.Version))
{
HDR = reader.ReadBoolean();
}
if (HasAllowMSAA(reader.Version))
{
AllowMSAA = reader.ReadBoolean();
}
if (HasAllowDynamicResolution(reader.Version))
{
AllowDynamicResolution = reader.ReadBoolean();
}
if (HasForceIntoRT(reader.Version))
{
ForceIntoRT = reader.ReadBoolean();
}
if (HasOcclusionCulling(reader.Version))
{
OcclusionCulling = reader.ReadBoolean();
}
if (IsAlign2(reader.Version))
{
reader.AlignStream();
}
if (HasStereoConvergence(reader.Version))
{
StereoConvergence = reader.ReadSingle();
StereoSeparation = reader.ReadSingle();
}
if (HasStereoMirrorMode(reader.Version))
{
StereoMirrorMode = reader.ReadBoolean();
}
}