Justin Marshall
739 lines
25 KiB
C++
739 lines
25 KiB
C++
#include "gamelib/effects/fxmanager.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <cstdint>
|
|
|
|
int GameLib_GetFXDeclActionCount(const idDeclFX* decl);
|
|
int GameLib_GetFXDeclChangeId(const idDeclFX* decl);
|
|
const char* GameLib_GetFXDeclName(const idDeclFX* decl);
|
|
bool GameLib_GetFXActionParameters(const idDeclFX* decl, int actionIndex,
|
|
idFXActionParameters& parameters);
|
|
void GameLib_CreateFXActionResource(idGameLibEffects* effects,
|
|
idRenderWorld* renderWorld, const idFXActionParameters& parameters,
|
|
idFXAction& action);
|
|
void GameLib_StartFXActionResource(idGameLibEffects* effects,
|
|
const idFXActionParameters& parameters, idFXAction& action,
|
|
const idVec3& origin, const idMat3& axis, int time);
|
|
void GameLib_UpdateFXActionResource(idGameLibEffects* effects,
|
|
const idFXActionParameters& parameters, idFXAction& action,
|
|
const idVec3& origin, const idMat3& axis, const idVec3& velocity,
|
|
const idVec4& color, int time, int frameNumber, float fovScale,
|
|
float depthHack);
|
|
void GameLib_StopFXActionResource(idGameLibEffects* effects,
|
|
const idFXActionParameters& parameters, idFXAction& action,
|
|
int time, bool immediate, bool recycleResources);
|
|
void GameLib_FreeFXActionResource(idGameLibEffects* effects,
|
|
const idFXActionParameters& parameters, idFXAction& action);
|
|
void GameLib_EnumerateFXActionTags(idTreeAnimator* animator,
|
|
const idDeclFX* decl, int actionIndex, idList<tagData_t, 109>& tags);
|
|
bool GameLib_GetFXTagVelocity(idTreeAnimator* animator, const tagData_t& tag,
|
|
int gameMsPerFrame, idVec3& velocity);
|
|
idVec4 GameLib_GetFXRenderParm(const idDeclRenderParm* parameter);
|
|
idVec4 GameLib_GetFXTableColor(const idFXSingleAction& action,
|
|
float fraction);
|
|
idList<idViewCallbacks*, 109>* GameLib_GetFXViewCallbacks();
|
|
int GameLib_StartFXSound(idSoundEmitter* emitter, soundChannel_t channel,
|
|
const idSoundShader* shader);
|
|
void GameLib_SerializeFXManager(idSerializer& serializer,
|
|
idFXManager& manager);
|
|
|
|
idRenderModelParticle* GameLib_AllocParticleFxModel(idRenderWorld* renderWorld,
|
|
const idDeclParticle* particleDecl);
|
|
void GameLib_FreeParticleFxModel(idRenderModelParticle* model);
|
|
idRenderModel* GameLib_AllocStaticFxModel(idRenderWorld* renderWorld,
|
|
const char* modelName);
|
|
void GameLib_FreeStaticFxModel(idRenderModel* model);
|
|
|
|
namespace {
|
|
|
|
int PointerKey(const void* pointer) {
|
|
return static_cast<int>(reinterpret_cast<std::uintptr_t>(pointer) >> 4);
|
|
}
|
|
|
|
float RandomRange(idRandom2& random, const idVec2& range) {
|
|
return range.x + (range.y - range.x) * random.RandomFloat();
|
|
}
|
|
|
|
float Clamp01(const float value) {
|
|
return (std::max)(0.0f, (std::min)(1.0f, value));
|
|
}
|
|
|
|
void ResetState(fxActionState_t& state) {
|
|
state.startDelay = 0;
|
|
state.startTime = -1;
|
|
state.stopTime = 0;
|
|
state.hidden = false;
|
|
state.started = false;
|
|
state.shouldTrigger = false;
|
|
state.forceStop = false;
|
|
state.fadeInStartTime = -1;
|
|
state.fadeInEndTime = 0;
|
|
state.fadeOutStartTime = 0;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
idFXModelRecycler::idFXModelRecycler()
|
|
: fxPrtModels()
|
|
, activePrtModelHash(256, 256)
|
|
, inactivePrtModelHash(256, 256)
|
|
, fxStaticModels()
|
|
, activeStaticModelHash(64, 64)
|
|
, inactiveStaticModelHash(64, 64) {
|
|
}
|
|
|
|
idFXModelRecycler::~idFXModelRecycler() {
|
|
Shutdown();
|
|
}
|
|
|
|
void idFXModelRecycler::Init() {
|
|
Shutdown();
|
|
activePrtModelHash.Clear();
|
|
inactivePrtModelHash.Clear();
|
|
activeStaticModelHash.Clear();
|
|
inactiveStaticModelHash.Clear();
|
|
}
|
|
|
|
void idFXModelRecycler::Shutdown() {
|
|
for (int index = 0; index < fxPrtModels.Num(); ++index) {
|
|
if (fxPrtModels[index].pmodel != nullptr) {
|
|
GameLib_FreeParticleFxModel(fxPrtModels[index].pmodel);
|
|
}
|
|
}
|
|
for (int index = 0; index < fxStaticModels.Num(); ++index) {
|
|
if (fxStaticModels[index].rmodel != nullptr) {
|
|
GameLib_FreeStaticFxModel(fxStaticModels[index].rmodel);
|
|
}
|
|
}
|
|
fxPrtModels.Clear();
|
|
fxStaticModels.Clear();
|
|
activePrtModelHash.Clear();
|
|
inactivePrtModelHash.Clear();
|
|
activeStaticModelHash.Clear();
|
|
inactiveStaticModelHash.Clear();
|
|
}
|
|
|
|
idRenderModelParticle* idFXModelRecycler::GetParticleFxModel(
|
|
const idDeclParticle* const particleDecl,
|
|
idRenderWorld* const renderWorld) {
|
|
if (particleDecl == nullptr) {
|
|
return nullptr;
|
|
}
|
|
const int key = PointerKey(particleDecl);
|
|
for (int index = inactivePrtModelHash.First(key); index >= 0;
|
|
index = inactivePrtModelHash.Next(index)) {
|
|
if (index < fxPrtModels.Num() &&
|
|
fxPrtModels[index].pDecl == particleDecl) {
|
|
inactivePrtModelHash.Remove(key, index);
|
|
activePrtModelHash.Add(key, index);
|
|
return fxPrtModels[index].pmodel;
|
|
}
|
|
}
|
|
if (fxPrtModels.Num() >= fxPrtModels.Max()) {
|
|
return nullptr;
|
|
}
|
|
fxPrtModel_t item{};
|
|
item.pDecl = particleDecl;
|
|
item.pmodel = GameLib_AllocParticleFxModel(renderWorld, particleDecl);
|
|
if (item.pmodel == nullptr) {
|
|
return nullptr;
|
|
}
|
|
const int index = fxPrtModels.Append(item);
|
|
activePrtModelHash.Add(key, index);
|
|
return item.pmodel;
|
|
}
|
|
|
|
void idFXModelRecycler::RecycleParticleFxModel(
|
|
const idDeclParticle* const particleDecl,
|
|
idRenderModelParticle* const model) {
|
|
if (particleDecl == nullptr || model == nullptr) {
|
|
return;
|
|
}
|
|
const int key = PointerKey(particleDecl);
|
|
for (int index = activePrtModelHash.First(key); index >= 0;
|
|
index = activePrtModelHash.Next(index)) {
|
|
if (index < fxPrtModels.Num() &&
|
|
fxPrtModels[index].pmodel == model) {
|
|
activePrtModelHash.Remove(key, index);
|
|
inactivePrtModelHash.Add(key, index);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
idRenderModel* idFXModelRecycler::GetStaticFxModel(
|
|
const idAtomicString& modelName, idRenderWorld* const renderWorld) {
|
|
if (modelName.IsEmpty()) {
|
|
return nullptr;
|
|
}
|
|
const int key = inactiveStaticModelHash.GenerateKeyForString(
|
|
modelName.c_str(), false);
|
|
for (int index = inactiveStaticModelHash.First(key); index >= 0;
|
|
index = inactiveStaticModelHash.Next(index)) {
|
|
if (index < fxStaticModels.Num() &&
|
|
fxStaticModels[index].modelName == modelName) {
|
|
inactiveStaticModelHash.Remove(key, index);
|
|
activeStaticModelHash.Add(key, index);
|
|
return fxStaticModels[index].rmodel;
|
|
}
|
|
}
|
|
if (fxStaticModels.Num() >= fxStaticModels.Max()) {
|
|
return nullptr;
|
|
}
|
|
fxStaticModel_t item{};
|
|
item.modelName = modelName;
|
|
item.rmodel = GameLib_AllocStaticFxModel(renderWorld, modelName.c_str());
|
|
if (item.rmodel == nullptr) {
|
|
return nullptr;
|
|
}
|
|
const int index = fxStaticModels.Append(item);
|
|
activeStaticModelHash.Add(key, index);
|
|
return item.rmodel;
|
|
}
|
|
|
|
void idFXModelRecycler::RecycleStaticFxModel(
|
|
const idAtomicString& modelName, idRenderModel* const model) {
|
|
if (modelName.IsEmpty() || model == nullptr) {
|
|
return;
|
|
}
|
|
const int key = activeStaticModelHash.GenerateKeyForString(
|
|
modelName.c_str(), false);
|
|
for (int index = activeStaticModelHash.First(key); index >= 0;
|
|
index = activeStaticModelHash.Next(index)) {
|
|
if (index < fxStaticModels.Num() &&
|
|
fxStaticModels[index].rmodel == model) {
|
|
activeStaticModelHash.Remove(key, index);
|
|
inactiveStaticModelHash.Add(key, index);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
idFXAction::idFXAction()
|
|
: tagIndex(0)
|
|
, startOrg()
|
|
, startAxis(1.0f)
|
|
, rLight(nullptr)
|
|
, rModel(nullptr)
|
|
, rParticle(nullptr)
|
|
, screenPrtHandle(-1)
|
|
, flareManager()
|
|
, ribbonManager()
|
|
, tagData(4)
|
|
, lastParticleDropPos()
|
|
, renderParmStartValue(0.0f, 0.0f, 0.0f, 0.0f)
|
|
, randomAngles(0.0f, 0.0f, 0.0f)
|
|
, viewCallbacksID(-1) {
|
|
startOrg.Zero();
|
|
lastParticleDropPos.Zero();
|
|
}
|
|
|
|
idFXManager::idFXManager()
|
|
: initialized(false)
|
|
, fxDecl(nullptr)
|
|
, gameLibEffects(nullptr)
|
|
, ta(nullptr)
|
|
, rw(nullptr)
|
|
, systemColor(1.0f, 1.0f, 1.0f, 1.0f)
|
|
, random(0)
|
|
, soundInfo{nullptr, SND_CHANNEL_ANY}
|
|
, actions(4)
|
|
, actionState(4)
|
|
, remote(false)
|
|
, allowSurfaceOnlyInViewID(0)
|
|
, suppressSurfaceInViewID(0)
|
|
, viewCallbacksID(-1)
|
|
, declChangeId(-1)
|
|
, externalRotation(1.0f)
|
|
, externalPosition()
|
|
, hasExternalPositionAndRotation(false)
|
|
, actionBuffer{}
|
|
, actionBufferPos(0)
|
|
, serializeActionCount(0) {
|
|
externalPosition.Zero();
|
|
}
|
|
|
|
idFXManager::~idFXManager() {
|
|
Shutdown();
|
|
}
|
|
|
|
idVec4 idFXManager::GetVector(const idDeclRenderParm* const parameter) const {
|
|
return parameter != nullptr ? GameLib_GetFXRenderParm(parameter)
|
|
: idVec4(0.0f, 0.0f, 0.0f, 0.0f);
|
|
}
|
|
|
|
idVec4 idFXManager::GetTableColor(const idFXSingleAction& action,
|
|
const float fraction) const {
|
|
return GameLib_GetFXTableColor(action, fraction);
|
|
}
|
|
|
|
bool idFXManager::GetWorldSpaceTagVelocity(const tagData_t& tag,
|
|
const int gameMsPerFrame, idVec3& velocity) {
|
|
velocity.Zero();
|
|
return ta != nullptr && gameMsPerFrame > 0 &&
|
|
GameLib_GetFXTagVelocity(ta, tag, gameMsPerFrame, velocity);
|
|
}
|
|
|
|
int idFXManager::StartSound(const soundChannel_t channel,
|
|
const idSoundShader* const shader) {
|
|
if (soundInfo.emitter == nullptr || shader == nullptr) {
|
|
return 0;
|
|
}
|
|
const soundChannel_t resolved = channel == SND_CHANNEL_ANY
|
|
? soundInfo.channel : channel;
|
|
return GameLib_StartFXSound(soundInfo.emitter, resolved, shader);
|
|
}
|
|
|
|
idList<idViewCallbacks*, 109>& idFXManager::GetViewCallbacks() {
|
|
idList<idViewCallbacks*, 109>* callbacks = GameLib_GetFXViewCallbacks();
|
|
if (callbacks != nullptr) {
|
|
return *callbacks;
|
|
}
|
|
static idList<idViewCallbacks*, 109> empty;
|
|
return empty;
|
|
}
|
|
|
|
const char* idFXManager::GetName() const {
|
|
return fxDecl != nullptr ? GameLib_GetFXDeclName(fxDecl) : "";
|
|
}
|
|
|
|
bool idFXManager::IsStopped(const int time) const {
|
|
for (int index = 0; index < actionState.Num(); ++index) {
|
|
if (time < actionState[index].stopTime) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void idFXManager::Init(const idDeclFX* const declFX,
|
|
idRenderWorld* const renderWorld,
|
|
const fxEmitterSound_t* const emitterSound,
|
|
idGameLibEffects* const effects, const float diversity,
|
|
idTreeAnimator* const treeAnimator) {
|
|
Shutdown();
|
|
if (declFX == nullptr) {
|
|
return;
|
|
}
|
|
fxDecl = declFX;
|
|
gameLibEffects = effects;
|
|
ta = treeAnimator;
|
|
rw = renderWorld;
|
|
random.SetSeed(static_cast<unsigned int>(diversity * 65535.0f));
|
|
if (emitterSound != nullptr) {
|
|
soundInfo = *emitterSound;
|
|
}
|
|
const int count = (std::max)(0, GameLib_GetFXDeclActionCount(fxDecl));
|
|
actions.SetNum(count);
|
|
actionState.SetNum(count);
|
|
declChangeId = GameLib_GetFXDeclChangeId(fxDecl);
|
|
for (int index = 0; index < count; ++index) {
|
|
CreateAction(index, rw);
|
|
}
|
|
EnumerateTags();
|
|
initialized = true;
|
|
}
|
|
|
|
void idFXManager::CreateAction(const int index,
|
|
idRenderWorld* const renderWorld) {
|
|
if (index < 0 || index >= actions.Num()) {
|
|
return;
|
|
}
|
|
ResetState(actionState[index]);
|
|
idFXActionParameters parameters{};
|
|
if (GameLib_GetFXActionParameters(fxDecl, index, parameters)) {
|
|
GameLib_CreateFXActionResource(gameLibEffects, renderWorld,
|
|
parameters, actions[index]);
|
|
}
|
|
}
|
|
|
|
void idFXManager::EnumerateTags() {
|
|
if (ta == nullptr) {
|
|
return;
|
|
}
|
|
for (int index = 0; index < actions.Num(); ++index) {
|
|
actions[index].tagData.Clear();
|
|
GameLib_EnumerateFXActionTags(ta, fxDecl, index,
|
|
actions[index].tagData);
|
|
}
|
|
}
|
|
|
|
void idFXManager::StartAction(const int index, const idVec3& origin,
|
|
const idMat3& axis, const int time, const int explicitTagIndex) {
|
|
if (index < 0 || index >= actions.Num()) {
|
|
return;
|
|
}
|
|
idFXActionParameters parameters{};
|
|
if (!GameLib_GetFXActionParameters(fxDecl, index, parameters)) {
|
|
return;
|
|
}
|
|
idFXAction& action = actions[index];
|
|
fxActionState_t& state = actionState[index];
|
|
action.startOrg = origin;
|
|
action.startAxis = axis;
|
|
action.tagIndex = explicitTagIndex >= 0 ? explicitTagIndex : 0;
|
|
if (explicitTagIndex < 0 && action.tagData.Num() > 1) {
|
|
action.tagIndex = random.RandomInt(action.tagData.Num());
|
|
}
|
|
action.randomAngles = idAngles(
|
|
RandomRange(random, parameters.randomRotationX),
|
|
RandomRange(random, parameters.randomRotationY),
|
|
RandomRange(random, parameters.randomRotationZ));
|
|
state.startDelay = static_cast<int>(RandomRange(random,
|
|
parameters.delay) * 1000.0f);
|
|
state.startTime = time;
|
|
state.stopTime = time + state.startDelay +
|
|
static_cast<int>(parameters.duration * 1000.0f);
|
|
state.fadeInStartTime = time + state.startDelay;
|
|
state.fadeInEndTime = state.fadeInStartTime +
|
|
static_cast<int>(parameters.fadeInTime * 1000.0f);
|
|
state.fadeOutStartTime = state.stopTime -
|
|
static_cast<int>(parameters.fadeOutTime * 1000.0f);
|
|
state.hidden = false;
|
|
state.started = false;
|
|
state.shouldTrigger = true;
|
|
state.forceStop = false;
|
|
}
|
|
|
|
int idFXManager::StartActions(const idVec3& origin, const idMat3& axis,
|
|
const int time, const fxCondition_t startCondition,
|
|
const fxExtraCondition_t extraCondition, const int explicitTagIndex) {
|
|
int startedCount = 0;
|
|
for (int index = 0; index < actions.Num(); ++index) {
|
|
idFXActionParameters parameters{};
|
|
if (!GameLib_GetFXActionParameters(fxDecl, index, parameters)) {
|
|
continue;
|
|
}
|
|
if (parameters.startCondition != startCondition) {
|
|
continue;
|
|
}
|
|
if (parameters.extraCondition != FX_EXTRA_COND_NONE &&
|
|
(static_cast<int>(parameters.extraCondition) &
|
|
static_cast<int>(extraCondition)) == 0) {
|
|
continue;
|
|
}
|
|
StartAction(index, origin, axis, time, explicitTagIndex);
|
|
++startedCount;
|
|
}
|
|
return startedCount;
|
|
}
|
|
|
|
int idFXManager::InternalStartFX(const fxActionCall_t& actionCall) {
|
|
if (!initialized) {
|
|
return 0;
|
|
}
|
|
const int result = StartActions(actionCall.org, actionCall.axis,
|
|
actionCall.time, actionCall.condition, actionCall.extraCondition,
|
|
actionCall.tagIdx);
|
|
++actionBufferPos;
|
|
return result;
|
|
}
|
|
|
|
int idFXManager::StartFX(const idVec3& origin, const idMat3& axis,
|
|
const int time, const fxCondition_t startCondition,
|
|
const int explicitTagIndex, const int delay) {
|
|
if (!initialized) {
|
|
return 0;
|
|
}
|
|
fxActionCall_t& call = actionBuffer[actionBufferPos % 8];
|
|
call.org = origin;
|
|
call.axis = axis;
|
|
call.condition = startCondition;
|
|
call.time = time + delay;
|
|
call.extraCondition = FX_EXTRA_COND_NONE;
|
|
call.tagIdx = explicitTagIndex;
|
|
call.actionType = FXACTION_START;
|
|
call.immediate = false;
|
|
call.viewCallbacksID = viewCallbacksID;
|
|
return InternalStartFX(call);
|
|
}
|
|
|
|
int idFXManager::StartFX(const idVec3& origin, const idMat3& axis,
|
|
const int time, const fxCondition_t startCondition,
|
|
const fxExtraCondition_t extraCondition) {
|
|
if (!initialized) {
|
|
return 0;
|
|
}
|
|
fxActionCall_t& call = actionBuffer[actionBufferPos % 8];
|
|
call.org = origin;
|
|
call.axis = axis;
|
|
call.condition = startCondition;
|
|
call.time = time;
|
|
call.extraCondition = extraCondition;
|
|
call.tagIdx = -1;
|
|
call.actionType = FXACTION_START;
|
|
call.immediate = false;
|
|
call.viewCallbacksID = viewCallbacksID;
|
|
return InternalStartFX(call);
|
|
}
|
|
|
|
int idFXManager::StartFX(const idVec3& origin, const idMat3& axis,
|
|
const int time, const fxCondition_t startCondition) {
|
|
return StartFX(origin, axis, time, startCondition, -1, 0);
|
|
}
|
|
|
|
void idFXManager::LocalStartFX(const idVec3& origin, const idMat3& axis,
|
|
const int time, const fxCondition_t startCondition) {
|
|
if (initialized) {
|
|
StartActions(origin, axis, time, startCondition,
|
|
FX_EXTRA_COND_NONE, -1);
|
|
}
|
|
}
|
|
|
|
void idFXManager::ApplyFade(const idFXActionParameters& parameters,
|
|
idFXAction& action, fxActionState_t& state, const int time,
|
|
const float fraction) {
|
|
float fade = 1.0f;
|
|
if (parameters.fadeInTime > 0.0f && time < state.fadeInEndTime) {
|
|
const int duration = state.fadeInEndTime - state.fadeInStartTime;
|
|
fade *= duration > 0 ? Clamp01(static_cast<float>(
|
|
time - state.fadeInStartTime) / duration) : 1.0f;
|
|
}
|
|
if (parameters.fadeOutTime > 0.0f && time >= state.fadeOutStartTime) {
|
|
const int duration = state.stopTime - state.fadeOutStartTime;
|
|
fade *= duration > 0 ? Clamp01(static_cast<float>(
|
|
state.stopTime - time) / duration) : 0.0f;
|
|
}
|
|
action.renderParmStartValue = idVec4(
|
|
systemColor.x * fade, systemColor.y * fade,
|
|
systemColor.z * fade, systemColor.w * fade * Clamp01(fraction));
|
|
}
|
|
|
|
void idFXManager::RestartAction(const int index, const int time) {
|
|
if (index < 0 || index >= actions.Num()) {
|
|
return;
|
|
}
|
|
const idVec3 origin = actions[index].startOrg;
|
|
const idMat3 axis = actions[index].startAxis;
|
|
StopAction(index, time, true, false);
|
|
StartAction(index, origin, axis, time, actions[index].tagIndex);
|
|
}
|
|
|
|
void idFXManager::StopAction(const int index, const int time,
|
|
const bool immediate, const bool recycleResources) {
|
|
if (index < 0 || index >= actions.Num()) {
|
|
return;
|
|
}
|
|
idFXActionParameters parameters{};
|
|
if (!GameLib_GetFXActionParameters(fxDecl, index, parameters)) {
|
|
return;
|
|
}
|
|
fxActionState_t& state = actionState[index];
|
|
if (state.startTime < 0) {
|
|
return;
|
|
}
|
|
if (!immediate && !state.forceStop && parameters.fadeOutTime > 0.0f &&
|
|
parameters.type != FX_SOUND) {
|
|
state.fadeOutStartTime = time;
|
|
state.stopTime = time + static_cast<int>(
|
|
parameters.fadeOutTime * 1000.0f);
|
|
state.forceStop = true;
|
|
return;
|
|
}
|
|
if (parameters.type == FX_FLARE) {
|
|
actions[index].flareManager.StopFlare();
|
|
} else if (parameters.type == FX_RIBBON) {
|
|
actions[index].ribbonManager.StopRibbon();
|
|
}
|
|
GameLib_StopFXActionResource(gameLibEffects, parameters, actions[index],
|
|
time, immediate, recycleResources);
|
|
const bool keepHidden = parameters.triggered;
|
|
ResetState(state);
|
|
state.hidden = keepHidden;
|
|
actions[index].lastParticleDropPos.Zero();
|
|
actions[index].randomAngles = idAngles(0.0f, 0.0f, 0.0f);
|
|
actions[index].startAxis = idMat3(1.0f);
|
|
actions[index].startOrg.Zero();
|
|
}
|
|
|
|
void idFXManager::StopActions(const int time,
|
|
const fxCondition_t stopCondition,
|
|
const fxExtraCondition_t extraCondition, const bool stopAll,
|
|
const bool immediate) {
|
|
for (int index = 0; index < actions.Num(); ++index) {
|
|
idFXActionParameters parameters{};
|
|
if (!GameLib_GetFXActionParameters(fxDecl, index, parameters)) {
|
|
continue;
|
|
}
|
|
if (!stopAll && parameters.stopCondition != stopCondition) {
|
|
continue;
|
|
}
|
|
if (!stopAll && parameters.extraCondition != FX_EXTRA_COND_NONE &&
|
|
(static_cast<int>(parameters.extraCondition) &
|
|
static_cast<int>(extraCondition)) == 0) {
|
|
continue;
|
|
}
|
|
StopAction(index, time, immediate, true);
|
|
}
|
|
}
|
|
|
|
void idFXManager::InternalStopFX(const fxActionCall_t& actionCall) {
|
|
if (!initialized) {
|
|
return;
|
|
}
|
|
StopActions(actionCall.time, actionCall.condition,
|
|
actionCall.extraCondition,
|
|
actionCall.actionType == FXACTION_STOP_ALL, actionCall.immediate);
|
|
++actionBufferPos;
|
|
}
|
|
|
|
void idFXManager::StopFX(const int time,
|
|
const fxCondition_t stopCondition, const bool immediate) {
|
|
StopFX(time, stopCondition, FX_EXTRA_COND_NONE, immediate);
|
|
}
|
|
|
|
void idFXManager::StopFX(const int time,
|
|
const fxCondition_t stopCondition,
|
|
const fxExtraCondition_t extraCondition, const bool immediate) {
|
|
if (!initialized) {
|
|
return;
|
|
}
|
|
fxActionCall_t& call = actionBuffer[actionBufferPos % 8];
|
|
call.condition = stopCondition;
|
|
call.time = time;
|
|
call.extraCondition = extraCondition;
|
|
call.actionType = FXACTION_STOP;
|
|
call.immediate = immediate;
|
|
call.viewCallbacksID = viewCallbacksID;
|
|
InternalStopFX(call);
|
|
}
|
|
|
|
void idFXManager::LocalStopFX(const int time,
|
|
const fxCondition_t stopCondition, const bool immediate) {
|
|
if (initialized) {
|
|
StopActions(time, stopCondition, FX_EXTRA_COND_NONE, false,
|
|
immediate);
|
|
}
|
|
}
|
|
|
|
void idFXManager::StopAllFX(const int time, const bool immediate) {
|
|
if (!initialized) {
|
|
return;
|
|
}
|
|
fxActionCall_t& call = actionBuffer[actionBufferPos % 8];
|
|
call.condition = FX_NONE;
|
|
call.time = time;
|
|
call.extraCondition = FX_EXTRA_COND_NONE;
|
|
call.actionType = FXACTION_STOP_ALL;
|
|
call.immediate = immediate;
|
|
call.viewCallbacksID = viewCallbacksID;
|
|
InternalStopFX(call);
|
|
}
|
|
|
|
void idFXManager::LocalStopAllFX(const int time, const bool immediate) {
|
|
if (initialized) {
|
|
StopActions(time, FX_NONE, FX_EXTRA_COND_NONE, true, immediate);
|
|
}
|
|
}
|
|
|
|
void idFXManager::UpdateActions(const idVec3& origin, const idMat3& axis,
|
|
const idVec3& velocity, const int time, const int gameMsPerFrame,
|
|
const int frameNumber, const float fovScale, const float depthHack) {
|
|
(void)gameMsPerFrame;
|
|
for (int index = 0; index < actions.Num(); ++index) {
|
|
idFXActionParameters parameters{};
|
|
if (!GameLib_GetFXActionParameters(fxDecl, index, parameters)) {
|
|
continue;
|
|
}
|
|
fxActionState_t& state = actionState[index];
|
|
idFXAction& action = actions[index];
|
|
if (state.startTime < 0 || state.hidden) {
|
|
continue;
|
|
}
|
|
const int actualStart = state.startTime + state.startDelay;
|
|
if (time < actualStart) {
|
|
continue;
|
|
}
|
|
if (!state.started) {
|
|
GameLib_StartFXActionResource(gameLibEffects, parameters, action,
|
|
action.startOrg, action.startAxis, actualStart);
|
|
if (parameters.type == FX_SOUND) {
|
|
StartSound(parameters.soundChannel, parameters.sound);
|
|
}
|
|
state.started = true;
|
|
}
|
|
if (time >= state.stopTime) {
|
|
if (parameters.looping && !state.forceStop) {
|
|
RestartAction(index, time + static_cast<int>(
|
|
parameters.restart * 1000.0f));
|
|
} else {
|
|
StopAction(index, time, true, true);
|
|
}
|
|
continue;
|
|
}
|
|
const int duration = (std::max)(1, state.stopTime - actualStart);
|
|
const float fraction = Clamp01(static_cast<float>(time - actualStart) /
|
|
static_cast<float>(duration));
|
|
ApplyFade(parameters, action, state, time, fraction);
|
|
const idVec3 updateOrigin = parameters.trackOrigin ? origin
|
|
: action.startOrg;
|
|
const idMat3 updateAxis = parameters.trackOrigin ? axis
|
|
: action.startAxis;
|
|
GameLib_UpdateFXActionResource(gameLibEffects, parameters, action,
|
|
updateOrigin, updateAxis, velocity, action.renderParmStartValue,
|
|
time, frameNumber, fovScale, depthHack);
|
|
}
|
|
}
|
|
|
|
void idFXManager::Update(const idVec3& parentOrigin,
|
|
const idMat3& parentAxis, const idVec3& parentVelocity, const int time,
|
|
const int gameMsPerFrame, const int frameNumber, const float fovScale,
|
|
const float depthHack) {
|
|
if (!initialized) {
|
|
return;
|
|
}
|
|
while (serializeActionCount > 0) {
|
|
--serializeActionCount;
|
|
fxActionCall_t& call = actionBuffer[actionBufferPos % 8];
|
|
call.time = time;
|
|
viewCallbacksID = call.viewCallbacksID;
|
|
if (call.actionType == FXACTION_START) {
|
|
InternalStartFX(call);
|
|
} else {
|
|
InternalStopFX(call);
|
|
}
|
|
}
|
|
UpdateActions(parentOrigin, parentAxis, parentVelocity, time,
|
|
gameMsPerFrame, frameNumber, fovScale, depthHack);
|
|
}
|
|
|
|
void idFXManager::ResetTreeAnimator(idTreeAnimator* const treeAnimator) {
|
|
ta = treeAnimator;
|
|
EnumerateTags();
|
|
}
|
|
|
|
void idFXManager::Serialize(idSerializer& serializer) {
|
|
GameLib_SerializeFXManager(serializer, *this);
|
|
}
|
|
|
|
void idFXManager::FreeActions() {
|
|
for (int index = 0; index < actions.Num(); ++index) {
|
|
idFXActionParameters parameters{};
|
|
if (GameLib_GetFXActionParameters(fxDecl, index, parameters)) {
|
|
GameLib_FreeFXActionResource(gameLibEffects, parameters,
|
|
actions[index]);
|
|
}
|
|
actions[index].tagData.Clear();
|
|
}
|
|
actions.Clear();
|
|
actionState.Clear();
|
|
}
|
|
|
|
void idFXManager::Shutdown() {
|
|
if (fxDecl != nullptr) {
|
|
StopActions(0, FX_NONE, FX_EXTRA_COND_NONE, true, true);
|
|
FreeActions();
|
|
}
|
|
initialized = false;
|
|
fxDecl = nullptr;
|
|
gameLibEffects = nullptr;
|
|
ta = nullptr;
|
|
rw = nullptr;
|
|
soundInfo.emitter = nullptr;
|
|
soundInfo.channel = SND_CHANNEL_ANY;
|
|
declChangeId = -1;
|
|
actionBufferPos = 0;
|
|
serializeActionCount = 0;
|
|
}
|