Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/ryzom/client/src/attached_fx.cpp

448 lines
13 KiB
C++
Raw Normal View History

Fixed EOL issues and added .hgeol file.
2012-05-29 13:31:11 +00:00
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
#include "stdpch.h"
#include "nel/misc/matrix.h"
#include "nel/3d/u_scene.h"
#include "nel/3d/u_transform.h"
#include "nel/3d/u_skeleton.h"
#include "nel/3d/u_bone.h"
#include "attached_fx.h"
#include "character_cl.h"
#include "user_entity.h"
#include "entities.h"
#include "time_client.h"
#include "fx_manager.h"
extern NL3D::UScene *Scene;
using namespace NLMISC;
using namespace NL3D;
extern CUserEntity *UserEntity;
// *************************************************************************************
CAttachedFX::CAttachedFX()
{
clear();
}
// *************************************************************************************
CAttachedFX::~CAttachedFX()
{
clear();
}
// ***********************************************************************************************************************
void CAttachedFX::clear()
{
if (!FX.empty())
{
if (StickMode == CFXStickMode::SpawnPermanent)
{
FXMngr.addFX(FX, 100.f);
}
else
{
Scene->deleteInstance(FX);
}
}
FX = NULL;
AniFX = NULL;
TimeOutDate = FX_MANAGER_DEFAULT_TIMEOUT;
StickMode = CFXStickMode::Follow;
MaxAnimCount = 0;
UserBoneID = ~0;
TargeterUserBoneID = 0xff;
}
// ***********************************************************************************************************************
void CAttachedFX::create(CCharacterCL &parent,
const CBuildInfo &buildInfo,
const CTargeterInfo &targeterInfo
)
{
clear();
if (!buildInfo.Sheet) return;
UParticleSystemInstance instance = buildInfo.Sheet->createMatchingInstance();
// TODO nico : user params are not in the buildInfo, but are set by createMatchingInstance then by the caller (they could be set directly by createMatchingInstance)
if (instance.empty()) return;
create(parent, instance, buildInfo, targeterInfo);
}
// ***********************************************************************************************************************
void CAttachedFX::create(CCharacterCL &parent,
NL3D::UParticleSystemInstance instance,
const CBuildInfo &buildInfo,
const CTargeterInfo &targeterInfo
)
{
nlassert(buildInfo.Sheet);
TimeOutDate = buildInfo.TimeOut;
const CFXStickMode *stickMode = buildInfo.StickMode ? buildInfo.StickMode : &buildInfo.Sheet->Sheet->StickMode;
if (!instance.empty())
{
instance.setClusterSystem(parent.getClusterSystem());
instance.setTransformMode(NL3D::UTransformable::DirectMatrix);
instance.show();
}
FX = instance;
AniFX = buildInfo.Sheet;
StickMode = stickMode->Mode;
SpawnTime = TimeInSec;
MaxAnimCount = buildInfo.MaxNumAnimCount;
TargeterInfo = targeterInfo;
switch(stickMode->Mode)
{
case CFXStickMode::StaticMatrix:
{
const CMatrix &staticMatrix = buildInfo.StaticMatrix ? *buildInfo.StaticMatrix : NLMISC::CMatrix::Identity;
instance.setMatrix(staticMatrix);
SpawnPos = staticMatrix.getPos();
}
break;
case CFXStickMode::Spawn:
case CFXStickMode::SpawnPermanent:
{
parent.alignFX(instance, parent.getScalePos());
SpawnPos = parent.pos() + buildInfo.StickOffset;
if (stickMode->Mode == CFXStickMode::SpawnPermanent)
{
instance.forceInstanciate();
}
}
break;
case CFXStickMode::UserBone:
{
if (parent.skeleton())
{
sint boneID = parent.skeleton()->getBoneIdByName(NLMISC::CStringMapper::unmap(stickMode->UserBoneName));
UserBoneID = boneID;
if (boneID != -1)
{
parent.skeleton()->stickObjectEx(instance, boneID, true);
NLMISC::CMatrix mat = instance.getMatrix();
mat.scale(buildInfo.Sheet->Sheet->ScaleFX ? parent.getScaleRef() : 1.f);
mat.setPos(buildInfo.StickOffset);
if (!instance.empty()) instance.setMatrix(mat);
SpawnPos = buildInfo.StickOffset;
// if parent is hidden, then force to compute the bone at least once
if (parent.skeleton()->getVisibility() == NL3D::UTransform::Hide)
{
parent.forceEvalAnim();
// force to compute fx at least once
parent.skeleton()->forceComputeBone(UserBoneID);
}
break;
}
}
// bone not found or no skeleton
if (!parent.instance().empty())
{
instance.parent(parent.instance());
SpawnPos = buildInfo.StickOffset;
}
else
{
// just spawn at position of entity
SpawnPos = parent.pos() + buildInfo.StickOffset;
}
}
break;
case CFXStickMode::UserBoneOrientedTowardTargeter:
if (parent.skeleton())
{
UserBoneID = parent.skeleton()->getBoneIdByName(NLMISC::CStringMapper::unmap(stickMode->UserBoneName));
if (UserBoneID == 0xff)
{
nlwarning("Bad bone name : %s", NLMISC::CStringMapper::unmap(stickMode->UserBoneName).c_str());
}
}
else
{
UserBoneID = 0xff;
}
SpawnPos = buildInfo.StickOffset;
update(parent, CMatrix::Identity);
break;
case CFXStickMode::UserBoneRay:
if (parent.skeleton())
{
UserBoneID = parent.skeleton()->getBoneIdByName(NLMISC::CStringMapper::unmap(stickMode->UserBoneName));
if (UserBoneID == 0xff)
{
nlwarning("Bad bone name : %s", NLMISC::CStringMapper::unmap(stickMode->UserBoneName).c_str());
}
}
else
{
UserBoneID = 0xff;
}
SpawnPos = buildInfo.StickOffset;
TargeterUserBoneID =0xff;
if (targeterInfo.StickMode.UserBoneName != 0)
{
CEntityCL *targeter = EntitiesMngr.entity(TargeterInfo.Slot);
if (targeter && targeter->skeleton())
{
TargeterUserBoneID = parent.skeleton()->getBoneIdByName(NLMISC::CStringMapper::unmap(TargeterInfo.StickMode.UserBoneName));
}
}
update(parent, CMatrix::Identity);
break;
case CFXStickMode::OrientedTowardTargeter:
SpawnPos = buildInfo.StickOffset;
update(parent, CMatrix::Identity);
break;
default: // -> stick fx in 'Follow' mode
parent.alignFX(instance, parent.getScalePos());
SpawnPos = buildInfo.StickOffset;
break;
}
}
// ***********************************************************************************************************************
void CAttachedFX::evalTargeterStickPos(NLMISC::CVector &dest) const
{
CEntityCL *targeter = EntitiesMngr.entity(TargeterInfo.Slot);
if (!targeter)
{
dest = TargeterInfo.DefaultPos;
return;
}
switch(TargeterInfo.StickMode.Mode)
{
case CFXStickMode::Spawn:
case CFXStickMode::SpawnPermanent:
case CFXStickMode::Follow:
case CFXStickMode::FollowNoRotation:
case CFXStickMode::OrientedTowardTargeter:
dest = targeter->pos();
break;
case CFXStickMode::StaticMatrix:
nlwarning("Not implemented"); // this case is not used for now
dest = targeter->pos();
break;
case CFXStickMode::UserBoneOrientedTowardTargeter:
case CFXStickMode::UserBoneRay:
case CFXStickMode::UserBone:
if (targeter->skeleton() && TargeterUserBoneID != 0xff)
{
const UBone bone = targeter->skeleton()->getBone(TargeterUserBoneID);
targeter->forceEvalAnim();
targeter->skeleton()->forceComputeBone(TargeterUserBoneID);
dest = bone.getLastWorldMatrixComputed() * TargeterInfo.StickOffset;
}
else
{
dest = TargeterInfo.DefaultPos;
}
break;
};
}
// ***********************************************************************************************************************
void CAttachedFX::update(CCharacterCL &parent, const NLMISC::CMatrix &alignMatrix)
{
if (AniFX && !FX.empty())
{
NLMISC::CVector trackPos;
// see if fx has a track applied on it
if (AniFX->PosTrack)
{
// eval current pos
AniFX->PosTrack->interpolate((float) (TimeInSec - SpawnTime), trackPos);
}
else
{
trackPos.set(0.f, 0.f, 0.f);
}
// apply pos depending on mode
switch(StickMode)
{
case CFXStickMode::UserBone:
{
FX.setClusterSystem(parent.getClusterSystem());
if (!AniFX->PosTrack)
{
// no track for fx,
if (parent.skeleton() && UserBoneID != 0xff)
{
if (parent.skeleton()->getVisibility() == UTransform::Hide)
{
// if user no visible, force to compute the bone.
parent.forceEvalAnim();
parent.skeleton()->forceComputeBone(UserBoneID);
}
}
return;
}
if (parent.skeleton())
{
if (UserBoneID != 0xff)
{
CMatrix mat = FX.getMatrix();
mat.setPos(trackPos + SpawnPos);
mat.setScale(AniFX->Sheet->ScaleFX ? parent.getScaleRef() : 1.f);
FX.setMatrix(mat);
if (&parent == UserEntity && UserEntity->skeleton())
{
if (UserEntity->skeleton()->getVisibility() == UTransform::Hide)
{
// if user no visible, force to compute the bone.
parent.forceEvalAnim();
UserEntity->skeleton()->forceComputeBone(UserBoneID);
}
}
}
}
// no skeleton or bone not found
if (!parent.instance().empty())
{
CMatrix mat = FX.getMatrix();
mat.setPos(trackPos + SpawnPos);
mat.setScale(AniFX->Sheet->ScaleFX ? parent.getScaleRef() : 1.f);
FX.setMatrix(mat);
}
else
{
// no skeleton, no instance
CMatrix mat = FX.getMatrix();
mat.setPos(trackPos + SpawnPos + parent.pos());
mat.setScale(AniFX->Sheet->ScaleFX ? parent.getScaleRef() : 1.f);
FX.setMatrix(mat);
}
}
break;
case CFXStickMode::Follow:
// just change local pos
parent.alignFX(FX, alignMatrix, AniFX->Sheet->ScaleFX ? parent.getScaleRef() : 1.f, trackPos + SpawnPos);
break;
case CFXStickMode::FollowNoRotation:
{
// just update the pos
CMatrix mat = FX.getMatrix();
mat.setScale(AniFX->Sheet->ScaleFX ? parent.getScaleRef() : 1.f);
mat.setPos(trackPos + parent.pos().asVector());
FX.setMatrix(mat);
FX.setClusterSystem(parent.getClusterSystem());
}
break;
case CFXStickMode::StaticObjectCastRay:
{
// if not animated need no updates
if (!AniFX->PosTrack) return;
nlwarning("Not implemented");
}
break;
case CFXStickMode::Spawn:
case CFXStickMode::SpawnPermanent:
{
if (!AniFX->PosTrack) return;
// put in local basis and offset spawn pos
CMatrix mat = FX.getMatrix();
mat.setScale(AniFX->Sheet->ScaleFX ? parent.getScaleRef() : 1.f);
mat.setPos(SpawnPos + FX.getMatrix().mulVector(trackPos));
FX.setMatrix(mat);
// Do not update the cluster system because fx stays in place
}
break;
case CFXStickMode::OrientedTowardTargeter:
{
CEntityCL *targeter = EntitiesMngr.entity(TargeterInfo.Slot);
if (targeter)
{
CVectorD orientD = parent.pos() - targeter->pos();
CVector J((float) orientD.x, (float) orientD.y, 0.f); // project on XY plane
J.normalize();
CVector I = J ^ CVector::K;
CMatrix mat;
mat.setRot(I, J, CVector::K);
mat.setScale(AniFX->Sheet->ScaleFX ? parent.getScaleRef() : 1.f);
mat.setPos(trackPos + parent.pos().asVector());
FX.setMatrix(mat);
FX.setClusterSystem(parent.getClusterSystem());
}
}
break;
case CFXStickMode::UserBoneOrientedTowardTargeter:
{
CEntityCL *targeter = EntitiesMngr.entity(TargeterInfo.Slot);
if (targeter)
{
CVector orientD;
CMatrix orientMat;
if (UserBoneID == 0xff || !parent.skeleton())
{
// bone not found -> use parent position instead
orientD = parent.pos() - targeter->pos();
orientMat.setPos(trackPos + parent.pos());
}
else
{
const UBone bone = parent.skeleton()->getBone(UserBoneID);
parent.forceEvalAnim();
parent.skeleton()->forceComputeBone(UserBoneID);
const CMatrix &wm = bone.getLastWorldMatrixComputed();
// compute orientation toward targeter, and build a matrix from it
orientD = wm.getPos() - targeter->pos().asVector();
orientMat.setPos(trackPos + wm.getPos());
}
CVector J(orientD.x, orientD.y, 0.f); // project on XY plane
J.normalize();
CVector I = J ^ CVector::K;
float scale = AniFX->Sheet->ScaleFX ? parent.getScaleRef() : 1.f;
orientMat.setRot(scale * I, scale * J, scale * CVector::K, true);
FX.setMatrix(orientMat);
FX.setClusterSystem(parent.getClusterSystem());
}
}
break;
case CFXStickMode::UserBoneRay:
{
CVector aimingPoint;
evalTargeterStickPos(aimingPoint);
CVector startPoint = CVector::Null;
if (UserBoneID != 0xff && parent.skeleton())
{
const UBone bone = parent.skeleton()->getBone(UserBoneID);
parent.forceEvalAnim();
parent.skeleton()->forceComputeBone(UserBoneID);
startPoint = bone.getLastWorldMatrixComputed().getPos();
}
CMatrix rayMat;
CVector ray = aimingPoint - startPoint;
CVector I = ray.normed();
CVector K = (CVector::K - (I * CVector::K) * I).normed();
CVector J = K ^ I;
if (AniFX)
{
I *= ray.norm() / AniFX->Sheet->RayRefLength;
}
rayMat.setRot(I, J, K);
rayMat.setPos(startPoint + 0.5f * AniFX->Sheet->RayRefLength * I);
FX.setMatrix(rayMat);
// don't clusterize ray, because it can be quite large
FX.setForceClipRoot(true);
}
}
}
}
Reference in a new issue Copy permalink