scriptedlightbase.c

Go to the documentation of this file.

/*
Please remember that:
-Lights work only on client side!
-Lights with Brightness or Radius of 0 (or less) are automatically deleted
-Lights are very performance heavy. Especially if they cast shadows. Use them carefully!
 
Script author: Boris Vacula
*/
 
class ScriptedLightBase extends EntityLightSource
{
 float m_LifetimeStart;
 float m_LifetimeEnd = -1; // -1 makes this light permanent
 float m_FadeOutTime = -1;
 float m_FadeInTime = -1;
 float m_Radius;
 float m_RadiusTarget;
 float m_Brightness;
 float m_BrightnessPulse; // flicker effect
 float m_BrightnessPulseSpeed;
 float m_BrightnessPulseAmplitudeMax;
 float m_BrightnessPulseAmplitudeMin;
 float m_BrightnessTarget;
 float m_BrightnessSpeedOfChange = 1;
 float m_RadiusSpeedOfChange = 1;
 float m_OptimizeShadowsRadius = 0; // Within this range between the light source and camera the shadows will be automatically disabled to save on performance
 
 float m_DancingShadowsAmplitude;
 float m_DancingShadowsSpeed;
 
 float m_BlinkingSpeed;
 
 bool m_IsDebugEnabled = false;
 
 Object m_Parent; // Attachment parent
 vector m_LocalPos; // Local position to my attachment parent
 vector m_LocalOri; // Local orientation to my attachment parent
 vector m_DancingShadowsLocalPos;
 
 ref Timer m_DeleteTimer;
 
 static ref set<ScriptedLightBase> m_NightTimeOnlyLights = new set<ScriptedLightBase>();
 
 void ScriptedLightBase()
 {
 m_LifetimeStart = GetGame().GetTime();
 SetEnabled(true);
 SetEventMask(EntityEvent.FRAME);
 SetEventMask(EntityEvent.INIT);
 }
 
 void ~ScriptedLightBase()
 {
 if (m_NightTimeOnlyLights)
 {
 int index = m_NightTimeOnlyLights.Find(this);
 if (index != -1)
 {
 m_NightTimeOnlyLights.Remove(index);
 }
 }
 }
 
 override void EOnInit(IEntity other, int extra)
 {
 if (!IsVisibleDuringDaylight())
 {
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 if (player && player.m_UndergroundPresence)
 SetVisibleDuringDaylight(true);
 m_NightTimeOnlyLights.Insert(this);
 }
 }
 
 override bool IsScriptedLight()
 {
 return true;
 }
 
 void UpdateMode()
 {
 ItemBase item = ItemBase.Cast(m_Parent);
 if (item)
 {
 InventoryLocation il = new InventoryLocation;
 item.GetInventory().GetCurrentInventoryLocation( il );
 string slotName;
 if (il.GetType() == InventoryLocationType.GROUND)
 {
 slotName = "Ground";
 }
 else if (il.GetSlot() != -1)
 {
 slotName = InventorySlots.GetSlotName(il.GetSlot());
 }
 UpdateLightMode(slotName); 
 }
 }
 
 private void UpdateLightMode(string slotName);
 
 private void DeleteLightWithDelay()
 {
 DetachFromParent(); // This is the reason for the delay
 
 if (GetGame())
 {
 if (!m_DeleteTimer)
 m_DeleteTimer = new Timer( CALL_CATEGORY_SYSTEM );
 
 m_DeleteTimer.Run( 0.03 , this, "DeleteLightNow", NULL, true);
 }
 
 }
 
 // Deletes light now. Do not call this directly. Call Destroy() instead. Otherwise you might get errors related to hierarchy.
 private void DeleteLightNow()
 {
 GetGame().ObjectDelete(this);
 }
 
 void AttachOnObject(Object parent, vector local_pos = "0 0 0", vector local_ori = "0 0 0")
 {
 if (!parent)
 {
 if (m_Parent)
 {
 m_Parent.RemoveChild(this);
 }
 
 return;
 }
 else
 {
 if (m_Parent)
 {
 m_Parent.RemoveChild(this);
 }
 }
 
 m_Parent = parent;
 m_LocalPos = local_pos;
 m_LocalOri = local_ori;
 SetOrientation(local_ori);
 SetPosition(local_pos);
 parent.AddChild(this, -1);
 parent.Update();
 }
 
