birkeh/o3de
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
a10351f38ddf50af2b01ed071c04cda52d6069ed
o3de/Gems/Maestro/Code/Source/Cinematics/AnimScreenFaderNode.cpp
T
alexpete a10351f38d Initial commit
2021-03-08 14:30:57 -08:00

423 lines
12 KiB
C++
Raw Blame History

/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#include "Maestro_precompiled.h"
#include <AzCore/Serialization/SerializeContext.h>
#include "AnimScreenFaderNode.h"
#include "ScreenFaderTrack.h"
#include <IRenderer.h>
#include "Maestro/Types/AnimNodeType.h"
#include "Maestro/Types/AnimValueType.h"
#include "Maestro/Types/AnimParamType.h"
//-----------------------------------------------------------------------------
namespace
{
bool s_screenFaderNodeParamsInitialized = false;
StaticInstance<std::vector<CAnimNode::SParamInfo>> s_screenFaderNodeParams;
void AddSupportedParams(const char* sName, AnimParamType paramId, AnimValueType valueType)
{
CAnimNode::SParamInfo param;
param.name = sName;
param.paramType = paramId;
param.valueType = valueType;
param.flags = IAnimNode::eSupportedParamFlags_MultipleTracks;
s_screenFaderNodeParams.push_back(param);
}
};
//-----------------------------------------------------------------------------
bool CalculateIsolatedKeyColor(const IScreenFaderKey& key, float fTime, Vec4& colorOut)
{
float ratio = fTime - key.time;
if (ratio < 0.f)
{
return false;
}
if (key.m_fadeTime == 0.f)
{
colorOut(key.m_fadeColor.GetR(), key.m_fadeColor.GetG(), key.m_fadeColor.GetB(), key.m_fadeColor.GetA());
if (key.m_fadeType == IScreenFaderKey::eFT_FadeIn)
{
colorOut.w = 0.f;
}
else
{
colorOut.w = 1.f;
}
}
else
{
colorOut(key.m_fadeColor.GetR(), key.m_fadeColor.GetG(), key.m_fadeColor.GetB(), key.m_fadeColor.GetA());
ratio = ratio / key.m_fadeTime;
if (key.m_fadeType == IScreenFaderKey::eFT_FadeIn)
{
colorOut.w = MAX(0.f, 1.f - ratio);
}
else
{
colorOut.w = MIN(1.f, ratio);
}
}
return true;
}
//-----------------------------------------------------------------------------
CAnimScreenFaderNode::CAnimScreenFaderNode(const int id)
: CAnimNode(id, AnimNodeType::ScreenFader)
, m_bActive(false)
, m_screenWidth(800.f)
, m_screenHeight(600.f)
, m_lastActivatedKey(-1)
, m_texPrecached(false)
{
m_startColor = Vec4(1, 1, 1, 1);
CAnimScreenFaderNode::Initialize();
PrecacheTexData();
}
CAnimScreenFaderNode::CAnimScreenFaderNode()
: CAnimScreenFaderNode(0)
{
}
CAnimScreenFaderNode::~CAnimScreenFaderNode()
{
}
//-----------------------------------------------------------------------------
void CAnimScreenFaderNode::Initialize()
{
if (!s_screenFaderNodeParamsInitialized)
{
s_screenFaderNodeParamsInitialized = true;
s_screenFaderNodeParams.reserve(1);
AddSupportedParams("Fader", AnimParamType::ScreenFader, AnimValueType::Unknown);
}
}
//-----------------------------------------------------------------------------
void CAnimScreenFaderNode::Animate(SAnimContext& ac)
{
size_t const nScreenFaderTracksNumber = m_tracks.size();
for (size_t nFaderTrackNo = 0; nFaderTrackNo < nScreenFaderTracksNumber; ++nFaderTrackNo)
{
CScreenFaderTrack* pTrack = static_cast<CScreenFaderTrack*>(GetTrackForParameter(AnimParamType::ScreenFader, nFaderTrackNo));
if (!pTrack)
{
continue;
}
if (pTrack->GetNumKeys() == 0)
{
continue;
}
if (pTrack->GetFlags() & IAnimTrack::eAnimTrackFlags_Disabled)
{
continue;
}
if (pTrack->IsMasked(ac.trackMask))
{
continue;
}
if (ac.singleFrame)
{
m_lastActivatedKey = -1;
}
IScreenFaderKey key;
int nActiveKeyIndex = pTrack->GetActiveKey(ac.time, &key);
if (nActiveKeyIndex >= 0)
{
if (m_lastActivatedKey != nActiveKeyIndex)
{
m_lastActivatedKey = nActiveKeyIndex;
m_bActive = true;
if (!key.m_strTexture.empty())
{
if (pTrack->SetActiveTexture(nActiveKeyIndex))
{
pTrack->SetTextureVisible(true);
}
else
{
pTrack->SetTextureVisible(false);
}
}
else
{
pTrack->SetTextureVisible(false);
}
}
if (m_bActive || key.m_fadeTime + key.time > ac.time)
{
float ratio = (key.m_fadeTime > 0) ? (ac.time - key.time) / key.m_fadeTime : 1.f;
if (ratio < 0.f)
{
ratio = 0.f;
}
ratio = MIN(ratio, 1.f);
switch (key.m_fadeChangeType)
{
case IScreenFaderKey::eFCT_Square:
ratio = ratio * ratio;
break;
case IScreenFaderKey::eFCT_CubicSquare:
ratio = ratio * ratio * ratio;
break;
case IScreenFaderKey::eFCT_SquareRoot:
ratio = sqrt(ratio);
break;
case IScreenFaderKey::eFCT_Sin:
ratio = sinf(ratio * 3.14159265f * 0.5f);
break;
}
if (!key.m_bUseCurColor || nActiveKeyIndex == 0)
{
m_startColor(key.m_fadeColor.GetR(), key.m_fadeColor.GetG(), key.m_fadeColor.GetB(), key.m_fadeColor.GetA());
}
else
{
IScreenFaderKey preKey;
pTrack->GetKey(nActiveKeyIndex - 1, &preKey);
CalculateIsolatedKeyColor(preKey, ac.time, m_startColor);
}
if (key.m_fadeType == IScreenFaderKey::eFT_FadeIn)
{
if (!key.m_bUseCurColor || nActiveKeyIndex == 0)
{
m_startColor.w = 1.f;
}
key.m_fadeColor.SetA(0.f);
}
else
{
if (!key.m_bUseCurColor || nActiveKeyIndex == 0)
{
m_startColor.w = 0.f;
}
key.m_fadeColor.SetA(1.f);
}
Vec4 fadeColorAsVec4(key.m_fadeColor.GetR(), key.m_fadeColor.GetG(), key.m_fadeColor.GetB(), key.m_fadeColor.GetA());
pTrack->SetDrawColor(m_startColor + (fadeColorAsVec4 - m_startColor) * ratio);
if (pTrack->GetDrawColor().w < 0.01f)
{
m_bActive = IsAnyTextureVisible();
}
else
{
m_bActive = true;
}
}
}
else
{
pTrack->SetTextureVisible(false);
m_bActive = IsAnyTextureVisible();
}
}
}
//-----------------------------------------------------------------------------
void CAnimScreenFaderNode::CreateDefaultTracks()
{
CreateTrack(AnimParamType::ScreenFader);
}
//-----------------------------------------------------------------------------
void CAnimScreenFaderNode::OnReset()
{
CAnimNode::OnReset();
m_bActive = false;
}
//-----------------------------------------------------------------------------
void CAnimScreenFaderNode::Activate(bool bActivate)
{
if (bActivate)
{
m_bActive = false;
}
if (m_texPrecached == false)
{
PrecacheTexData();
}
}
//-----------------------------------------------------------------------------
/// @deprecated Serialization for Sequence data in Component Entity Sequences now occurs through AZ::SerializeContext and the Sequence Component
void CAnimScreenFaderNode::Serialize
(XmlNodeRef& xmlNode, bool bLoading, bool bLoadEmptyTracks)
{
CAnimNode::Serialize(xmlNode, bLoading, bLoadEmptyTracks);
if (bLoading)
{
PrecacheTexData();
}
}
//////////////////////////////////////////////////////////////////////////
void CAnimScreenFaderNode::Reflect(AZ::SerializeContext* serializeContext)
{
serializeContext->Class<CAnimScreenFaderNode, CAnimNode>()
->Version(1);
}
//-----------------------------------------------------------------------------
unsigned int CAnimScreenFaderNode::GetParamCount() const
{
return s_screenFaderNodeParams.size();
}
//-----------------------------------------------------------------------------
CAnimParamType CAnimScreenFaderNode::GetParamType(unsigned int nIndex) const
{
if (nIndex >= 0 && nIndex < (int)s_screenFaderNodeParams.size())
{
return s_screenFaderNodeParams[nIndex].paramType;
}
return AnimParamType::Invalid;
}
//-----------------------------------------------------------------------------
void CAnimScreenFaderNode::SetFlags(int flags)
{
// call base class implementation. I'm avoiding the use of the Microsoft specific __super::SetFlags(flags) because it is not
// platform agnostic
CAnimNode::SetFlags(flags);
if (flags & eAnimNodeFlags_Disabled)
{
// for screen faders, when disabling, we want to reset so the screen doesn't stay partially faded if a fade was in
// effect when disabled
OnReset();
}
}
//-----------------------------------------------------------------------------
bool CAnimScreenFaderNode::GetParamInfoFromType(const CAnimParamType& paramId, SParamInfo& info) const
{
for (size_t i = 0; i < s_screenFaderNodeParams.size(); ++i)
{
if (s_screenFaderNodeParams[i].paramType == paramId)
{
info = s_screenFaderNodeParams[i];
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
void CAnimScreenFaderNode::Render()
{
if (!m_bActive)
{
return;
}
if (gEnv->pRenderer)
{
size_t const paramCount = m_tracks.size();
for (size_t paramIndex = 0; paramIndex < paramCount; ++paramIndex)
{
CScreenFaderTrack* pTrack = static_cast<CScreenFaderTrack*>(GetTrackForParameter(AnimParamType::ScreenFader, paramIndex));
if (!pTrack)
{
continue;
}
int textureId = -1;
if (pTrack->IsTextureVisible())
{
textureId = (pTrack->GetActiveTexture() != 0) ? pTrack->GetActiveTexture()->GetTextureID() : -1;
}
gEnv->pRenderer->SetState(GS_BLSRC_SRCALPHA | GS_BLDST_ONEMINUSSRCALPHA | GS_NODEPTHTEST);
gEnv->pRenderer->Draw2dImage(0, 0, m_screenWidth, m_screenHeight, textureId, 0.0f, 1.0f, 1.0f, 0.0f, 0.f,
pTrack->GetDrawColor().x, pTrack->GetDrawColor().y, pTrack->GetDrawColor().z, pTrack->GetDrawColor().w, 0.f);
}
}
}
bool CAnimScreenFaderNode::IsAnyTextureVisible() const
{
size_t const paramCount = m_tracks.size();
for (size_t paramIndex = 0; paramIndex < paramCount; ++paramIndex)
{
CScreenFaderTrack* pTrack = static_cast<CScreenFaderTrack*>(GetTrackForParameter(AnimParamType::ScreenFader, paramIndex));
if (!pTrack)
{
continue;
}
if (pTrack->IsTextureVisible())
{
return true;
}
}
return false;
}
void CAnimScreenFaderNode::PrecacheTexData()
{
size_t const paramCount = m_tracks.size();
for (size_t paramIndex = 0; paramIndex < paramCount; ++paramIndex)
{
IAnimTrack* pTrack = m_tracks[paramIndex].get();
if (!pTrack)
{
continue;
}
switch (m_tracks[paramIndex]->GetParameterType().GetType())
{
case AnimParamType::ScreenFader:
{
CScreenFaderTrack* pFaderTrack = static_cast<CScreenFaderTrack*>(pTrack);
pFaderTrack->PreloadTextures();
}
break;
}
}
m_texPrecached = true;
}
Reference in New Issue View Git Blame Copy Permalink