itemoptics.c

Go to the documentation of this file.

class ItemOptics extends InventoryItemSuper
{
 bool m_data_set;
 bool m_allowsDOF; //true if optics DOES NOT have magnification (FOV >= DZPLAYER_CAMERA_FOV_IRONSIGHTS)
 bool m_reddot_displayed
 bool m_isNVOptic = false;
 int m_CurrentOpticMode; //generic optic mode, currently used for NV optics only (could be expanded)
 int m_CurrentOpticModeLocal; //local mirror for sync purposes;
 int m_reddot_index;
 float m_blur_float;
 float m_nearplane_override; //override value for DayZPlayerCameraOptics only!
 string m_optic_sight_texture;
 string m_optic_sight_material;
 string m_2D_preload_type;
 ref array<float> m_mask_array;
 ref array<float> m_lens_array;
 ref array<float> m_OpticsDOFProperties;
 
 void ItemOptics()
 {
 m_mask_array = new array<float>;
 m_lens_array = new array<float>;
 m_OpticsDOFProperties = new array<float>;
 
 InitReddotData();
 InitOpticsPPInfo();
 InitCameraOverrideProperties();
 InitOpticsDOFProperties(m_OpticsDOFProperties);
 Init2DPreloadType();
 InitOpticMode();
 
 m_CurrentOpticModeLocal = -1;
 RegisterNetSyncVariableInt( "m_CurrentOpticMode", 0, 63 );
 }
 
 proto native bool EnterOptics ();
 
 proto native bool IsInOptics ();
 
 proto native bool ExitOptics ();
 
 proto native bool HasWeaponIronsightsOverride ();
 
 proto native bool UseWeaponIronsightsOverride(bool state);
 
 proto native bool IsUsingWeaponIronsightsOverride();
 
 proto native int GetStepFOVCount ();
 
 proto native int GetStepFOVIndex ();
 
 proto native bool SetStepFOVIndex (int step);
 
 proto native bool StepFOVUp ();
 
 proto native bool StepFOVDown ();
 
 proto native float GetCurrentStepFOV ();
 
 proto native int GetStepZeroing ();
 
 proto native bool SetStepZeroing (int step);
 
 proto native bool StepZeroingUp ();
 
 proto native bool StepZeroingDown ();
 
 proto native void GetCameraPoint (out vector pos, out vector dir);
 
 proto native float GetZoomInit();
 
 proto native float GetZoomMin();
 
 proto native float GetZoomMax();
 
 proto native float GetZeroingDistanceZoomMin();
 
 proto native float GetZeroingDistanceZoomMax();
 
 proto native void SetZeroingClampDist(float dist);
 
 override void OnWorkStart()
 {
 if (!GetGame().IsDedicatedServer())
 {
 ShowReddot(true);
 }
 }
 
 override void OnWorkStop()
 {
 if (!GetGame().IsDedicatedServer())
 {
 ShowReddot(false);
 }
 }
 
 bool IsWorking()
 {
 if (GetCompEM() && GetCompEM().CanWork())
 return true;
 return false;
 }
 
 void UpdateOpticsReddotVisibility()
 {
 if (IsWorking() && !m_reddot_displayed)
 {
 ShowReddot(true);
 }
 else if (!IsWorking() && m_reddot_displayed)
 {
 ShowReddot(false);
 }
 }
 
 override void OnWasAttached( EntityAI parent, int slot_id )
 {
 super.OnWasAttached(parent, slot_id);
 
 SetTakeable(false);
 
 Weapon wep;
 if (Class.CastTo(wep,parent))
 {
 SetZeroingClampDist(wep.GetZeroingClamp(wep.GetCurrentMuzzle()));
 }
 }
 
 override void OnWasDetached( EntityAI parent, int slot_id )
 {
 super.OnWasDetached(parent, slot_id);
 
 PlayerBase player;
 if (PlayerBase.CastTo(player, GetHierarchyRootPlayer()))
 {
 player.SetReturnToOptics(false);
 }
 
 SetTakeable(true);
 
 Weapon wep;
 if (Class.CastTo(wep,parent))
 {
 SetZeroingClampDist(0.0);
 }
 }
 
