BVB Source Codes

CRYENGINE Show ViewSystem.cpp Source code

Return Download CRYENGINE: download ViewSystem.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.  
  8.    -------------------------------------------------------------------------
  9.    History:
  10.    - 17:9:2004 : Created by Filippo De Luca
  11.     24:11:2005: added movie system (Craig Tiller)
  12. *************************************************************************/
  13. #include "StdAfx.h"
  14.  
  15. #include <CryMath/Cry_Camera.h>
  16. #include <ILevelSystem.h>
  17. #include "ViewSystem.h"
  18. #include "GameObjects/GameObject.h"
  19. #include "CryAction.h"
  20. #include "IActorSystem.h"
  21. #include <CryMath/PNoise3.h>
  22. #include <CryAISystem/IAISystem.h>
  23.  
  24. #define VS_CALL_LISTENERS(func)                                                                               \
  25.   {                                                                                                           \
  26.     size_t count = m_listeners.size();                                                                        \
  27.     if (count > 0)                                                                                            \
  28.     {                                                                                                         \
  29.       const size_t memSize = count * sizeof(IViewSystemListener*);                                            \
  30.       PREFAST_SUPPRESS_WARNING(6255) IViewSystemListener * *pArray = (IViewSystemListener**) alloca(memSize); \
  31.       memcpy(pArray, &*m_listeners.begin(), memSize);                                                         \
  32.       while (count--)                                                                                         \
  33.       {                                                                                                       \
  34.         (*pArray)->func; ++pArray;                                                                            \
  35.       }                                                                                                       \
  36.     }                                                                                                         \
  37.   }
  38.  
  39. //------------------------------------------------------------------------
  40. CViewSystem::CViewSystem(ISystem* const pSystem) :
  41.         m_pSystem(pSystem),
  42.         m_activeViewId(0),
  43.         m_nextViewIdToAssign(1000),
  44.         m_preSequenceViewId(0),
  45.         m_cutsceneViewId(0),
  46.         m_cutsceneCount(0),
  47.         m_bOverridenCameraRotation(false),
  48.         m_bActiveViewFromSequence(false),
  49.         m_fBlendInPosSpeed(0.0f),
  50.         m_fBlendInRotSpeed(0.0f),
  51.         m_bPerformBlendOut(false),
  52.         m_useDeferredViewSystemUpdate(false),
  53.         m_bControlsAudioListeners(true)
  54. {
  55.         REGISTER_CVAR2("cl_camera_noise", &m_fCameraNoise, -1, 0,
  56.                        "Adds hand-held like camera noise to the camera view. \n The higher the value, the higher the noise.\n A value <= 0 disables it.");
  57.         REGISTER_CVAR2("cl_camera_noise_freq", &m_fCameraNoiseFrequency, 2.5326173f, 0,
  58.                        "Defines camera noise frequency for the camera view. \n The higher the value, the higher the noise.");
  59.  
  60.         REGISTER_CVAR2("cl_ViewSystemDebug", &m_nViewSystemDebug, 0, VF_CHEAT,
  61.                        "Sets Debug information of the ViewSystem.");
  62.  
  63.         REGISTER_CVAR2("cl_DefaultNearPlane", &m_fDefaultCameraNearZ, DEFAULT_NEAR, 0,
  64.                 "The default camera near plane. ");
  65.  
  66.         REGISTER_CVAR2("cl_ViewApplyHmdOffset", &m_bApplyHmdOffset, 1, 0,
  67.                 "Enables default engine HMD positional / rotational offset");
  68.  
  69.         //Register as level system listener
  70.         if (CCryAction::GetCryAction()->GetILevelSystem())
  71.                 CCryAction::GetCryAction()->GetILevelSystem()->AddListener(this);
  72. }
  73.  
  74. //------------------------------------------------------------------------
  75. CViewSystem::~CViewSystem()
  76. {
  77.         ClearAllViews();
  78.  
  79.         IConsole* pConsole = gEnv->pConsole;
  80.         CRY_ASSERT(pConsole);
  81.         pConsole->UnregisterVariable("cl_camera_noise", true);
  82.         pConsole->UnregisterVariable("cl_camera_noise_freq", true);
  83.         pConsole->UnregisterVariable("cl_ViewSystemDebug", true);
  84.         pConsole->UnregisterVariable("cl_DefaultNearPlane", true);
  85.  
  86.         //Remove as level system listener
  87.         if (CCryAction::GetCryAction()->GetILevelSystem())
  88.                 CCryAction::GetCryAction()->GetILevelSystem()->RemoveListener(this);
  89. }
  90.  
  91. //------------------------------------------------------------------------
  92. void CViewSystem::Update(float frameTime)
  93. {
  94.         FUNCTION_PROFILER(GetISystem(), PROFILE_ACTION);
  95.  
  96.         if (gEnv->IsDedicated())
  97.                 return;
  98.  
  99.         CView* const __restrict pActiveView = static_cast<CView*>(GetActiveView());
  100.  
  101.         TViewMap::const_iterator Iter(m_views.begin());
  102.         TViewMap::const_iterator const IterEnd(m_views.end());
  103.  
  104.         for (; Iter != IterEnd; ++Iter)
  105.         {
  106.                 CView* const __restrict pView = Iter->second;
  107.  
  108.                 bool const bIsActive = (pView == pActiveView);
  109.  
  110.                 pView->Update(frameTime, bIsActive);
  111.  
  112.                 if (bIsActive)
  113.                 {
  114.                         CCamera& rCamera = pView->GetCamera();
  115.                         pView->UpdateAudioListener(rCamera.GetMatrix());
  116.                         SViewParams currentParams = *(pView->GetCurrentParams());
  117.  
  118.                         rCamera.SetJustActivated(currentParams.justActivated);
  119.  
  120.                         currentParams.justActivated = false;
  121.                         pView->SetCurrentParams(currentParams);
  122.  
  123.                         if (m_bOverridenCameraRotation)
  124.                         {
  125.                                 // When camera rotation is overridden.
  126.                                 Vec3 pos = rCamera.GetMatrix().GetTranslation();
  127.                                 Matrix34 camTM(m_overridenCameraRotation);
  128.                                 camTM.SetTranslation(pos);
  129.                                 rCamera.SetMatrix(camTM);
  130.                         }
  131.                         else
  132.                         {
  133.                                 // Normal setting of the camera
  134.  
  135.                                 if (m_fCameraNoise > 0)
  136.                                 {
  137.                                         Matrix33 m = Matrix33(rCamera.GetMatrix());
  138.                                         m.OrthonormalizeFast();
  139.                                         Ang3 aAng1 = Ang3::GetAnglesXYZ(m);
  140.                                         //Ang3 aAng2 = RAD2DEG(aAng1);
  141.  
  142.                                         Matrix34 camTM = rCamera.GetMatrix();
  143.                                         Vec3 pos = camTM.GetTranslation();
  144.                                         camTM.SetIdentity();
  145.  
  146.                                         const float fScale = 0.1f;
  147.                                         CPNoise3* pNoise = m_pSystem->GetNoiseGen();
  148.                                         float fRes = pNoise->Noise1D(gEnv->pTimer->GetCurrTime() * m_fCameraNoiseFrequency);
  149.                                         aAng1.x += fRes * m_fCameraNoise * fScale;
  150.                                         pos.z -= fRes * m_fCameraNoise * fScale;
  151.                                         fRes = pNoise->Noise1D(17 + gEnv->pTimer->GetCurrTime() * m_fCameraNoiseFrequency);
  152.                                         aAng1.y -= fRes * m_fCameraNoise * fScale;
  153.  
  154.                                         //aAng1.z+=fRes*0.025f; // left / right movement should be much less visible
  155.  
  156.                                         camTM.SetRotationXYZ(aAng1);
  157.                                         camTM.SetTranslation(pos);
  158.                                         rCamera.SetMatrix(camTM);
  159.                                 }
  160.                         }
  161.  
  162.                         m_pSystem->SetViewCamera(rCamera);
  163.                 }
  164.         }
  165.  
  166.         // Display debug info on screen
  167.         if (m_nViewSystemDebug)
  168.         {
  169.                 DebugDraw();
  170.         }
  171.  
  172.         // perform dynamic color grading
  173.         // Beni - Commented for console demo stuff
  174.         /******************************************************************************************
  175.            if (!IsPlayingCutScene() && gEnv->pAISystem)
  176.            {
  177.            SAIDetectionLevels detection;
  178.            gEnv->pAISystem->GetDetectionLevels(nullptr, detection);
  179.            float factor = detection.puppetThreat;
  180.  
  181.            // marcok: magic numbers taken from Maciej's tweaked values (final - initial)
  182.            {
  183.             float percentage = (0.0851411f - 0.0509998f)/0.0509998f * factor;
  184.             float amount = 0.0f;
  185.             gEnv->p3DEngine->GetPostEffectParam("ColorGrading_GrainAmount", amount);
  186.             gEnv->p3DEngine->SetPostEffectParam("ColorGrading_GrainAmount_Offset", amount*percentage);
  187.            }
  188.            {
  189.             float percentage = (0.405521f - 0.256739f)/0.256739f * factor;
  190.             float amount = 0.0f;
  191.             gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SharpenAmount", amount);
  192.             //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SharpenAmount_Offset", amount*percentage);
  193.            }
  194.            {
  195.             float percentage = (0.14f - 0.11f)/0.11f * factor;
  196.             float amount = 0.0f;
  197.             gEnv->p3DEngine->GetPostEffectParam("ColorGrading_PhotoFilterColorDensity", amount);
  198.             gEnv->p3DEngine->SetPostEffectParam("ColorGrading_PhotoFilterColorDensity_Offset", amount*percentage);
  199.            }
  200.            {
  201.             float percentage = (234.984f - 244.983f)/244.983f * factor;
  202.             float amount = 0.0f;
  203.             gEnv->p3DEngine->GetPostEffectParam("ColorGrading_maxInput", amount);
  204.             //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_maxInput_Offset", amount*percentage);
  205.            }
  206.            {
  207.             float percentage = (239.984f - 247.209f)/247.209f * factor;
  208.             float amount = 0.0f;
  209.             gEnv->p3DEngine->GetPostEffectParam("ColorGrading_maxOutput", amount);
  210.             //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_maxOutput_Offset", amount*percentage);
  211.            }
  212.            {
  213.             Vec4 dest(0.0f/255.0f, 22.0f/255.0f, 33.0f/255.0f, 1.0f);
  214.             Vec4 initial(2.0f/255.0f, 154.0f/255.0f, 226.0f/255.0f, 1.0f);
  215.             Vec4 percentage = (dest - initial)/initial * factor;
  216.             Vec4 amount;
  217.             gEnv->p3DEngine->GetPostEffectParamVec4("clr_ColorGrading_SelectiveColor", amount);
  218.             //gEnv->p3DEngine->SetPostEffectParamVec4("clr_ColorGrading_SelectiveColor_Offset", amount*percentage);
  219.            }
  220.            {
  221.             float percentage = (-5.0083 - -1.99999)/-1.99999 * factor;
  222.             float amount = 0.0f;
  223.             gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorCyans", amount);
  224.             //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorCyans_Offset", amount*percentage);
  225.            }
  226.            {
  227.             float percentage = (10.0166 - -5.99999)/-5.99999 * factor;
  228.             float amount = 0.0f;
  229.             gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorMagentas", amount);
  230.             //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorMagentas_Offset", amount*percentage);
  231.            }
  232.            {
  233.             float percentage = (10.0166 - 1.99999)/1.99999 * factor;
  234.             float amount = 0.0f;
  235.             gEnv->p3DEngine->GetPostEffectParam("ColorGrading_SelectiveColorYellows", amount);
  236.             //gEnv->p3DEngine->SetPostEffectParam("ColorGrading_SelectiveColorYellows_Offset", amount*percentage);
  237.            }
  238.            }
  239.          ********************************************************************************************/
  240. }
  241.  
  242. //------------------------------------------------------------------------
  243. IView* CViewSystem::CreateView()
  244. {
  245.         CView* newView = new CView(m_pSystem);
  246.  
  247.         if (newView)
  248.         {
  249.                 m_views.insert(TViewMap::value_type(m_nextViewIdToAssign, newView));
  250.                 if (IsPlayingCutScene())
  251.                 {
  252.                         m_cutsceneViewIdVector.push_back(m_nextViewIdToAssign);
  253.                 }
  254.                 ++m_nextViewIdToAssign;
  255.         }
  256.  
  257.         return newView;
  258. }
  259.  
  260. void CViewSystem::RemoveView(IView* pView)
  261. {
  262.         RemoveViewById(GetViewId(pView));
  263. }
  264.  
  265. void CViewSystem::RemoveView(unsigned int viewId)
  266. {
  267.         RemoveViewById(viewId);
  268. }
  269.  
  270. void CViewSystem::RemoveViewById(unsigned int viewId)
  271. {
  272.         TViewMap::iterator iter = m_views.find(viewId);
  273.  
  274.         if (iter != m_views.end())
  275.         {
  276.                 SAFE_RELEASE(iter->second);
  277.                 m_views.erase(iter);
  278.         }
  279. }
  280.  
  281. //------------------------------------------------------------------------
  282. void CViewSystem::SetActiveView(IView* pView)
  283. {
  284.         if (pView != nullptr)
  285.         {
  286.                 IView* const __restrict pPrevView = GetView(m_activeViewId);
  287.  
  288.                 if (pPrevView != pView)
  289.                 {
  290.                         if (pPrevView != nullptr)
  291.                         {
  292.                                 pPrevView->SetActive(false);
  293.                         }
  294.  
  295.                         pView->SetActive(true);
  296.                         m_activeViewId = GetViewId(pView);
  297.                 }
  298.         }
  299.         else
  300.         {
  301.                 m_activeViewId = ~0;
  302.         }
  303.  
  304.         m_bActiveViewFromSequence = false;
  305. }
  306.  
  307. //------------------------------------------------------------------------
  308. void CViewSystem::SetActiveView(unsigned int viewId)
  309. {
  310.         IView* const __restrict pPrevView = GetView(m_activeViewId);
  311.  
  312.         if (pPrevView != nullptr)
  313.         {
  314.                 pPrevView->SetActive(false);
  315.         }
  316.  
  317.         IView* const __restrict pView = GetView(viewId);
  318.  
  319.         if (pView != nullptr)
  320.         {
  321.                 pView->SetActive(true);
  322.                 m_activeViewId = viewId;
  323.                 m_bActiveViewFromSequence = false;
  324.         }
  325. }
  326.  
  327. //------------------------------------------------------------------------
  328. IView* CViewSystem::GetView(unsigned int viewId) const
  329. {
  330.         TViewMap::const_iterator it = m_views.find(viewId);
  331.  
  332.         if (it != m_views.end())
  333.         {
  334.                 return it->second;
  335.         }
  336.  
  337.         return nullptr;
  338. }
  339.  
  340. //------------------------------------------------------------------------
  341. IView* CViewSystem::GetActiveView() const
  342. {
  343.         return GetView(m_activeViewId);
  344. }
  345.  
  346. //------------------------------------------------------------------------
  347. bool CViewSystem::IsClientActorViewActive() const
  348. {
  349.         IView* pActiveView = GetActiveView();
  350.         if (!pActiveView)
  351.         {
  352.                 return true;
  353.         }
  354.         return pActiveView->GetLinkedId() == CCryAction::GetCryAction()->GetClientActorId();
  355. }
  356.  
  357. //------------------------------------------------------------------------
  358. unsigned int CViewSystem::GetViewId(IView* pView) const
  359. {
  360.         for (TViewMap::const_iterator it = m_views.begin(); it != m_views.end(); ++it)
  361.         {
  362.                 IView* tView = it->second;
  363.  
  364.                 if (tView == pView)
  365.                         return it->first;
  366.         }
  367.  
  368.         return 0;
  369. }
  370.  
  371. //------------------------------------------------------------------------
  372. unsigned int CViewSystem::GetActiveViewId() const
  373. {
  374.         // cutscene can override the games id of the active view
  375.         if (m_cutsceneCount && m_cutsceneViewId)
  376.                 return m_cutsceneViewId;
  377.         return m_activeViewId;
  378. }
  379.  
  380. //------------------------------------------------------------------------
  381. IView* CViewSystem::GetViewByEntityId(unsigned int id, bool forceCreate)
  382. {
  383.         for (TViewMap::const_iterator it = m_views.begin(); it != m_views.end(); ++it)
  384.         {
  385.                 IView* tView = it->second;
  386.  
  387.                 if (tView && tView->GetLinkedId() == id)
  388.                         return tView;
  389.         }
  390.  
  391.         if (forceCreate)
  392.         {
  393.                 if (IEntity* pEntity = gEnv->pEntitySystem->GetEntity(id))
  394.                 {
  395.                         if (CGameObject* pGameObject = static_cast<CGameObject*>(pEntity->GetProxy(ENTITY_PROXY_USER)))
  396.                         {
  397.                                 if (IView* pNew = CreateView())
  398.                                 {
  399.                                         pNew->LinkTo(pGameObject);
  400.                                         return pNew;
  401.                                 }
  402.                         }
  403.                         else
  404.                         {
  405.                                 if (IView* pNew = CreateView())
  406.                                 {
  407.                                         pNew->LinkTo(pEntity);
  408.                                         return pNew;
  409.                                 }
  410.                         }
  411.                 }
  412.         }
  413.  
  414.         return nullptr;
  415. }
  416.  
  417. //------------------------------------------------------------------------
  418. void CViewSystem::SetActiveCamera(const SCameraParams& params)
  419. {
  420.         IView* pView = nullptr;
  421.         if (params.cameraEntityId)
  422.         {
  423.                 pView = GetViewByEntityId(params.cameraEntityId, true);
  424.                 if (pView)
  425.                 {
  426.                         SViewParams viewParams = *pView->GetCurrentParams();
  427.                         viewParams.fov = params.fFOV;
  428.                         viewParams.nearplane = params.fNearZ;
  429.  
  430.                         //char szDebug[256];
  431.                         //cry_sprintf(szDebug,"pos=%0.2f,%0.2f,%0.2f,rot=%0.2f,%0.2f,%0.2f\n",viewParams.position.x,viewParams.position.y,viewParams.position.z,viewParams.rotation.v.x,viewParams.rotation.v.y,viewParams.rotation.v.z,viewParams.rotation.w);
  432.                         //OutputDebugString(szDebug);
  433.  
  434.                         if (m_bActiveViewFromSequence == false && m_preSequenceViewId == 0)
  435.                         {
  436.                                 m_preSequenceViewId = m_activeViewId;
  437.                                 IView* pPrevView = GetView(m_activeViewId);
  438.                                 if (pPrevView && m_fBlendInPosSpeed > 0.0f && m_fBlendInRotSpeed > 0.0f)
  439.                                 {
  440.                                         viewParams.blendPosSpeed = m_fBlendInPosSpeed;
  441.                                         viewParams.blendRotSpeed = m_fBlendInRotSpeed;
  442.                                         viewParams.BlendFrom(*pPrevView->GetCurrentParams());
  443.                                 }
  444.                         }
  445.  
  446.                         if (m_activeViewId != GetViewId(pView) && params.justActivated)
  447.                         {
  448.                                 viewParams.justActivated = true;
  449.                         }
  450.  
  451.                         pView->SetCurrentParams(viewParams);
  452.                         // make this one the active view
  453.                         SetActiveView(pView);
  454.                         m_bActiveViewFromSequence = true;
  455.                 }
  456.         }
  457.         else
  458.         {
  459.                 if (m_preSequenceViewId != 0)
  460.                 {
  461.                         IView* pActiveView = GetView(m_activeViewId);
  462.                         IView* pNewView = GetView(m_preSequenceViewId);
  463.                         if (pActiveView && pNewView && m_bPerformBlendOut)
  464.                         {
  465.                                 SViewParams activeViewParams = *pActiveView->GetCurrentParams();
  466.                                 SViewParams newViewParams = *pNewView->GetCurrentParams();
  467.                                 newViewParams.BlendFrom(activeViewParams);
  468.                                 newViewParams.blendPosSpeed = activeViewParams.blendPosSpeed;
  469.                                 newViewParams.blendRotSpeed = activeViewParams.blendRotSpeed;
  470.  
  471.                                 if (m_activeViewId != m_preSequenceViewId && params.justActivated)
  472.                                 {
  473.                                         newViewParams.justActivated = true;
  474.                                 }
  475.  
  476.                                 pNewView->SetCurrentParams(newViewParams);
  477.                                 SetActiveView(m_preSequenceViewId);
  478.  
  479.                         }
  480.                         else if (pActiveView && m_activeViewId != m_preSequenceViewId && params.justActivated)
  481.                         {
  482.                                 SViewParams activeViewParams = *pActiveView->GetCurrentParams();
  483.                                 activeViewParams.justActivated = true;
  484.                                 if (m_nViewSystemDebug)
  485.                                 {
  486.                                         GameWarning("CViewSystem::SetActiveCamera(): %d", m_preSequenceViewId);
  487.                                         if (pNewView == nullptr)
  488.                                                 GameWarning("CViewSystem::SetActiveCamera(): Switching to pre-sequence view failed!");
  489.                                         else
  490.                                                 GameWarning("CViewSystem::SetActiveCamera(): Switching to pre-sequence view OK!");
  491.                                 }
  492.  
  493.                                 if (pNewView)
  494.                                 {
  495.                                         pNewView->SetCurrentParams(activeViewParams);
  496.                                         SetActiveView(m_preSequenceViewId);
  497.                                 }
  498.  
  499.                         }
  500.  
  501.                         m_preSequenceViewId = 0;
  502.                         m_bActiveViewFromSequence = false;
  503.                 }
  504.         }
  505.         m_cutsceneViewId = GetViewId(pView);
  506.  
  507.         VS_CALL_LISTENERS(OnCameraChange(params));
  508. }
  509.  
  510. //------------------------------------------------------------------------
  511. void CViewSystem::BeginCutScene(IAnimSequence* pSeq, unsigned long dwFlags, bool bResetFX)
  512. {
  513.         m_cutsceneCount++;
  514.  
  515.         if (m_cutsceneCount == 1)
  516.         {
  517.                 gEnv->p3DEngine->ResetPostEffects();
  518.         }
  519.  
  520.         VS_CALL_LISTENERS(OnBeginCutScene(pSeq, bResetFX));
  521.  
  522.         /* TODO: how do we pause the game
  523.            IScriptSystem *pSS=m_pGame->GetScriptSystem();
  524.            _SmartScriptObject pClientStuff(pSS,true);
  525.            if(pSS->GetGlobalValue("ClientStuff",pClientStuff)){
  526.             pSS->BeginCall("ClientStuff","OnPauseGame");
  527.             pSS->PushFuncParam(pClientStuff);
  528.             pSS->EndCall();
  529.            }
  530.          */
  531.  
  532.         /* TODO: how do we block keys
  533.            // do not allow the player to mess around with player's keys
  534.            // during a cutscene
  535.            GetISystem()->GetIInput()->GetIKeyboard()->ClearKeyState();
  536.            m_pGame->m_pIActionMapManager->SetActionMap("player_dead");
  537.            m_pGame->AllowQuicksave(false);
  538.          */
  539.  
  540.         /* TODO: how do we pause sounds?
  541.            // Sounds are not stopped or cut automatically, code needs to listen to cutscene begin/end event
  542.            // Cutscenes have dedicated foley sounds so to lower the volume of the rest a soundmood is used
  543.          */
  544.  
  545.         REINST("notify the audio system?");
  546.  
  547.         /* TODO: how do we reset FX?
  548.            if (bResetFx)
  549.            {
  550.             m_pGame->m_p3DEngine->ResetScreenFx();
  551.             ICVar *pResetScreenEffects=pCon->GetCVar("r_ResetScreenFx");
  552.             if(pResetScreenEffects)
  553.             {
  554.             pResetScreenEffects->Set(1);
  555.             }
  556.            }
  557.          */
  558.  
  559.         //  if(gEnv->p3DEngine)
  560.         //  gEnv->p3DEngine->ProposeContentPrecache();
  561. }
  562.  
  563. //------------------------------------------------------------------------
  564. void CViewSystem::EndCutScene(IAnimSequence* pSeq, unsigned long dwFlags)
  565. {
  566.         m_cutsceneCount -= (m_cutsceneCount > 0);
  567.  
  568.         if (m_cutsceneCount == 0)
  569.         {
  570.                 gEnv->p3DEngine->ResetPostEffects();
  571.         }
  572.  
  573.         ClearCutsceneViews();
  574.  
  575.         VS_CALL_LISTENERS(OnEndCutScene(pSeq));
  576.  
  577.         // TODO: reimplement
  578.         //      m_pGame->AllowQuicksave(true);
  579.  
  580.         /* TODO: how to resume game
  581.            if (!m_pGame->IsServer())
  582.            {
  583.             IScriptSystem *pSS=m_pGame->GetScriptSystem();
  584.             _SmartScriptObject pClientStuff(pSS,true);
  585.             if(pSS->GetGlobalValue("ClientStuff",pClientStuff)){
  586.               pSS->BeginCall("ClientStuff","OnResumeGame");
  587.               pSS->PushFuncParam(pClientStuff);
  588.               pSS->EndCall();
  589.             }
  590.            }
  591.          */
  592.  
  593.         /* TODO: how do we pause sounds?
  594.            // Sounds are not stopped or cut automatically, code needs to listen to cutscene begin/end event
  595.            // Cutscenes have dedicated foley sounds so to lower the volume of the rest a soundmood is used
  596.  
  597.            if (m_bSoundsPaused)
  598.            {
  599.            }
  600.          */
  601.  
  602.         REINST("notify the audio system?");
  603.  
  604.         /* TODO: resolve input difficulties
  605.            m_pGame->m_pIActionMapManager->SetActionMap("default");
  606.            GetISystem()->GetIInput()->GetIKeyboard()->ClearKeyState();
  607.          */
  608.  
  609.         /* TODO: weird game related stuff
  610.            // we regenerate stamina fpr the local payer on cutsceen end - supposendly he was idle long enough to get it restored
  611.            if (m_pGame->GetMyPlayer())
  612.            {
  613.             CPlayer *pPlayer;
  614.             if (m_pGame->GetMyPlayer()->GetContainer()->QueryContainerInterface(CIT_IPLAYER,(void**)&pPlayer))
  615.             {
  616.               pPlayer->m_stats.stamina = 100;
  617.             }
  618.            }
  619.  
  620.            // reset subtitles
  621.            m_pGame->m_pClient->ResetSubtitles();
  622.          */
  623. }
  624.  
  625. void CViewSystem::SendGlobalEvent(const char* pszEvent)
  626. {
  627.         // TODO: broadcast to flowgraph/script system
  628. }
  629.  
  630. //void CViewSystem::PlaySubtitles( IAnimSequence* pSeq, ISound *pSound )
  631. //{
  632. //      // TODO: support subtitles
  633. //}
  634.  
  635. //////////////////////////////////////////////////////////////////////////
  636. void CViewSystem::SetOverrideCameraRotation(bool bOverride, Quat rotation)
  637. {
  638.         m_bOverridenCameraRotation = bOverride;
  639.         m_overridenCameraRotation = rotation;
  640. }
  641.  
  642. //////////////////////////////////////////////////////////////////////////
  643. void CViewSystem::UpdateSoundListeners()
  644. {
  645.         assert(gEnv->IsEditor() && !gEnv->IsEditorGameMode());
  646.  
  647.         // In Editor we may want to control global listeners outside of the game view.
  648.         if (m_bControlsAudioListeners)
  649.         {
  650.                 CView* const __restrict pActiveView = static_cast<CView*>(GetActiveView());
  651.                 TViewMap::const_iterator Iter(m_views.begin());
  652.                 TViewMap::const_iterator const IterEnd(m_views.end());
  653.  
  654.                 for (; Iter != IterEnd; ++Iter)
  655.                 {
  656.                         CView* const __restrict pView = Iter->second;
  657.                         bool const bIsActive = (pView == pActiveView);
  658.                         CCamera const& rCamera = bIsActive ? gEnv->pSystem->GetViewCamera() : pView->GetCamera();
  659.                         pView->UpdateAudioListener(rCamera.GetMatrix());
  660.                 }
  661.         }
  662. }
  663.  
  664. //////////////////////////////////////////////////////////////////
  665. void CViewSystem::OnLoadingStart(ILevelInfo* pLevel)
  666. {
  667.         //If the level is being restarted (IsSerializingFile() == 1)
  668.         //views should not be cleared, because the main view (player one) won't be recreated in this case
  669.         //Views will only be cleared when loading a new map, or loading a saved game (IsSerizlizingFile() == 2)
  670.         bool shouldClearViews = gEnv->pSystem ? (gEnv->pSystem->IsSerializingFile() != 1) : false;
  671.  
  672.         if (shouldClearViews)
  673.                 ClearAllViews();
  674. }
  675.  
  676. /////////////////////////////////////////////////////////////////////
  677. void CViewSystem::OnUnloadComplete(ILevelInfo* pLevel)
  678. {
  679.         bool shouldClearViews = gEnv->pSystem ? (gEnv->pSystem->IsSerializingFile() != 1) : false;
  680.  
  681.         if (shouldClearViews)
  682.                 ClearAllViews();
  683.  
  684.         assert(m_listeners.empty());
  685.         stl::free_container(m_listeners);
  686. }
  687.  
  688. /////////////////////////////////////////////////////////////////////
  689. void CViewSystem::ClearCutsceneViews()
  690. {
  691.         //First switch to previous camera if available
  692.         //In practice, the camera should be already restored before reaching this point, but just in case.
  693.         if (m_preSequenceViewId != 0)
  694.         {
  695.                 SCameraParams camParams;
  696.                 camParams.cameraEntityId = 0; //Setting to 0, will try to switch to previous camera
  697.                 camParams.fFOV = 60.0f;
  698.                 camParams.fNearZ = DEFAULT_NEAR;
  699.                 camParams.justActivated = true;
  700.                 SetActiveCamera(camParams);
  701.         }
  702.  
  703.         //Delete views created during the cut-scene
  704.         const int count = m_cutsceneViewIdVector.size();
  705.         for (int i = 0; i < count; ++i)
  706.         {
  707.                 TViewMap::iterator it = m_views.find(m_cutsceneViewIdVector[i]);
  708.                 if (it != m_views.end())
  709.                 {
  710.                         it->second->Release();
  711.                         if (it->first == m_activeViewId)
  712.                                 m_activeViewId = 0;
  713.                         if (it->first == m_preSequenceViewId)
  714.                                 m_preSequenceViewId = 0;
  715.                         m_views.erase(it);
  716.                 }
  717.         }
  718.         stl::free_container(m_cutsceneViewIdVector);
  719. }
  720.  
  721. ///////////////////////////////////////////
  722. void CViewSystem::ClearAllViews()
  723. {
  724.         TViewMap::iterator end = m_views.end();
  725.         for (TViewMap::iterator it = m_views.begin(); it != end; ++it)
  726.         {
  727.                 SAFE_RELEASE(it->second);
  728.         }
  729.         stl::free_container(m_views);
  730.         stl::free_container(m_cutsceneViewIdVector);
  731.         m_preSequenceViewId = 0;
  732.         m_activeViewId = 0;
  733. }
  734.  
  735. ////////////////////////////////////////////////////////////////////
  736. void CViewSystem::DebugDraw()
  737. {
  738.         float xpos = 20;
  739.         float ypos = 15;
  740.         float fColor[4] = { 1.0f, 1.0f, 1.0f, 0.7f };
  741.         float fColorRed[4] = { 1.0f, 0.0f, 0.0f, 0.7f };
  742.         //              float fColorYellow[4]   ={1.0f, 1.0f, 0.0f, 0.7f};
  743.         float fColorGreen[4] = { 0.0f, 1.0f, 0.0f, 0.7f };
  744.         //              float fColorOrange[4]   ={1.0f, 0.5f, 0.0f, 0.7f};
  745.         //              float fColorBlue[4]             ={0.4f, 0.4f, 7.0f, 0.7f};
  746.  
  747.         IRenderAuxText::Draw2dLabel(xpos, 5, 1.35f, fColor, false, "ViewSystem Stats: %" PRISIZE_T " Views ", m_views.size());
  748.  
  749.         IView* pActiveView = GetActiveView();
  750.         for (TViewMap::iterator it = m_views.begin(); it != m_views.end(); ++it)
  751.         {
  752.                 CView* pView = it->second;
  753.                 const CCamera& cam = pView->GetCamera();
  754.                 bool isActive = (pView == pActiveView);
  755.                 bool cutSceneCamera = false;
  756.                 for (int i = 0; i < m_cutsceneViewIdVector.size(); i++)
  757.                 {
  758.                         if (m_cutsceneViewIdVector[i] == it->first)
  759.                         {
  760.                                 cutSceneCamera = true;
  761.                                 break;
  762.                         }
  763.                 }
  764.  
  765.                 Vec3 pos = cam.GetPosition();
  766.                 Ang3 ang = cam.GetAngles();
  767.                 if (!cutSceneCamera)
  768.                         IRenderAuxText::Draw2dLabel(xpos, ypos, 1.35f, isActive ? fColorGreen : fColorRed, false, "View Camera: %p . View Id: %d, pos (%f, %f, %f), ang (%f, %f, %f)", &cam, it->first, pos.x, pos.y, pos.z, ang.x, ang.y, ang.z);
  769.                 else
  770.                         IRenderAuxText::Draw2dLabel(xpos, ypos, 1.35f, isActive ? fColorGreen : fColorRed, false, "View Camera: %p . View Id: %d, pos (%f, %f, %f), ang (%f, %f, %f) - Created during Cut-Scene", &cam, it->first, pos.x, pos.y, pos.z, ang.x, ang.y, ang.z);
  771.  
  772.                 ypos += 11;
  773.         }
  774. }
  775.  
  776. //////////////////////////////////////////////////////////////////////////
  777. void CViewSystem::GetMemoryUsage(ICrySizer* s) const
  778. {
  779.         SIZER_SUBCOMPONENT_NAME(s, "ViewSystem");
  780.         s->Add(*this);
  781.         s->AddObject(m_views);
  782. }
  783.  
  784. void CViewSystem::Serialize(TSerialize ser)
  785. {
  786.         TViewMap::iterator iter = m_views.begin();
  787.         TViewMap::iterator iterEnd = m_views.end();
  788.         while (iter != iterEnd)
  789.         {
  790.                 iter->second->Serialize(ser);
  791.                 ++iter;
  792.         }
  793. }
  794.  
  795. void CViewSystem::PostSerialize()
  796. {
  797.         TViewMap::iterator iter = m_views.begin();
  798.         TViewMap::iterator iterEnd = m_views.end();
  799.         while (iter != iterEnd)
  800.         {
  801.                 iter->second->PostSerialize();
  802.                 ++iter;
  803.         }
  804. }
  805.  
  806. ///////////////////////////////////////////////////////////////////////////
  807. void CViewSystem::SetControlAudioListeners(bool bActive)
  808. {
  809.         m_bControlsAudioListeners = bActive;
  810.  
  811.         TViewMap::const_iterator Iter(m_views.begin());
  812.         TViewMap::const_iterator const IterEnd(m_views.end());
  813.  
  814.         for (; Iter != IterEnd; ++Iter)
  815.         {
  816.                 Iter->second->SetActive(bActive);
  817.         }
  818. }
  819.  
downloadViewSystem.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