 Object GetAttachmentParent()
 {
 return m_Parent;
 }
 
 void AttachOnMemoryPoint(Object parent, string memory_point_start, string memory_point_target = "")
 {
 if (parent.MemoryPointExists(memory_point_start))
 {
 m_LocalPos = parent.GetMemoryPointPos(memory_point_start);
 vector local_ori;
 
 if (memory_point_target != "" )
 {
 if (parent.MemoryPointExists(memory_point_target))
 {
 vector target_pos = parent.GetSelectionPositionLS(memory_point_target);
 target_pos = vector.Direction(m_LocalPos, target_pos);
 local_ori = target_pos.VectorToAngles();
 }
 else
 {
 ErrorEx("memory point 'memory_point_target' not found when attaching light");
 }
 }
 AttachOnObject(parent, m_LocalPos, local_ori); 
 UpdateMode();
 }
 else
 {
 ErrorEx("memory point 'memory_point_start' not found when attaching light");
 }
 }
 
 void DetachFromParent()
 {
 if (!m_Parent)
 {
 m_Parent = Object.Cast( GetParent() );
 }
 
 if (m_Parent)
 {
 if ( !m_Parent.ToDelete() && !ToDelete() )
 {
 m_Parent.RemoveChild(this);
 }
 }
 
 m_Parent = null;
 m_LocalPos = Vector(0,0,0);
 m_LocalOri = Vector(0,0,0);
 }
 
 static ScriptedLightBase CreateLightAtObjMemoryPoint(typename name, notnull Object target, string memory_point_start, string memory_point_target = "", vector global_pos = "0 0 0", float fade_in_time_in_s = 0)
 {
 ScriptedLightBase light;
 if (target.MemoryPointExists(memory_point_start))
 {
 light = CreateLight(name, global_pos, fade_in_time_in_s);
 light.AttachOnMemoryPoint(target, memory_point_start, memory_point_target);
 }
 return light;
 }
 
 static ScriptedLightBase CreateLight(typename name, vector global_pos = "0 0 0", float fade_in_time_in_s = 0)
 {
 ScriptedLightBase light_instance;
 
 if ( !GetGame().IsServer() || !GetGame().IsMultiplayer() ) // Client side
 {
 light_instance = ScriptedLightBase.Cast( GetGame().CreateObject(name.ToString(), global_pos, true) );
 
 if (!light_instance)
 {
 Error("Error! Light entity of name " + name.ToString() + " cannot be spawned! This name is incorrect or not inherited from ScriptedLightBase." );
 return null;
 }
 
 if (fade_in_time_in_s != 0)
 {
 light_instance.FadeIn(fade_in_time_in_s);
 }
 }
 else // Server side
 {
 if ( GetGame().IsDebug() )
 {
 Error("An instance of ScriptedLightBase was attempted to spawn on server side! Lights are CLIENT SIDE ONLY!");
 }
 }
 
 return light_instance;
 }
 
 void SetBrightnessTo(float value)
 {
 m_Brightness = value;
 m_BrightnessTarget = value;
 SetBrightness(m_Brightness * m_BrightnessPulse);
 CorrectLightPulseDuringDaylight();
 }
 
 void CorrectLightPulseDuringDaylight()
 {
 if (m_Brightness < 100)
 {
 float v = m_Brightness * 0.01;
 
 if (v > 0)
 {
 float brightness_compesation = 1 / v;
 float compenset_brightness = (m_Brightness * m_BrightnessPulse) * brightness_compesation;
 SetBrightness(compenset_brightness);
 SetPulseCoef(v);
 }
 }
 else
 {
 SetPulseCoef(1);
 }
 }
 
