BVB Source Codes

CRYENGINE Show VehiclePartLight.cpp Source code

Return Download CRYENGINE: download VehiclePartLight.cpp Source code - Download CRYENGINE Source code - Type:.cpp
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. /*************************************************************************
  4.    -------------------------------------------------------------------------
  5.    $Id$
  6.    $DateTime$
  7.    Description: Implements a light part
  8.  
  9.    -------------------------------------------------------------------------
  10.    History:
  11.    - 24:10:2005: Created by Mathieu Pinard
  12.  
  13. *************************************************************************/
  14. #include "StdAfx.h"
  15.  
  16. #include <CryAnimation/ICryAnimation.h>
  17. #include "IVehicleSystem.h"
  18.  
  19. #include "CryAction.h"
  20. #include "Vehicle.h"
  21. #include "VehicleComponent.h"
  22. #include "VehiclePartBase.h"
  23. #include "VehiclePartLight.h"
  24.  
  25. #define DEFAULT_FLOAT -1.f
  26. #define DEFAULT_INT   -1
  27. #define DEFAULT_VEC3  Vec3(0)
  28.  
  29. BEGIN_SHARED_PARAMS(SVehicleLightParams)
  30.  
  31. SVehicleLightParams() : radius(5.0f),
  32.                               diffuseMult(1.0f),
  33.                               diffuseMult_fp(1.0f),
  34.                               specularMult(1.0f),
  35.                               frustumAngle(45.0f),
  36.                               HDRDynamic(1.0f),
  37.                               animSpeed(1.0f),
  38.                               animPhase(0),
  39.                               diffuse(1.0f, 1.0f, 1.0f),
  40.                               specular(1.0f, 1.0f, 1.0f),
  41.                               style(0),
  42.                               viewDistanceRatio(0),
  43.                               castShadows(0),
  44.                               fakeLight(false),
  45.                               flareFOV(0.0f),
  46.                               falloff(1.0f)
  47. {
  48. }
  49.  
  50. string texture, material, flare;
  51.  
  52. float radius, diffuseMult, diffuseMult_fp, specularMult, frustumAngle, HDRDynamic, animSpeed, flareFOV, falloff;
  53.  
  54. Vec3 diffuse, specular;
  55.  
  56. int style;
  57. int animPhase;
  58. int viewDistanceRatio;
  59. int castShadows;
  60.  
  61. bool fakeLight;
  62.  
  63. END_SHARED_PARAMS
  64.  
  65. DEFINE_SHARED_PARAMS_TYPE_INFO(SVehicleLightParams)
  66.  
  67. namespace
  68. {
  69. SVehicleLightParamsConstPtr LoadVehicleLightParams(ISharedParamsManager* pSharedParamsManager, const char* inputLightType)
  70. {
  71.         const XmlNodeRef lightsRootNode = gEnv->pSystem->LoadXmlFromFile("Scripts/Entities/Vehicles/Lights/DefaultVehicleLights.xml");
  72.  
  73.         IF_UNLIKELY (lightsRootNode == (IXmlNode*)NULL)
  74.                 return SVehicleLightParamsConstPtr();
  75.  
  76.         const XmlNodeRef lightsListNode = lightsRootNode->findChild("Lights");
  77.         IF_UNLIKELY (lightsListNode == (IXmlNode*)NULL)
  78.                 return SVehicleLightParamsConstPtr();
  79.  
  80.         const int numberOfLights = lightsListNode->getChildCount();
  81.  
  82.         for (int i = 0; i < numberOfLights; ++i)
  83.         {
  84.                 const XmlNodeRef lightParamsNode = lightsListNode->getChild(i);
  85.                 assert(lightParamsNode != (IXmlNode*)NULL);
  86.  
  87.                 IF_UNLIKELY (strcmp(lightParamsNode->getTag(), "Light") != 0)
  88.                         continue;
  89.  
  90.                 const char* type = lightParamsNode->getAttr("type");
  91.  
  92.                 if (!pSharedParamsManager->Get(type))
  93.                 {
  94.                         SVehicleLightParams lightParams;
  95.  
  96.                         lightParams.texture = lightParamsNode->getAttr("texture");
  97.                         lightParams.material = lightParamsNode->getAttr("material");
  98.                         lightParams.flare = lightParamsNode->getAttr("flare");
  99.                         if (!lightParamsNode->getAttr("flareFOV", lightParams.flareFOV))
  100.                         {
  101.                                 lightParams.flareFOV = 180.0f;
  102.                         }
  103.  
  104.                         lightParamsNode->getAttr("radius", lightParams.radius);
  105.                         lightParamsNode->getAttr("diffuseMult", lightParams.diffuseMult);
  106.  
  107.                         if (!lightParamsNode->getAttr("diffuseMult_fp", lightParams.diffuseMult_fp))
  108.                         {
  109.                                 lightParams.diffuseMult_fp = lightParams.diffuseMult;
  110.                         }
  111.  
  112.                         lightParamsNode->getAttr("specularMult", lightParams.specularMult);
  113.                         lightParamsNode->getAttr("frustumAngle", lightParams.frustumAngle);
  114.  
  115.                         lightParamsNode->getAttr("diffuse", lightParams.diffuse);
  116.                         lightParamsNode->getAttr("specular", lightParams.specular);
  117.  
  118.                         lightParamsNode->getAttr("HDRDynamic", lightParams.HDRDynamic);
  119.  
  120.                         lightParamsNode->getAttr("animSpeed", lightParams.animSpeed);
  121.                         lightParamsNode->getAttr("animPhase", lightParams.animPhase);
  122.  
  123.                         lightParamsNode->getAttr("style", lightParams.style);
  124.                         lightParamsNode->getAttr("viewDistanceRatio", lightParams.viewDistanceRatio);
  125.                         lightParamsNode->getAttr("castShadows", lightParams.castShadows);
  126.  
  127.                         lightParamsNode->getAttr("fakeLight", lightParams.fakeLight);
  128.                         lightParamsNode->getAttr("falloff", lightParams.falloff);
  129.  
  130.                         SVehicleLightParamsConstPtr pNewVehicleLightParams = CastSharedParamsPtr<SVehicleLightParams>(pSharedParamsManager->Register(type, lightParams));
  131.  
  132.                         if (strcmp(type, inputLightType) == 0)
  133.                         {
  134.                                 return pNewVehicleLightParams;
  135.                         }
  136.                 }
  137.         }
  138.  
  139.         return SVehicleLightParamsConstPtr();
  140. }
  141.  
  142. };
  143.  
  144. //------------------------------------------------------------------------
  145. CVehiclePartLight::CVehiclePartLight()
  146. {
  147.         m_lightViewDistanceRatio = 0;
  148.         m_pMaterial = 0;
  149.         m_pHelper = 0;
  150.  
  151.         m_diffuseMult[0] = m_diffuseMult[1] = 1.f;
  152.         m_diffuseCol.Set(1, 1, 1);
  153.         m_enabled = false;
  154. }
  155.  
  156. //------------------------------------------------------------------------
  157. CVehiclePartLight::~CVehiclePartLight()
  158. {
  159.         ToggleLight(false);
  160. }
  161.  
  162. //------------------------------------------------------------------------
  163. bool CVehiclePartLight::Init(IVehicle* pVehicle, const CVehicleParams& table, IVehiclePart* parent, CVehicle::SPartInitInfo& initInfo, int partType)
  164. {
  165.         if (!CVehiclePartBase::Init(pVehicle, table, parent, initInfo, eVPT_Light))
  166.                 return false;
  167.  
  168.         float specularMul = 1.0f;
  169.  
  170.         m_light.m_nLightStyle = 0;
  171.         m_light.SetPosition(Vec3(ZERO));
  172.         m_light.m_fRadius = 5.0f;
  173.  
  174.         m_light.m_Flags |= DLF_DEFERRED_LIGHT;
  175.         m_light.m_Flags &= ~DLF_DISABLED;
  176.  
  177.         if (CVehicleParams lightTable = table.findChild("Light"))
  178.         {
  179.                 m_lightType = lightTable.getAttr("type");
  180.  
  181.                 ISharedParamsManager* pSharedParamsManager = CCryAction::GetCryAction()->GetISharedParamsManager();
  182.  
  183.                 CRY_ASSERT(pSharedParamsManager);
  184.  
  185.                 SVehicleLightParamsConstPtr pVehicleLightParams = CastSharedParamsPtr<SVehicleLightParams>(pSharedParamsManager->Get(m_lightType.c_str()));
  186.  
  187.                 if (!pVehicleLightParams)
  188.                 {
  189.                         pVehicleLightParams = LoadVehicleLightParams(pSharedParamsManager, m_lightType.c_str());
  190.                 }
  191.  
  192.                 if (pVehicleLightParams)
  193.                 {
  194.                         m_light.m_fRadius = pVehicleLightParams->radius;
  195.                         m_diffuseCol = pVehicleLightParams->diffuse;
  196.                         m_diffuseMult[1] = pVehicleLightParams->diffuseMult;
  197.                         m_diffuseMult[0] = pVehicleLightParams->diffuseMult_fp;
  198.                         specularMul = pVehicleLightParams->specularMult;
  199.  
  200.                         m_light.m_nLightStyle = pVehicleLightParams->style;
  201.                         m_light.m_fLightFrustumAngle = pVehicleLightParams->frustumAngle;
  202.                         m_light.m_fHDRDynamic = pVehicleLightParams->HDRDynamic;
  203.                         m_light.m_nLightPhase = pVehicleLightParams->animPhase;
  204.  
  205.                         m_light.SetAnimSpeed(pVehicleLightParams->animSpeed);
  206.                         m_light.SetFalloffMax(pVehicleLightParams->falloff);
  207.  
  208.                         m_lightViewDistanceRatio = pVehicleLightParams->viewDistanceRatio;
  209.  
  210.                         if (pVehicleLightParams->castShadows > 0)
  211.                         {
  212.                                 const ICVar* pLightSpec = gEnv->pConsole->GetCVar("sys_spec_light");
  213.                                 int configSpec = (pLightSpec != NULL) ? pLightSpec->GetIVal() : gEnv->pSystem->GetConfigSpec(true);
  214.  
  215.                                 // Treating consoles and custom as med spec for simplicity
  216.                                 if (configSpec == CONFIG_CUSTOM)
  217.                                 {
  218.                                         configSpec = CONFIG_MEDIUM_SPEC;
  219.                                 }
  220.  
  221.                                 if (pVehicleLightParams->castShadows <= configSpec)
  222.                                 {
  223.                                         m_light.m_Flags |= DLF_CASTSHADOW_MAPS;
  224.                                 }
  225.                         }
  226.  
  227.                         m_light.m_Flags = pVehicleLightParams->fakeLight ? m_light.m_Flags | DLF_FAKE : m_light.m_Flags & ~DLF_FAKE;
  228.  
  229.                         if (pVehicleLightParams->texture.empty() == false && gEnv->pRenderer)
  230.                         {
  231.                                 m_light.m_pLightImage = gEnv->pRenderer->EF_LoadTexture(pVehicleLightParams->texture.c_str(), FT_DONT_STREAM);
  232.                         }
  233.  
  234.                         if (pVehicleLightParams->material.empty() == false)
  235.                         {
  236.                                 m_pMaterial = gEnv->p3DEngine->GetMaterialManager()->LoadMaterial(pVehicleLightParams->material.c_str());
  237.                         }
  238.  
  239.                         if (pVehicleLightParams->flare.empty() == false && gEnv->pRenderer)
  240.                         {
  241.                                 int lensOpticsID = 0;
  242.                                 if (gEnv->pOpticsManager->Load(pVehicleLightParams->flare.c_str(), lensOpticsID))
  243.                                 {
  244.                                         m_light.SetLensOpticsElement(gEnv->pOpticsManager->GetOptics(lensOpticsID));
  245.  
  246.                                         int modularAngle = ((int)pVehicleLightParams->flareFOV) % 360;
  247.                                         if (modularAngle == 0)
  248.                                                 m_light.m_LensOpticsFrustumAngle = 255;
  249.                                         else
  250.                                                 m_light.m_LensOpticsFrustumAngle = (uint8)(pVehicleLightParams->flareFOV * (255.0f / 360.0f));
  251.                                 }
  252.  
  253.                                 if (m_pMaterial == NULL)
  254.                                 {
  255.                                         GameWarning("VehiclePartLight - Light uses flares, but it does not have a material. Flares won't work");
  256.                                 }
  257.                         }
  258.  
  259.                 }
  260.         }
  261.  
  262.         m_light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[1], 1.f));
  263.         m_light.SetSpecularMult(specularMul / m_diffuseMult[1]);
  264.  
  265.         if (m_light.m_fLightFrustumAngle && m_light.m_pLightImage && m_light.m_pLightImage->IsTextureLoaded())
  266.         {
  267.                 m_light.m_Flags |= DLF_PROJECT;
  268.         }
  269.         else
  270.         {
  271.                 if (m_light.m_pLightImage)
  272.                 {
  273.                         m_light.m_pLightImage->Release();
  274.                         m_light.m_pLightImage = 0;
  275.                 }
  276.                 m_light.m_Flags |= DLF_POINT;
  277.         }
  278.  
  279.         return true;
  280. }
  281.  
  282. //------------------------------------------------------------------------
  283. void CVehiclePartLight::PostInit()
  284. {
  285.         m_pHelper = m_pVehicle->GetHelper(m_pSharedParameters->m_helperPosName.c_str());
  286.  
  287.         // get Components this Part belongs to.
  288.         // currently that's only needed for Lights.
  289.         for (int i = 0, nComps = m_pVehicle->GetComponentCount(); i < nComps; ++i)
  290.         {
  291.                 IVehicleComponent* pComponent = m_pVehicle->GetComponent(i);
  292.  
  293.                 for (int j = 0, nParts = pComponent->GetPartCount(); j < nParts; ++j)
  294.                 {
  295.                         if (pComponent->GetPart(j) == this)
  296.                         {
  297.                                 m_components.push_back(pComponent);
  298.                                 break;
  299.                         }
  300.                 }
  301.         }
  302.  
  303.         if (VehicleCVars().v_lights_enable_always)
  304.                 ToggleLight(true);
  305. }
  306.  
  307. //------------------------------------------------------------------------
  308. void CVehiclePartLight::Reset()
  309. {
  310.         CVehiclePartBase::Reset();
  311.  
  312.         ToggleLight(false);
  313. }
  314.  
  315. //------------------------------------------------------------------------
  316. void CVehiclePartLight::OnEvent(const SVehiclePartEvent& event)
  317. {
  318.         if (event.type == eVPE_Damaged)
  319.         {
  320.                 if (event.fparam >= 1.0f)
  321.                 {
  322.                         float dmg = 1.f / max(1.f, (float)m_components.size());
  323.                         m_damageRatio += dmg;
  324.  
  325.                         if (m_damageRatio >= 1.f && IsEnabled())
  326.                                 ToggleLight(false);
  327.                 }
  328.         }
  329.         else
  330.         {
  331.                 CVehiclePartBase::OnEvent(event);
  332.         }
  333. }
  334.  
  335. //------------------------------------------------------------------------
  336. void CVehiclePartLight::ToggleLight(bool enable)
  337. {
  338.         if (enable && !IsEnabled())
  339.         {
  340.                 // 0: no lights at all (only intended for debugging etc.)
  341.                 // 1: lights only enabled for the local player
  342.                 // 2: all lights enabled
  343.                 if (VehicleCVars().v_lights == 0
  344.                     || (VehicleCVars().v_lights == 1 && !m_pVehicle->IsPlayerPassenger()))
  345.                         return;
  346.  
  347.                 if (m_pHelper && m_damageRatio < 1.0f)
  348.                 {
  349.                         m_slot = GetEntity()->LoadLight(m_slot, &m_light);
  350.  
  351.                         if (m_slot != -1)
  352.                         {
  353.                                 if (m_pMaterial)
  354.                                 {
  355.                                         GetEntity()->SetSlotMaterial(m_slot, m_pMaterial);
  356.                                 }
  357.  
  358.                                 if (m_lightViewDistanceRatio > 0)
  359.                                 {
  360.                                         SEntitySlotInfo slotInfo;
  361.                                         if (GetEntity()->GetSlotInfo(m_slot, slotInfo) && (slotInfo.pLight != NULL))
  362.                                         {
  363.                                                 slotInfo.pLight->SetViewDistRatio(m_lightViewDistanceRatio);
  364.                                         }
  365.                                 }
  366.                         }
  367.  
  368.                         UpdateLight(0.f);
  369.                 }
  370.  
  371.                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_Visible);
  372.                 m_enabled = true;
  373.         }
  374.         else if (!enable)
  375.         {
  376.                 if (m_slot != -1)
  377.                 {
  378.                         GetEntity()->FreeSlot(m_slot);
  379.                         m_slot = -1;
  380.                 }
  381.  
  382.                 m_pVehicle->SetObjectUpdate(this, IVehicle::eVOU_NoUpdate);
  383.                 m_enabled = false;
  384.         }
  385.  
  386. }
  387.  
  388. //-----------------------------------------------------------------------
  389. void CVehiclePartLight::Update(const float frameTime)
  390. {
  391.         if (IsEnabled())
  392.                 UpdateLight(frameTime);
  393. }
  394.  
  395. //-----------------------------------------------------------------------
  396. void CVehiclePartLight::UpdateLight(const float frameTime)
  397. {
  398.         if (m_slot == -1)
  399.                 return;
  400.  
  401.         // move to vehicle event change view?
  402.         if (m_diffuseMult[0] != m_diffuseMult[1])
  403.         {
  404.                 SEntitySlotInfo info;
  405.                 if (m_pVehicle->GetEntity()->GetSlotInfo(m_slot, info) && info.pLight)
  406.                 {
  407.                         CDLight& light = info.pLight->GetLightProperties();
  408.  
  409.                         IActor* pActor = CCryAction::GetCryAction()->GetClientActor();
  410.                         bool localPlayer = (pActor != NULL) && (pActor->GetLinkedVehicle() == m_pVehicle);
  411.  
  412.                         IVehicleSeat* pSeat = pActor ? m_pVehicle->GetSeatForPassenger(pActor->GetEntityId()) : NULL;
  413.                         IVehicleView* pView = pSeat ? pSeat->GetCurrentView() : NULL;
  414.                         bool isThirdPersonView = pView ? pView->IsThirdPerson() : true;
  415.                         if (localPlayer && !isThirdPersonView)
  416.                                 light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[0], 1.f));
  417.                         else
  418.                                 light.SetLightColor(ColorF(m_diffuseCol * m_diffuseMult[1], 1.f));
  419.                 }
  420.         }
  421.  
  422.         if (m_pHelper)
  423.         {
  424.                 const static Matrix33 rot(Matrix33::CreateRotationXYZ(Ang3(0.f, 0.f, DEG2RAD(90.f))));
  425.  
  426.                 Matrix34 helperTM;
  427.                 m_pHelper->GetVehicleTM(helperTM);
  428.                 Matrix34 localTM = Matrix33(helperTM) * rot;
  429.                 localTM.SetTranslation(helperTM.GetTranslation());
  430.  
  431.                 GetEntity()->SetSlotLocalTM(m_slot, localTM);
  432.         }
  433.  
  434. }
  435.  
  436. //------------------------------------------------------------------------
  437. void CVehiclePartLight::Serialize(TSerialize ser, EEntityAspects aspects)
  438. {
  439.         CVehiclePartBase::Serialize(ser, aspects);
  440.  
  441.         if (ser.GetSerializationTarget() != eST_Network)
  442.         {
  443.                 bool isEnabled = IsEnabled();
  444.                 ser.Value("lightEnabled", isEnabled, 'bool');
  445.  
  446.                 if (ser.IsReading())
  447.                 {
  448.                         ToggleLight(isEnabled);
  449.                 }
  450.         }
  451. }
  452.  
  453. DEFINE_VEHICLEOBJECT(CVehiclePartLight);
  454.  
downloadVehiclePartLight.cpp Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top