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);
}
private void SetupRendering()
{
var shadowRender = Shadows.Renderer(_sceneGraph, 2500, ShadowMapType.Depth, true)
.MapInput((double _) => _camera);
var skyboxRender = Skybox.Renderer(_sceneGraph, _skyColor);
var terrainRender = Terrain.Renderer(_sceneGraph, _skyColor, Shadows.Instance.csmUniforms);
var entityRender = Entities.Renderer(_sceneGraph, Shadows.Instance.csmUniforms);
var panelRender = Panels.Renderer(_sceneGraph)
.And(React.By((Vec2i vp) => ControlPanel <TexturedVertex> .UpdateAll(_sceneGraph, this, vp)))
.MapInput((double _) => new Vec2i(ClientSize.Width, ClientSize.Height));
var moveFighter = React.By <float> (UpdateFighterAndCamera)
.Aggregate((float s, double t) => s + (float)t * 25f, 0f);
React.By <double> (UpdateFPS)
.And(shadowRender
.And(skyboxRender
.And(terrainRender)
.And(entityRender)
.MapInput((double _) => _camera)
.And(panelRender)
.Viewport(this)))
.And(moveFighter)
.SwapBuffers(this)
.WhenRendered(this).Evoke();
Entities.UpdatePerspectiveMatrix()
.And(Skybox.UpdatePerspectiveMatrix())
.And(Terrain.UpdatePerspectiveMatrix())
.MapInput((Vec2 size) =>
(_camera.Frustum = new ViewingFrustum(FrustumKind.Perspective, size.X, size.Y, -1f, -400f))
.CameraToScreen)
.WhenResized(this).Evoke();
}
internal override Event ReadEntry(BinaryReaderEx br)
{
EventType type = br.GetEnum8 <EventType>(br.Position + br.VarintSize + 4);
switch (type)
{
case EventType.Light:
return(Lights.EchoAdd(new Event.Light(br)));
case EventType.Shadow:
return(Shadows.EchoAdd(new Event.Shadow(br)));
case EventType.Fog:
return(Fogs.EchoAdd(new Event.Fog(br)));
case EventType.BGColor:
return(BGColors.EchoAdd(new Event.BGColor(br)));
case EventType.MapOffset:
return(MapOffsets.EchoAdd(new Event.MapOffset(br)));
case EventType.Warp:
return(Warps.EchoAdd(new Event.Warp(br)));
case EventType.CheapMode:
return(CheapModes.EchoAdd(new Event.CheapMode(br)));
default:
throw new NotImplementedException($"Unimplemented event type: {type}");
}
}
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);
}
private static void LoadDefaults()
{
resolution = Screen.currentResolution;
fullscreen = Screen.fullScreen;
antialiasing = Antialiasing.Ultra;
shadows = Shadows.High;
bloom = Bloom.High;
motionBlur = MotionBlur.High;
}
protected void DestroyShadow(int shadow)
{
FAShadow sh = GetShadow(shadow);
if (sh != null)
{
sh.Dispose();
Shadows.Remove(sh);
}
}
void Update()
{
if (!isAI())
{
Inputs.HandleInputs();
}
Shadows.HandleShadows();
HandleAnimations();
}
public void Begin(Camera camera)
{
var transform = camera.GetTransform();
Tiles.Begin(SpriteSortMode.Deferred, samplerState: SamplerState.PointClamp, transformMatrix: transform);
Entities.Begin(SpriteSortMode.Deferred, samplerState: SamplerState.PointClamp, transformMatrix: transform);
Overlay.Begin(SpriteSortMode.Deferred, samplerState: SamplerState.PointClamp, transformMatrix: transform);
Lights.Begin(SpriteSortMode.Deferred, BlendState.Additive, SamplerState.LinearClamp,
transformMatrix: transform);
Shadows.Begin(SpriteSortMode.Deferred, samplerState: SamplerState.PointClamp, transformMatrix: transform);
}
public void SetDirection(Vector2 direction)
{
if (Direction == direction)
{
return;
}
Direction = direction;
if (Direction == Vector2.zero)
{
Parts.ForEach(i => i.SetActive(true));
Shadows.ForEach(i => i.SetActive(true));
Parts[0].transform.localPosition = Shadows[0].transform.localPosition = new Vector3(0, -1.25f);
Parts[1].transform.localPosition = Shadows[1].transform.localPosition = new Vector3(0, 1.25f);
Parts[2].transform.localPosition = Shadows[2].transform.localPosition = new Vector3(-1.5f, 0);
Parts[3].transform.localPosition = Shadows[3].transform.localPosition = new Vector3(1.5f, 0);
return;
}
Parts.ForEach(i => i.transform.localPosition = Vector3.zero);
Shadows.ForEach(i => i.transform.localPosition = Vector3.zero);
int index;
if (direction == Vector2.left)
{
index = 2;
}
else if (direction == Vector2.right)
{
index = 3;
}
else if (direction == Vector2.up)
{
index = 1;
}
else if (direction == Vector2.down)
{
index = 0;
}
else
{
throw new NotSupportedException();
}
for (var i = 0; i < Parts.Count; i++)
{
Parts[i].SetActive(i == index);
Shadows[i].SetActive(i == index);
}
}
string ToKeyword(Shadows en)
{
if (en == Shadows.HARD)
{
return("HARD_SHADOWS");
}
if (en == Shadows.VARIANCE)
{
return("VARIANCE_SHADOWS");
}
return("");
}
public static void Draw(Pass pass)
{
if (pass.drawShadows)
{
Shadows.Draw(pass);
}
if (pass.drawMask)
{
Masks.Draw(pass);
}
}
public override void Update()
{
var delta = Engine.Get().Delta;
_factorDay = _driverDay.Update(delta);
_skyboxRotation = new Vector3(360.0f * _factorDay, 0.0f, 0.0f);
var lightDirection = _skyboxRotation.Rotate(new Vector3(0.2f, 0.0f, 0.5f));
lightDirection.Normalize();
var fogColour = FogColourSunrise.Interpolate(FogColourNight, SunriseFactor);
fogColour = fogColour.Interpolate(FogColourDay, ShadowFactor);
_sunPosition = lightDirection * new Vector3(-6048.0f, -6048.0f, -6048.0f);
_moonPosition = lightDirection * new Vector3(6048.0f, 6048.0f, 6048.0f);
/*if (Scenes.Get().GetCamera() != null)
* {
* _sunPosition += Scenes.Get().Camera.Position;
* _moonPosition += Scenes.Get().Camera.Position;
* }*/
_sunColour = SunColourSunrise.Interpolate(SunColourNight, SunriseFactor);
_sunColour = _sunColour.Interpolate(SunColourDay, ShadowFactor);
_moonColour = MoonColourNight.Interpolate(MoonColourDay, ShadowFactor);
_fog.Colour = fogColour;
_fog.Density = 0.002f + ((1.0f - ShadowFactor * 0.002f));
_fog.Gradient = 2.0f - ((1.0f - ShadowFactor) * 0.380f);
_fog.LowerLimit = 0.0f;
_fog.UpperLimit = 0.15f - ((1.0f - ShadowFactor) * 0.03f);
_skyColour = SkyboxColourDay;
if (Shadows.Get() != null)
{
Shadows.Get().LightDirection = lightDirection;
Shadows.Get().ShadowBoxOffset = (4.0f * (1.0f - ShadowFactor)) + 10.0f;
Shadows.Get().ShadowBoxDistance = 40.0f;
Shadows.Get().ShadowTransition = 5.0f;
Shadows.Get().ShadowDarkness = 0.6f * ShadowFactor;
}
_factorSunrise = Math.Clamp(-((float)Math.Sin(2.0f * Math.PI * DayFactor) - 1.0f) / 2.0f, 0.0f, 1.0f);
_factorShadow = Math.Clamp(1.7f * (float)Math.Sin(2.0f * Math.PI * DayFactor), 0.0f, 1.0f);;
_sunHeight = _sunPosition.Y;
_starIntensity = Math.Clamp(1.0f - ShadowFactor, 0.0f, 1.0f);
}
public LightingForward()
{
buffer = new CommandBuffer()
{
name = "Lighting"
};
additionalLightsPositions = new Vector4[Definitions.MaxAdditionalLightsCount];
additionalLightsColors = new Vector4[Definitions.MaxAdditionalLightsCount];
additionalLightsSpotAngles = new Vector4[Definitions.MaxAdditionalLightsCount];
additionalLightsSpotDirs = new Vector4[Definitions.MaxAdditionalLightsCount];
additionalLightsOcclusionProbes = new Vector4[Definitions.MaxAdditionalLightsCount];
shadow = new Shadows();
}
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 Shadows ConvertShadowToDTO(BllShadows bllShadows)
{
Shadows dTOShadows = new Shadows()
{
Id = bllShadows.Id,
Name = bllShadows.Name,
Brand = bllShadows.Brand,
Price = bllShadows.Price,
Volume = bllShadows.Volume,
QuantityBottles = bllShadows.QuantityBottles,
QuantityGeneralVolume = bllShadows.QuantityGeneralVolume,
Color = bllShadows.Color,
QuntityCount = bllShadows.QuntityCount
};
return(dTOShadows);
}
public BllShadows ConvertShadowToBll(Shadows dTOShadows)
{
BllShadows bllShadows = new BllShadows()
{
Id = dTOShadows.Id,
Name = dTOShadows.Name,
Brand = dTOShadows.Brand,
Price = dTOShadows.Price,
Volume = dTOShadows.Volume,
QuantityBottles = dTOShadows.QuantityBottles,
QuantityGeneralVolume = dTOShadows.QuantityGeneralVolume,
Color = dTOShadows.Color,
QuntityCount = dTOShadows.QuntityCount
};
return(bllShadows);
}
internal override Event ReadEntry(BinaryReaderEx br)
{
EventType type = br.GetEnum16 <EventType>(br.Position + 0xC);
switch (type)
{
case EventType.Light:
var light = new Event.Light(br);
Lights.Add(light);
return(light);
case EventType.Shadow:
var shadow = new Event.Shadow(br);
Shadows.Add(shadow);
return(shadow);
case EventType.Fog:
var fog = new Event.Fog(br);
Fogs.Add(fog);
return(fog);
case EventType.BGColor:
var bgColor = new Event.BGColor(br);
BGColors.Add(bgColor);
return(bgColor);
case EventType.MapOffset:
var mapOffset = new Event.MapOffset(br);
MapOffsets.Add(mapOffset);
return(mapOffset);
case EventType.Warp:
var warp = new Event.Warp(br);
Warps.Add(warp);
return(warp);
case EventType.CheapMode:
var cheapMode = new Event.CheapMode(br);
CheapModes.Add(cheapMode);
return(cheapMode);
default:
throw new NotImplementedException($"Unimplemented event type: {type}");
}
}
public void ComputeShadowMesh(Vector3 lightWorldPosition)
{
List <VertexBuffer> vertexBuffers;
List <IndexBuffer> indexBuffers;
_gameWorld.GetRenderables(out vertexBuffers, out indexBuffers);
for (int i = 0; i < vertexBuffers.Count; ++i)
{
_shadowMeshIndices.Clear();
_shadowVertices.Clear();
_shadowIndices.Clear();
VertexPositionNormalTexture[] vertexData = new VertexPositionNormalTexture[vertexBuffers[i].VertexCount];
vertexBuffers[i].GetData <VertexPositionNormalTexture>(vertexData);
UInt32[] vertexIndices = new UInt32[indexBuffers[i].IndexCount];
indexBuffers[i].GetData <UInt32>(vertexIndices);
foreach (VertexPositionNormalTexture vertex in vertexData)
{
_shadowVertices.Add(vertex.Position);
}
foreach (UInt32 index in vertexIndices)
{
_shadowIndices.Add(index);
}
Shadows.CreateShadowVolumeMesh(vertexData.ToList(), _shadowIndices, Vector3.Zero - lightWorldPosition, ref _shadowMeshIndices, ref _shadowMeshVertices);
IndexBuffer shadowIndexBuffer = new IndexBuffer(GraphicsDevice, IndexElementSize.ThirtyTwoBits, _shadowMeshIndices.Count, BufferUsage.None);
shadowIndexBuffer.SetData(_shadowMeshIndices.ToArray());
_shadowIndexList.Add(shadowIndexBuffer);
List <VertexPositionColor> shadowVertices = new List <VertexPositionColor>();
foreach (Vector3 vertexPos in _shadowMeshVertices)
{
shadowVertices.Add(new VertexPositionColor(vertexPos, Color.White));
}
VertexBuffer shadowVertexBuffer = new VertexBuffer(GraphicsDevice, typeof(VertexPositionColor), shadowVertices.Count, BufferUsage.None);
shadowVertexBuffer.SetData(shadowVertices.ToArray());
_shadowVertexBufferList.Add(shadowVertexBuffer);
}
}
public static void Unload()
{
Subtitle.Dispose();
Title.Dispose();
Splash.Dispose();
MapSheet.Dispose();
MiniHP.Dispose();
HPMenu.Dispose();
Buttons.Dispose();
Shadows.Dispose();
Darkness.Dispose();
BattleFactors.Dispose();
Strip.Dispose();
Cursor.Dispose();
Arrows.Dispose();
PicBorder.Dispose();
MenuBorder.Dispose();
MenuBG.Dispose();
tileCache.Clear();
objectCache.Clear();
bgCache.Clear();
itemCache.Clear();
iconCache.Clear();
vfxCache.Clear();
portraitCache.Clear();
spriteCache.Clear();
DivTex.Dispose();
EXPFont.Dispose();
HealFont.Dispose();
DamageFont.Dispose();
DungeonFont.Dispose();
TextFont.Dispose();
SysFont.Dispose();
Pixel.Dispose();
defaultTex.Dispose();
Loaded = false;
//Notify script engine
LuaEngine.Instance.OnGraphicsUnload();
}
public override void Unpack(BinaryReader reader)
{
Id = reader.ReadUInt32();
Bitfield = reader.ReadUInt32();
reader.BaseStream.Position += 4; // Skip ahead 4 bytes, because this is the CellId. Again. Twice.
byte numSurfaces = reader.ReadByte();
byte numPortals = reader.ReadByte(); // Note that "portal" in this context does not refer to the swirly pink/purple thing, its basically connecting cells
ushort numStabs = reader.ReadUInt16(); // I believe this is what cells can be seen from this one. So the engine knows what else it needs to load/draw.
// Read what surfaces are used in this cell
for (uint i = 0; i < numSurfaces; i++)
{
Shadows.Add(0x08000000u | reader.ReadUInt16()); // these are stored in the dat as short values, so we'll make them a full dword
}
EnvironmentId = (0x0D000000u | reader.ReadUInt16());
CellStructure = reader.ReadUInt16();
Position.Unpack(reader);
CellPortals.Unpack(reader, numPortals);
for (uint i = 0; i < numStabs; i++)
{
VisibleCells.Add(reader.ReadUInt16());
}
if ((Bitfield & 2) != 0)
{
StaticObjects.Unpack(reader);
}
if ((Bitfield & 8) != 0)
{
RestrictionObj = reader.ReadUInt32();
}
}
void Start()
{
audioSource = GameObject.FindGameObjectWithTag("S_SoundFX").GetComponent <AudioSource>();
//myLight = GameObject.FindGameObjectWithTag("Flashlight").GetComponent<Light>();
//mySpotLight = GameObject.FindGameObjectWithTag("Spotlight").GetComponent<Light>();
currentRenderer = this.GetComponent <MeshRenderer>();
//print(currentRenderer);
myShadowM = this.GetComponent <Shadow_Movement>();
MyBox = this.GetComponent <BoxCollider>();
myShadow = this.GetComponent <Shadows>();
myRigid = this.GetComponent <Rigidbody>();
myMeshC = this.GetComponent <MeshCollider>();
myAudio = this.GetComponent <AudioSource>();
if (DeletedShadows.Contains(gameObject.name))
{
myMeshC.enabled = false;
//Change Texture
currentRenderer.material.mainTexture = normalTexture;
//Turn off trigger of Box Collider
MyBox.isTrigger = false;
//Activate MeshCollider
//myMeshC.enabled = true;
//Turn off Shadow Movement
Destroy(myShadowM);
//Turn off the Rigid Body
Destroy(myRigid);
//move positon
Xpos = myDictionary[gameObject.name][0];
Ypos = myDictionary[gameObject.name][1];
Zpos = myDictionary[gameObject.name][2];
transform.position = new Vector3(Xpos, Ypos, Zpos);
//Turn off shadow audio
myAudio.mute = true;
myAudio.enabled = false;
//Change Tag
transform.tag = "Untagged";
// Turn off Shadow Script
Destroy(myShadow);
}
}
public void Add(IMsbEvent item)
{
switch (item)
{
case Event.Light e:
Lights.Add(e);
break;
case Event.Shadow e:
Shadows.Add(e);
break;
case Event.Fog e:
Fogs.Add(e);
break;
case Event.BGColor e:
BGColors.Add(e);
break;
case Event.MapOffset e:
MapOffsets.Add(e);
break;
case Event.Warp e:
Warps.Add(e);
break;
case Event.CheapMode e:
CheapModes.Add(e);
break;
default:
throw new ArgumentException(
message: "Item is not recognized",
paramName: nameof(item));
}
}
/// <summary>
/// Adds an event to the appropriate list for its type; returns the event.
/// </summary>
public Event Add(Event evnt)
{
switch (evnt)
{
case Event.Light e: Lights.Add(e); break;
case Event.Shadow e: Shadows.Add(e); break;
case Event.Fog e: Fogs.Add(e); break;
case Event.BGColor e: BGColors.Add(e); break;
case Event.MapOffset e: MapOffsets.Add(e); break;
case Event.Warp e: Warps.Add(e); break;
case Event.CheapMode e: CheapModes.Add(e); break;
default:
throw new ArgumentException($"Unrecognized type {evnt.GetType()}.", nameof(evnt));
}
return(evnt);
}
/// <summary>
/// Teammember
/// </summary>
/// <param name="teammemberId"></param>
/// <param name="playerId"></param>
/// <param name="operationType"></param>
public void AddShadow(Guid teammemberId, int playerId, EnumOperationType operationType)
{
Shadows.Add(new TeammemberShadow(teammemberId, playerId, operationType, TransactionId));
}
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);
}
}
private void Add(object sender, RoutedEventArgs e)
{
foreach (var item in StockRoom.Items)
{
if ((item as TabItem).IsSelected)
{
if ((item as TabItem).Header.ToString() == "Shampoo")
{
AddMaterial(new Shampoo());
}
else if ((item as TabItem).Header.ToString() == "Balsam")
{
AddMaterial(new Balsam());
}
else if ((item as TabItem).Header.ToString() == "Color")
{
HairColor hairColor = new HairColor
{
Color = color.Text,
Description = description.Text
};
AddMaterial(hairColor);
}
else if ((item as TabItem).Header.ToString() == "Laque")
{
AddMaterial(new Laque());
}
else if ((item as TabItem).Header.ToString() == "Powder")
{
Powder powder = new Powder
{
Color = color.Text
};
AddMaterial(powder);
}
else if ((item as TabItem).Header.ToString() == "Foundation")
{
Foundation foundation = new Foundation
{
Color = color.Text,
Description = description.Text
};
AddMaterial(foundation);
}
else if ((item as TabItem).Header.ToString() == "Shadow")
{
Shadows shadows = new Shadows
{
Color = color.Text
};
AddMaterial(shadows);
}
else if ((item as TabItem).Header.ToString() == "Lipstick")
{
Lipstick lipstick = new Lipstick
{
Color = color.Text,
Description = description.Text
};
AddMaterial(lipstick);
}
else if ((item as TabItem).Header.ToString() == "Mascara")
{
Mascara mascara = new Mascara
{
Color = color.Text,
};
AddMaterial(mascara);
}
else if ((item as TabItem).Header.ToString() == "NailBase")
{
AddMaterial(new NailBase());
}
else if ((item as TabItem).Header.ToString() == "NailTop")
{
AddMaterial(new NailTop());
}
else if ((item as TabItem).Header.ToString() == "NailEnamel")
{
NailPolish nailPolish = new NailPolish
{
Color = color.Text,
};
AddMaterial(nailPolish);
}
}
}
load(null, null);
}
public void AddShadow(Shadow shadow)
{
Shadows.Add(shadow);
}
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 List <string> GetKeywords()
{
var Keywords = new List <string>();
if (Ring != null)
{
if (RingEnabled)
{
Keywords.Add("RING_ON");
Keywords.Add("SCATTERING");
var shadowsCount = Shadows.Count((shadow) => shadow != null && Helper.Enabled(shadow));
if (shadowsCount > 0 && GodManager.Instance.Eclipses)
{
for (byte i = 0; i < shadowsCount; i++)
{
Keywords.Add("SHADOW_" + (i + 1));
}
}
else
{
Keywords.Add("SHADOW_0");
}
}
else
{
Keywords.Add("RING_OFF");
}
}
else
{
Keywords.Add("RING_OFF");
}
if (Atmosphere != null)
{
if (AtmosphereEnabled)
{
var lightCount = Atmosphere.Suns.Count((sun) => sun != null && sun.gameObject.activeInHierarchy);
if (lightCount != 0)
{
Keywords.Add("LIGHT_" + lightCount);
}
if (Atmosphere.EclipseCasters.Count == 0)
{
Keywords.Add("ECLIPSES_OFF");
}
else
{
Keywords.Add(GodManager.Instance.Eclipses ? "ECLIPSES_ON" : "ECLIPSES_OFF");
}
if (Atmosphere.ShineCasters.Count == 0)
{
Keywords.Add("SHINE_OFF");
}
else
{
Keywords.Add(GodManager.Instance.Planetshine ? "SHINE_ON" : "SHINE_OFF");
}
Keywords.Add("ATMOSPHERE_ON");
}
else
{
Keywords.Add("ATMOSPHERE_OFF");
}
if (Ocean != null)
{
if (OceanEnabled && AtmosphereEnabled)
{
Keywords.Add("OCEAN_ON");
}
else
{
Keywords.Add("OCEAN_OFF");
}
}
else
{
Keywords.Add("OCEAN_OFF");
}
}
else
{
Keywords.Add("LIGHT_0");
Keywords.Add("ATMOSPHERE_OFF");
Keywords.Add("OCEAN_OFF");
}
return(Keywords);
}
public void AddShadow(int packageSize, byte[] itemString, byte itemVersion)
{
Shadows.Add(new ItemPackageShadow(packageSize, itemString, itemVersion, TransactionId));
}