 void FadeBrightnessTo( float value, float time_in_s )
 {
 m_BrightnessTarget = value;
 
 if (time_in_s == 0)
 {
 m_BrightnessSpeedOfChange = 9999;
 }
 else
 {
 m_BrightnessSpeedOfChange = Math.AbsFloat(m_Brightness - m_BrightnessTarget) / time_in_s;
 }
 }
 
 void SetRadiusTo(float value)
 {
 m_Radius = value;
 m_RadiusTarget = value;
 SetRadius(m_Radius);
 }
 
 void FadeRadiusTo( float value, float time_in_s )
 {
 m_RadiusTarget = value;
 
 if (time_in_s == 0)
 {
 m_RadiusSpeedOfChange = 9999;
 }
 else
 {
 m_RadiusSpeedOfChange = Math.AbsFloat(m_Radius - m_RadiusTarget) / time_in_s;
 }
 }
 
 void Destroy()
 {
 ClearEventMask(EntityEvent.FRAME);
 SetEnabled(false);
 if (m_Parent)
 DeleteLightWithDelay();
 else
 DeleteLightNow();
 }
 
 void SetLifetime(float life_in_s)
 {
 if(GetGame())
 m_LifetimeEnd = GetGame().GetTime() + life_in_s * 1000;
 }
 
 void SetFadeOutTime(float time_in_s)
 {
 m_FadeOutTime = time_in_s * 1000;
 }
 
 void FadeOut(float time_in_s = -1)
 {
 float time_in_ms = time_in_s * 1000;
 
 if (time_in_s == -1)
 {
 float kill_time_in_s = m_FadeOutTime*0.001;
 
 FadeBrightnessTo(0, kill_time_in_s);
 FadeRadiusTo(0, kill_time_in_s);
 SetLifetime(kill_time_in_s);
 }
 else
 {
 FadeBrightnessTo(0, time_in_s);
 FadeRadiusTo(0, time_in_s);
 SetLifetime(time_in_s);
 }
 }
 
 void FadeIn(float time_in_s)
 {
 float brightness = m_Brightness;
 SetBrightnessTo(0);
 FadeBrightnessTo(brightness, time_in_s);
 }
 
 void AddLifetime(float life_in_s)
 {
 m_LifetimeEnd += life_in_s * 1000;
 }
 
 void OnFrameLightSource(IEntity other, float timeSlice)
 {
 // ... 
 }
 
 override void EOnFrame(IEntity other, float timeSlice)
 {
 // Control lifetime of the light
 int current_time = GetGame().GetTime();
 
 if ( CheckLifetime(current_time) )
 {
 SetRadius(m_Radius);
 }
 else
 {
 return;
 }
 
 HandleFlickering(current_time - m_LifetimeStart, timeSlice);
 HandleDancingShadows(current_time - m_LifetimeStart, timeSlice);
 CheckFadeOut(current_time);
 HandleBrightnessFadeing(timeSlice);
 HandleRadiusFadeing(timeSlice);
 
 CheckIfParentIsInCargo();
 TryShadowOptimization();
 OnFrameLightSource(other, timeSlice);
 
 HandleBlinking(current_time);
 }
 
 void SetDancingShadowsAmplitude(float max_deviation_in_meters)
 {
 m_DancingShadowsAmplitude = Math.AbsFloat(max_deviation_in_meters);
 }
 
 void SetDancingShadowsMovementSpeed(float speed_in_meters_per_frame)
 {
 m_DancingShadowsSpeed = Math.AbsFloat(speed_in_meters_per_frame);
 }
 
 float GetDancingShadowsAmplitude()
 {
 return m_DancingShadowsAmplitude;
 }
 
 float GetDancingShadowsMovementSpeed()
 {
 return m_DancingShadowsSpeed;
 }
 
 void EnableDebug(bool state)
 {
 m_IsDebugEnabled = state;
 }
 