 override void OnInventoryExit(Man player)
 {
 super.OnInventoryExit(player);
 
 PlayerBase playerPB;
 if (PlayerBase.CastTo(playerPB, player))
 {
 playerPB.SetReturnToOptics(false);
 }
 
 SetTakeable(true);
 }
 
 override void OnStoreSave(ParamsWriteContext ctx)
 {
 super.OnStoreSave(ctx);
 
 ctx.Write(m_CurrentOpticMode);
 }
 
 override bool OnStoreLoad(ParamsReadContext ctx, int version)
 {
 if ( !super.OnStoreLoad(ctx,version) )
 {
 return false;
 }
 m_IsStoreLoad = true;
 
 if ( version >= 126 )
 {
 if ( !ctx.Read(m_CurrentOpticMode) )
 {
 m_IsStoreLoad = false;
 return false;
 }
 }
 
 OnOpticModeChange();
 SetSynchDirty();
 
 m_IsStoreLoad = false;
 return true;
 }
 
 override void OnVariablesSynchronized()
 {
 super.OnVariablesSynchronized();
 
 if (m_CurrentOpticModeLocal != m_CurrentOpticMode)
 {
 OnOpticModeChange();
 m_CurrentOpticModeLocal = m_CurrentOpticMode;
 }
 } 
 
 void InitReddotData()
 {
 string path = "cfgVehicles " + GetType() + " OpticsInfo";
 string temp;
 
 if (GetGame().ConfigIsExisting(path))
 {
 m_reddot_index = GetHiddenSelectionIndex("reddot");
 if (GetGame().ConfigIsExisting(path + " opticSightTexture"))
 {
 GetGame().ConfigGetText(path + " opticSightTexture", temp);
 m_optic_sight_texture = temp;
 temp = "";
 }
 if (GetGame().ConfigIsExisting(path + " opticSightMaterial"))
 {
 GetGame().ConfigGetText(path + " opticSightMaterial", temp);
 m_optic_sight_material = temp;
 temp = "";
 }
 }
 m_data_set = true;
 }
 
 void ShowReddot(bool state)
 {
 if (GetGame().IsDedicatedServer())
 {
 ErrorEx("should not be called on the server!",ErrorExSeverity.INFO);
 return;
 }
 
 if (!m_data_set)
 {
 InitReddotData();
 }
 
 // does not have reddot
 if (m_reddot_index == -1)
 {
 return;
 }
 
 if (state)
 {
 if (m_optic_sight_texture != "")
 SetObjectTexture(m_reddot_index, m_optic_sight_texture);
 if (m_optic_sight_material != "")
 SetObjectMaterial(m_reddot_index, m_optic_sight_material);
 }
 else
 {
 SetObjectTexture(m_reddot_index, "");
 SetObjectMaterial(m_reddot_index, "");
 }
 m_reddot_displayed = state;
 }
 
 void InitOpticsPPInfo()
 {
 m_allowsDOF = InitDOFAvailability();
 InitOpticsPP(m_mask_array, m_lens_array, m_blur_float);
 
 m_isNVOptic = ConfigGetBool("NVOptic");
 }
 
 bool InitDOFAvailability()
 {
 float fov_max;
 string path = "cfgVehicles " + GetType() + " OpticsInfo";
 
 /*
 Weapon_Base weapon = Weapon_Base.Cast(GetHierarchyParent());
 if (!weapon)
 return false; // no DOF for handheld optics
 */
 fov_max = GetGame().ConfigGetFloat(path + " opticsZoomMax");
 if (fov_max >= GameConstants.DZPLAYER_CAMERA_FOV_IRONSIGHTS)
 {
 return true;
 }
 return false;
 }
 
 void InitOpticsPP(out array<float> mask_array, out array<float> lens_array, out float blur_float)
 {
 string path = "cfgVehicles " + GetType() + " OpticsInfo";
 GetGame().ConfigGetFloatArray(path + " PPMaskProperties", mask_array);
 GetGame().ConfigGetFloatArray(path + " PPLensProperties", lens_array);
 blur_float = GetGame().ConfigGetFloat(path + " PPBlurProperties");
 }
 
