protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
#warning TODO: values acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("m_ClearFlags", ClearFlags);
node.Add("m_BackGroundColor", BackGroundColor.ExportYAML(container));
node.Add("m_NormalizedViewPortRect", NormalizedViewPortRect.ExportYAML(container));
node.Add("near clip plane", NearClipPlane);
node.Add("far clip plane", FarClipPlane);
node.Add("field of view", FieldOfView);
node.Add("orthographic", Orthographic);
node.Add("orthographic size", OrthographicSize);
node.Add("m_Depth", Depth);
node.Add("m_CullingMask", CullingMask.ExportYAML(container));
node.Add("m_RenderingPath", (int)RenderingPath);
node.Add("m_TargetTexture", TargetTexture.ExportYAML(container));
node.Add("m_TargetDisplay", TargetDisplay);
node.Add("m_TargetEye", (int)TargetEye);
node.Add("m_HDR", HDR);
node.Add("m_AllowMSAA", AllowMSAA);
node.Add("m_AllowDynamicResolution", AllowDynamicResolution);
node.Add("m_ForceIntoRT", ForceIntoRT);
node.Add("m_OcclusionCulling", OcclusionCulling);
node.Add("m_StereoConvergence", StereoConvergence);
node.Add("m_StereoSeparation", StereoSeparation);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
#warning TODO: serialized version acording to read version (current 2017.3.0f3)
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.Version));
node.Add("m_Type", (int)Type);
node.Add("m_Color", Color.ExportYAML(container));
node.Add("m_Intensity", Intensity);
node.Add("m_Range", Range);
node.Add("m_SpotAngle", SpotAngle);
node.Add("m_CookieSize", CookieSize);
node.Add("m_Shadows", Shadows.ExportYAML(container));
node.Add("m_Cookie", Cookie.ExportYAML(container));
node.Add("m_DrawHalo", DrawHalo);
node.Add("m_Flare", Flare.ExportYAML(container));
node.Add("m_RenderMode", (int)RenderMode);
node.Add("m_CullingMask", CullingMask.ExportYAML(container));
node.Add("m_Lightmapping", (int)Lightmapping);
node.Add("m_AreaSize", AreaSize.ExportYAML(container));
node.Add("m_BounceIntensity", BounceIntensity);
node.Add("m_ColorTemperature", ColorTemperature);
node.Add("m_UseColorTemperature", UseColorTemperature);
#warning ???
node.Add("m_ShadowRadius", 0);
node.Add("m_ShadowAngle", 0);
return(node);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(TypeName, (int)Type);
node.Add(ColorName, Color.ExportYAML(container));
node.Add(IntensityName, Intensity);
node.Add(RangeName, Range);
node.Add(SpotAngleName, SpotAngle);
node.Add(CookieSizeName, CookieSize);
node.Add(ShadowsName, Shadows.ExportYAML(container));
node.Add(CookieName, Cookie.ExportYAML(container));
node.Add(DrawHaloName, DrawHalo);
node.Add(FlareName, Flare.ExportYAML(container));
node.Add(RenderModeName, (int)RenderMode);
node.Add(CullingMaskName, CullingMask.ExportYAML(container));
node.Add(LightmappingName, (int)Lightmapping);
node.Add(AreaSizeName, AreaSize.ExportYAML(container));
node.Add(BounceIntensityName, BounceIntensity);
node.Add(ColorTemperatureName, ColorTemperature);
node.Add(UseColorTemperatureName, UseColorTemperature);
node.Add(ShadowRadiusName, 0);
node.Add(ShadowAngleName, 0);
return(node);
}
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);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(TypeName, (int)Type);
node.Add(ModeName, (int)Mode);
node.Add(RefreshModeName, (int)RefreshMode);
node.Add(TimeSlicingModeName, (int)TimeSlicingMode);
node.Add(ResolutionName, Resolution);
node.Add(UpdateFrequencyName, UpdateFrequency);
node.Add(BoxSizeName, BoxSize.ExportYAML(container));
node.Add(BoxOffsetName, BoxOffset.ExportYAML(container));
node.Add(NearClipName, NearClip);
node.Add(FarClipName, FarClip);
node.Add(ShadowDistanceName, ShadowDistance);
node.Add(ClearFlagsName, (uint)ClearFlags);
node.Add(BackGroundColorName, BackGroundColor.ExportYAML(container));
node.Add(CullingMaskName, CullingMask.ExportYAML(container));
node.Add(IntensityMultiplierName, IntensityMultiplier);
node.Add(BlendDistanceName, BlendDistance);
node.Add(HDRName, HDR);
node.Add(BoxProjectionName, BoxProjection);
node.Add(RenderDynamicObjectsName, RenderDynamicObjects);
node.Add(UseOcclusionCullingName, UseOcclusionCulling);
node.Add(ImportanceName, Importance);
node.Add(CustomBakedTextureName, CustomBakedTexture.ExportYAML(container));
if (IsReadBakedTexture(container.ExportVersion, container.ExportFlags))
{
node.Add(BakedTextureName, BakedTextureTexture.ExportYAML(container));
}
return(node);
}
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 OnInspectorGUI()
{
base.OnInspectorGUI();
CullingMask mask = target as CullingMask;
mask.setOffset();
var p = mask.gameObject.transform.parent.gameObject;
var img = UIUtils.GetImage(p, "glowImg");
if (img)
{
img.rectTransform.localPosition = mask.GetComponent <RectTransform>().localPosition;
img.rectTransform.sizeDelta = mask.GetComponent <RectTransform>().sizeDelta;
}
}
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);
Type = (LightType)reader.ReadInt32();
Color.Read(reader);
if (IsReadAttenuate(reader.Version))
{
Attenuate = reader.ReadBoolean();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
}
if (IsReadIntensity(reader.Version))
{
Intensity = reader.ReadSingle();
}
Range = reader.ReadSingle();
SpotAngle = reader.ReadSingle();
if (IsReadCookieSize(reader.Version))
{
CookieSize = reader.ReadSingle();
}
if (IsReadShadows(reader.Version))
{
Shadows.Read(reader);
}
Cookie.Read(reader);
DrawHalo = reader.ReadBoolean();
if (IsReadActuallyLightmapped(reader.Version))
{
ActuallyLightmapped = reader.ReadBoolean();
}
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
if (IsReadBakedIndex(reader.Version))
{
BakedIndex = reader.ReadInt32();
}
if (IsReadBakingOutput(reader.Version))
{
BakingOutput.Read(reader);
}
Flare.Read(reader);
RenderMode = (LightRenderMode)reader.ReadInt32();
if (IsReadCullingMask(reader.Version))
{
CullingMask.Read(reader);
}
if (IsReadLightmapping(reader.Version))
{
Lightmapping = (LightmappingMode)reader.ReadInt32();
}
if (IsReadLightShadowCasterMode(reader.Version))
{
LightShadowCasterMode = (LightShadowCasterMode)reader.ReadInt32();
}
if (IsReadAreaSize(reader.Version))
{
AreaSize.Read(reader);
}
if (IsReadBounceIntensity(reader.Version))
{
BounceIntensity = reader.ReadSingle();
}
if (IsReadFalloffTable(reader.Version))
{
FalloffTable.Read(reader);
}
if (IsReadColorTemperature(reader.Version))
{
ColorTemperature = reader.ReadSingle();
UseColorTemperature = reader.ReadBoolean();
reader.AlignStream(AlignType.Align4);
}
}
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();
}
}
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
}
public override void Read(AssetStream stream)
{
base.Read(stream);
Type = (LightType)stream.ReadInt32();
Color.Read(stream);
if (IsReadAttenuate(stream.Version))
{
Attenuate = stream.ReadBoolean();
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
}
if (IsReadIntensity(stream.Version))
{
Intensity = stream.ReadSingle();
}
Range = stream.ReadSingle();
SpotAngle = stream.ReadSingle();
if (IsReadCookieSize(stream.Version))
{
CookieSize = stream.ReadSingle();
}
if (IsReadShadows(stream.Version))
{
Shadows.Read(stream);
}
Cookie.Read(stream);
DrawHalo = stream.ReadBoolean();
if (IsReadActuallyLightmapped(stream.Version))
{
ActuallyLightmapped = stream.ReadBoolean();
}
if (IsAlign(stream.Version))
{
stream.AlignStream(AlignType.Align4);
}
if (IsReadBakedIndex(stream.Version))
{
BakedIndex = stream.ReadInt32();
}
if (IsReadBakingOutput(stream.Version))
{
BakingOutput.Read(stream);
}
Flare.Read(stream);
RenderMode = (LightRenderMode)stream.ReadInt32();
if (IsReadCullingMask(stream.Version))
{
CullingMask.Read(stream);
}
if (IsReadLightmapping(stream.Version))
{
Lightmapping = (LightmappingMode)stream.ReadInt32();
}
if (IsReadAreaSize(stream.Version))
{
AreaSize.Read(stream);
}
if (IsReadBounceIntensity(stream.Version))
{
BounceIntensity = stream.ReadSingle();
}
if (IsReadColorTemperature(stream.Version))
{
ColorTemperature = stream.ReadSingle();
UseColorTemperature = stream.ReadBoolean();
stream.AlignStream(AlignType.Align4);
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
Type = (ReflectionProbeType)reader.ReadInt32();
Mode = (ReflectionProbeMode)reader.ReadInt32();
if (IsReadRefreshMode(reader.Version))
{
RefreshMode = (ReflectionProbeRefreshMode)reader.ReadInt32();
TimeSlicingMode = (ReflectionProbeTimeSlicingMode)reader.ReadInt32();
}
Resolution = reader.ReadInt32();
UpdateFrequency = reader.ReadInt32();
if (IsReadImportance(reader.Version))
{
if (IsReadImportanceFirst(reader.Version))
{
Importance = reader.ReadInt16();
}
}
BoxSize.Read(reader);
BoxOffset.Read(reader);
NearClip = reader.ReadSingle();
FarClip = reader.ReadSingle();
ShadowDistance = reader.ReadSingle();
ClearFlags = (ReflectionProbeClearFlags)reader.ReadUInt32();
BackGroundColor.Read(reader);
CullingMask.Read(reader);
IntensityMultiplier = reader.ReadSingle();
if (IsReadBlendDistance(reader.Version))
{
BlendDistance = reader.ReadSingle();
}
if (IsReadBakedRenderPassCount(reader.Version))
{
BakedRenderPassCount = reader.ReadUInt32();
UseMipMap = reader.ReadBoolean();
}
HDR = reader.ReadBoolean();
if (IsReadBoxProjection(reader.Version))
{
BoxProjection = reader.ReadBoolean();
RenderDynamicObjects = reader.ReadBoolean();
UseOcclusionCulling = reader.ReadBoolean();
}
if (IsReadImportance(reader.Version))
{
if (!IsReadImportanceFirst(reader.Version))
{
Importance = reader.ReadInt16();
}
}
reader.AlignStream(AlignType.Align4);
if (IsReadCustomBakedTexture(reader.Version))
{
CustomBakedTexture.Read(reader);
}
if (IsReadBakedTexture(reader.Version, reader.Flags))
{
BakedTextureTexture.Read(reader);
}
}