 // Handles subtle movement of the light point to create the effect of dancing shadows
 void HandleDancingShadows(float time, float timeSlice)
 {
 if (m_DancingShadowsAmplitude > 0)
 {
 for (int i = 0; i < 3; i++ )
 {
 m_DancingShadowsLocalPos[i] = m_DancingShadowsLocalPos[i] + ( Math.RandomFloat(-m_DancingShadowsSpeed,m_DancingShadowsSpeed) * timeSlice) ;
 
 if (m_DancingShadowsLocalPos[i] > m_DancingShadowsAmplitude)
 m_DancingShadowsLocalPos[i] = m_DancingShadowsAmplitude;
 
 if (m_DancingShadowsLocalPos[i] < -m_DancingShadowsAmplitude)
 m_DancingShadowsLocalPos[i] = -m_DancingShadowsAmplitude;
 
 }
 
 if (m_Parent && !m_Parent.ToDelete())
 {
 // In order to move with the light, it must be detached from its parent first
 
 m_Parent.RemoveChild(this);
 SetPosition(m_LocalPos + m_DancingShadowsLocalPos);
 
 m_Parent.AddChild(this, -1);
 m_Parent.Update();
 }
 
 if (m_IsDebugEnabled)
 {
 Particle p = ParticleManager.GetInstance().PlayInWorld( ParticleList.DEBUG_DOT, GetPosition() );
 p.SetParticleParam( EmitorParam.SIZE, 0.01);
 }
 }
 else
 {
 m_DancingShadowsLocalPos = Vector(0,0,0);
 }
 }
 
 // Updates flickering light
 void HandleFlickering(float time, float timeSlice)
 {
 if (m_BrightnessPulseAmplitudeMax > 0)
 {
 m_BrightnessPulse += ( Math.RandomFloat(-m_BrightnessPulseSpeed, m_BrightnessPulseSpeed) ) * timeSlice;
 
 if (m_BrightnessPulse < m_BrightnessPulseAmplitudeMin + 1)
 m_BrightnessPulse = m_BrightnessPulseAmplitudeMin + 1;
 
 if (m_BrightnessPulse > m_BrightnessPulseAmplitudeMax + 1)
 m_BrightnessPulse = m_BrightnessPulseAmplitudeMax + 1;
 
 }
 else
 {
 m_BrightnessPulse = 1;
 }
 }
 
 void SetFlickerSpeed(float speed)
 {
 m_BrightnessPulseSpeed = speed;
 }
 
 void SetFlickerAmplitude(float coef)
 {
 m_BrightnessPulseAmplitudeMax = Math.AbsFloat(coef);
 m_BrightnessPulseAmplitudeMin = -Math.AbsFloat(coef);
 }
 
 void SetFlickerAmplitudeMax(float coef)
 {
 m_BrightnessPulseAmplitudeMax = coef;
 }
 
 void SetFlickerAmplitudeMin(float coef)
 {
 m_BrightnessPulseAmplitudeMin = coef;
 }
 
 float GetFlickerSpeed()
 {
 return m_BrightnessPulseSpeed;
 }
 
 float GetFlickerAmplitudeCoefMax()
 {
 return m_BrightnessPulseAmplitudeMax;
 }
 
 float GetFlickerAmplitudeCoefMin()
 {
 return m_BrightnessPulseAmplitudeMin;
 }
 
 void TryShadowOptimization()
 {
 if (m_OptimizeShadowsRadius > 0)
 {
 float distance_to_camera = vector.Distance( GetPosition(), GetGame().GetCurrentCameraPosition() );
 
 if (distance_to_camera < m_OptimizeShadowsRadius)
 {
 SetCastShadow(false);
 }
 else
 {
 SetCastShadow(true);
 }
 }
 }
 
 void SetDisableShadowsWithinRadius(float radius_in_m)
 {
 m_OptimizeShadowsRadius = radius_in_m;
 }
 
 float GetDisableShadowsWithinRadius()
 {
 return m_OptimizeShadowsRadius;
 }
 