 void InitCameraOverrideProperties()
 {
 string path = "cfgVehicles " + GetType() + " OpticsInfo";
 if ( GetGame().ConfigIsExisting(path + " nearPlaneDistanceOverride") )
 {
 m_nearplane_override = Math.Max(GetGame().ConfigGetFloat(path + " nearPlaneDistanceOverride"),DayZPlayerCameraBase.CONST_NEARPLANE_OPTICS_MIN);
 }
 else
 {
 m_nearplane_override = DayZPlayerCameraOptics.CONST_NEARPLANE_OPTICS;
 }
 }
 
 bool InitOpticsDOFProperties (out array<float> temp_array)
 {
 if (GetGame().ConfigIsExisting("cfgVehicles " + GetType() + " OpticsInfo PPDOFProperties"))
 {
 GetGame().ConfigGetFloatArray("cfgVehicles " + GetType() + " OpticsInfo PPDOFProperties", temp_array);
 return true;
 }
 else if (GetGame().ConfigIsExisting("cfgVehicles " + GetType() + " OpticsInfoWeaponOverride PPDOFProperties"))
 {
 GetGame().ConfigGetFloatArray("cfgVehicles " + GetType() + " OpticsInfoWeaponOverride PPDOFProperties", temp_array);
 return true;
 }
 return false;
 }
 
 bool AllowsDOF()
 {
 return m_allowsDOF;
 }
 
 bool IsNVOptic()
 {
 return m_isNVOptic;
 }
 
 int GetCurrentNVType()
 {
 /*
 //TODO - implement this into NV optics and modify (KazuarOptic example below)
 if (IsWorking())
 {
 switch (m_CurrentOpticMode)
 {
 case GameConstants.OPTICS_STATE_DAY:
 return NVTypes.NV_OPTICS_KAZUAR_DAY;
 
 case GameConstants.OPTICS_STATE_NIGHTVISION:
 return NVTypes.NV_OPTICS_KAZUAR_NIGHT;
 }
 }
 else
 {
 return NVTypes.NV_OPTICS_OFF;
 }
 */
 return NVTypes.NONE;
 }
 
 void SetCurrentOpticMode(int mode)
 {
 m_CurrentOpticMode = mode;
 OnOpticModeChange();
 }
 
 int GetCurrentOpticMode()
 {
 return m_CurrentOpticMode;
 }
 
 void OnOpticModeChange(){}
 void OnOpticEnter()
 {
 if ( GetGame() && !GetGame().IsDedicatedServer() )
 {
 HideSelection("hide");
 }
 }
 void OnOpticExit()
 {
 if ( GetGame() && !GetGame().IsDedicatedServer() )
 {
 ShowSelection("hide");
 }
 }
 
 ref array<float> GetOpticsDOF()
 {
 return m_OpticsDOFProperties;
 }
 ref array<float> GetOpticsPPMask()
 {
 return m_mask_array;
 }
 ref array<float> GetOpticsPPLens()
 {
 return m_lens_array;
 }
 float GetOpticsPPBlur()
 {
 return m_blur_float;
 }
 
 float GetNearPlaneValue()
 {
 return m_nearplane_override;
 }
 
 void Init2DPreloadType()
 {
 string path = "cfgVehicles " + GetType() + " OpticsInfo preloadOpticType";
 string type_2d;
 
 if ( GetGame().ConfigIsExisting(path) )
 {
 GetGame().ConfigGetText(path, type_2d);
 m_2D_preload_type = type_2d;
 }
 }
 
 void InitOpticMode()
 {
 SetCurrentOpticMode(GameConstants.OPTICS_STATE_DAY);
 }
 
 void UpdateSelectionVisibility() {}
 
 override void SetActions()
 {
 super.SetActions();
 
 AddAction(ActionViewOptics);
 }
 
 override void OnDebugSpawn()
 {
 GetInventory().CreateAttachment("Battery9V");
 }
}
 
typedef ItemOptics OpticBase;