 void CheckIfParentIsInCargo()
 {
 // TO DO: OPTIMIZE AND REFACTOR! THIS MUST BE HANDLED IN AN EVENT, NOT PER FRAME!
 
 if (m_Parent)
 {
 EntityAI parent_EAI = EntityAI.Cast( m_Parent );
 
 if (parent_EAI) // Check if the Cast was successfull
 {
 GameInventory GI = parent_EAI.GetInventory();
 
 if (GI) // Prevents handling of light on the parent item when it's projected in inventory as the item in inventory character's hands.
 {
 bool is_in_cargo = GI.IsInCargo();
 
 if (!is_in_cargo)
 {
 EntityAI parent2 = parent_EAI.GetHierarchyParent();
 
 if (parent2 && parent2.GetInventory())
 {
 is_in_cargo = parent2.GetInventory().IsInCargo();
 }
 }
 
 if ( is_in_cargo )
 {
 SetEnabled(false);
 }
 else
 {
 SetEnabled(true);
 }
 }
 }
 }
 }
 
 // Destroys this light if it's past it lifetime
 private bool CheckLifetime(int current_time)
 {
 if ( current_time > m_LifetimeEnd && m_LifetimeEnd != -1 )
 {
 Destroy();
 return false;
 }
 
 return true;
 }
 
 // Handles fade out effect at the end of lifetime
 private void CheckFadeOut( int current_time)
 {
 // Control fade out of the light
 if ( m_FadeOutTime != -1 && m_LifetimeEnd != -1 && current_time > m_LifetimeEnd - m_FadeOutTime )
 {
 m_FadeOutTime = -1;
 m_FadeInTime = -1; // Stop fade in process
 float time_left_in_s = (m_LifetimeEnd - current_time) * 0.001;
 FadeBrightnessTo(0, time_left_in_s);
 FadeRadiusTo(0, time_left_in_s);
 }
 }
 
 // handles fading of brightness
 private void HandleBrightnessFadeing(float timeSlice)
 {
 if ( m_Brightness != m_BrightnessTarget )
 {
 float brightness_difference = m_Brightness - m_BrightnessTarget;
 
 if (brightness_difference > m_BrightnessSpeedOfChange*timeSlice)
 brightness_difference = m_BrightnessSpeedOfChange*timeSlice;
 
 if (brightness_difference < -m_BrightnessSpeedOfChange*timeSlice)
 brightness_difference = -m_BrightnessSpeedOfChange*timeSlice;
 
 m_Brightness -= brightness_difference;
 
 if ( m_Brightness > 0 || m_BrightnessTarget > 0)
 {
 SetBrightness(m_Brightness * m_BrightnessPulse);
 CorrectLightPulseDuringDaylight();
 }
 else
 {
 Destroy();
 return;
 }
 }
 else
 {
 SetBrightness(m_Brightness * m_BrightnessPulse);
 CorrectLightPulseDuringDaylight();
 }
 }
 
 // handles fading of radius
 private void HandleRadiusFadeing(float timeSlice)
 {
 if ( m_Radius != m_RadiusTarget )
 {
 float radius_difference = m_Radius - m_RadiusTarget;
 
 if (radius_difference > m_RadiusSpeedOfChange*timeSlice)
 radius_difference = m_RadiusSpeedOfChange*timeSlice;
 
 if (radius_difference < -m_RadiusSpeedOfChange*timeSlice)
 radius_difference = -m_RadiusSpeedOfChange*timeSlice;
 
 m_Radius -= radius_difference;
 
 if ( m_Radius > 0 || m_RadiusTarget > 0)
 {
 SetRadius(m_Radius);
 }
 else
 {
 Destroy();
 return;
 }
 }
 else
 {
 SetRadius(m_Radius);
 }
 }
 
 void SetBlinkingSpeed(float _speed)
 {
 m_BlinkingSpeed = _speed;
 }
 
 float GetBlinkingSpeed()
 {
 return m_BlinkingSpeed;
 }
 
 // handles blinking. Turns light on and off on regular intervals
 private void HandleBlinking(float time)
 {
 if ( m_BlinkingSpeed <= 0 )
 return;
 
 float multiplier;
 
 multiplier = Math.Sin(time * 0.001 * m_BlinkingSpeed); // Oscillate the multiplier overtime (time normalized to sec)
 multiplier = (multiplier + 1)/2; // Normalized the value to 0-1 
 
 multiplier = Math.Round(multiplier); // Rounding to 0 or 1 to make it blink instantly 
 SetBrightness(m_Brightness * multiplier);
 }
};