aleajactaest/khanat-code-old
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-code-old.git synced 2024-11-24 15:56:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-code-old/code/nel/src/3d/ps_ribbon_base.cpp

816 lines
22 KiB
C++
Raw Normal View History

fix windows warnings in sync
2014-09-10 00:20:23 +00:00
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// 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 "std3d.h"
#include "nel/misc/common.h"
#include "nel/3d/ps_ribbon_base.h"
#include "nel/3d/particle_system.h"
namespace NL3D
{
////////////////////////////////////
// CPSRibbonBase implementation //
////////////////////////////////////
/// build some hermite spline value, with the given points and tangents
static inline void BuildHermiteVector(const NLMISC::CVector &P0,
const NLMISC::CVector &P1,
const NLMISC::CVector &T0,
const NLMISC::CVector &T1,
NLMISC::CVector &dest,
float lambda
)
{
NL_PS_FUNC(BuildHermiteVector)
const float lambda2 = lambda * lambda;
const float lambda3 = lambda2 * lambda;
const float h1 = 2 * lambda3 - 3 * lambda2 + 1;
const float h2 = - 2 * lambda3 + 3 * lambda2;
const float h3 = lambda3 - 2 * lambda2 + lambda;
const float h4 = lambda3 - lambda2;
/// just avoid some ctor calls here...
dest.set (h1 * P0.x + h2 * P1.x + h3 * T0.x + h4 * T1.x,
h1 * P0.y + h2 * P1.y + h3 * T0.y + h4 * T1.y,
h1 * P0.z + h2 * P1.z + h3 * T0.z + h4 * T1.z);
}
/// for test
static inline void BuildLinearVector(const NLMISC::CVector &P0,
const NLMISC::CVector &P1,
NLMISC::CVector &dest,
float lambda,
float oneMinusLambda
)
{
NL_PS_FUNC(BuildLinearVector)
dest.set (lambda * P1.x + oneMinusLambda * P0.x,
lambda * P1.y + oneMinusLambda * P0.y,
lambda * P1.z + oneMinusLambda * P0.z);
}
const uint EndRibbonStorage = 1;
//=======================================================
CPSRibbonBase::CPSRibbonBase() : _NbSegs(8),
_SegDuration(0.02f),
_Parametric(false),
_RibbonIndex(0),
_MatrixMode(FatherMatrix),
_LastUpdateDate(0),
_RibbonMode(VariableSize),
_InterpolationMode(Hermitte),
_RibbonLength(1),
_SegLength(_RibbonLength / _NbSegs),
_LODDegradation(1)
{
NL_PS_FUNC(CPSRibbonBase_CPSRibbonBase)
initDateVect();
}
//=======================================================
void CPSRibbonBase::setMatrixMode(TMatrixMode matrixMode)
{
NL_PS_FUNC(CPSRibbonBase_setMatrixMode)
if (matrixMode == _MatrixMode) return;
if (_Owner) resetFromOwner();
_MatrixMode = matrixMode;
}
//=======================================================
void CPSRibbonBase::setRibbonLength(float length)
{
NL_PS_FUNC(CPSRibbonBase_setRibbonLength)
nlassert(length > 0.f);
_RibbonLength = length;
_SegLength = length / _NbSegs;
}
//=======================================================
void CPSRibbonBase::setRibbonMode(TRibbonMode mode)
{
NL_PS_FUNC(CPSRibbonBase_setRibbonMode)
nlassert(mode < RibbonModeLast);
_RibbonMode = mode;
}
//=======================================================
void CPSRibbonBase::setInterpolationMode(TInterpolationMode mode)
{
NL_PS_FUNC(CPSRibbonBase_setInterpolationMode)
nlassert(mode < InterpModeLast);
_InterpolationMode = mode;
}
//=======================================================
void CPSRibbonBase::setTailNbSeg(uint32 nbSegs)
{
NL_PS_FUNC(CPSRibbonBase_setTailNbSeg)
nlassert(nbSegs >= 1);
_NbSegs = nbSegs;
_RibbonIndex = 0;
if (_Owner)
{
resize(_Owner->getMaxSize());
}
initDateVect();
}
//=======================================================
void CPSRibbonBase::setSegDuration(TAnimationTime ellapsedTime)
{
NL_PS_FUNC(CPSRibbonBase_setSegDuration)
_SegDuration = ellapsedTime;
}
//=======================================================
void CPSRibbonBase::updateGlobals()
{
NL_PS_FUNC(CPSRibbonBase_updateGlobals)
nlassert(!_Parametric);
nlassert(_Owner);
const uint size = _Owner->getSize();
if (!size) return;
const TAnimationTime currDate = _Owner->getOwner()->getSystemDate() + CParticleSystem::RealEllapsedTime;
if (currDate - _LastUpdateDate >= _SegDuration)
{
if (_RibbonIndex == 0) _RibbonIndex = _NbSegs + EndRibbonStorage;
else --_RibbonIndex;
/// decal date
::memmove(&_SamplingDate[1], &_SamplingDate[0], sizeof(float) * (_NbSegs + EndRibbonStorage));
_LastUpdateDate = currDate;
}
/// save current date
_SamplingDate[0] = currDate;
/// updating ribbons positions
TPSMatrixMode mm = convertMatrixMode();
if (mm == _Owner->getMatrixMode())
{
// trail reside in the same coord system -> no conversion needed
TPSAttribVector::iterator posIt = _Owner->getPos().begin();
NLMISC::CVector *currIt = &_Ribbons[_RibbonIndex];
uint k = size;
for (;;)
{
*currIt = *posIt;
--k;
if (!k) break;
++posIt;
currIt += (_NbSegs + 1 + EndRibbonStorage);
}
}
else
{
nlassert(_Owner->getOwner());
const CMatrix &mat = CPSLocated::getConversionMatrix(*_Owner->getOwner(), mm, _Owner->getMatrixMode());
TPSAttribVector::iterator posIt = _Owner->getPos().begin();
NLMISC::CVector *currIt = &_Ribbons[_RibbonIndex];
uint k = size;
for (;;)
{
*currIt = mat * *posIt;
--k;
if (!k) break;
++posIt;
currIt += (_NbSegs + 1 + EndRibbonStorage);
}
}
}
//=======================================================
void CPSRibbonBase::computeHermitteRibbon(uint index, NLMISC::CVector *dest, uint stride /* = sizeof(NLMISC::CVector)*/)
{
NL_PS_FUNC(CPSRibbonBase_CVector )
nlassert(!_Parametric);
NLMISC::CVector *startIt = &_Ribbons[(_NbSegs + 1 + EndRibbonStorage) * index];
NLMISC::CVector *endIt = startIt + (_NbSegs + 1 + EndRibbonStorage);
NLMISC::CVector *currIt = startIt + _RibbonIndex;
const NLMISC::CVector *firstIt = currIt;
NLMISC::CVector *nextIt = currIt + 1;
if (nextIt == endIt) nextIt = startIt;
NLMISC::CVector *nextNextIt = nextIt + 1;
if (nextNextIt == endIt) nextNextIt = startIt;
float *date = &_SamplingDate[0];
NLMISC::CVector t0 = (*nextIt - *currIt);
NLMISC::CVector t1 = 0.5f * (*nextNextIt - *currIt);
uint leftToDo = _UsedNbSegs + 1;
float lambda = 0.f;
float lambdaStep = 1.f;
for (;;)
{
float dt = date[0] - date[1];
if (dt < 10E-6f) // we reached the start of ribbon
{
do
{
*dest = *currIt;
#ifdef NL_DEBUG
nlassert(NLMISC::isValidDouble(dest->x));
nlassert(NLMISC::isValidDouble(dest->y));
nlassert(NLMISC::isValidDouble(dest->z));
#endif
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
}
while (--leftToDo);
return;
}
float newLambdaStep = _UsedSegDuration / dt;
// readapt lambda
lambda *= newLambdaStep / lambdaStep;
lambdaStep = newLambdaStep;
for(;;)
{
if (lambda >= 1.f) break;
/// compute a location
BuildHermiteVector(*currIt, *nextIt, t0, t1, *dest, lambda);
#ifdef NL_DEBUG
nlassert(NLMISC::isValidDouble(dest->x));
nlassert(NLMISC::isValidDouble(dest->y));
nlassert(NLMISC::isValidDouble(dest->z));
#endif
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
-- leftToDo;
if (!leftToDo) return;
lambda += lambdaStep;
}
++date;
lambda -= 1.f;
// Start new segment and compute new tangents
t0 = t1;
currIt = nextIt;
nextIt = nextNextIt;
++nextNextIt;
if (nextNextIt == endIt) nextNextIt = startIt;
if (nextNextIt == firstIt)
{
t1 = *nextIt - *currIt;
}
else
{
t1 = 0.5f * (*nextNextIt - *currIt);
}
}
}
//=======================================================
void CPSRibbonBase::computeLinearRibbon(uint index, NLMISC::CVector *dest, uint stride)
{
NL_PS_FUNC(CPSRibbonBase_computeLinearRibbon)
nlassert(!_Parametric);
NLMISC::CVector *startIt = &_Ribbons[(_NbSegs + 1 + EndRibbonStorage) * index];
NLMISC::CVector *endIt = startIt + (_NbSegs + 1 + EndRibbonStorage);
NLMISC::CVector *currIt = startIt + _RibbonIndex;
NLMISC::CVector *nextIt = currIt + 1;
if (nextIt == endIt) nextIt = startIt;
NLMISC::CVector *nextNextIt = nextIt + 1;
if (nextNextIt == endIt) nextNextIt = startIt;
float *date = &_SamplingDate[0];
uint leftToDo = _UsedNbSegs + 1;
float lambda = 0.f;
float lambdaStep = 1.f;
for (;;)
{
float dt = date[0] - date[1];
if (dt < 10E-6f) // we reached the start of ribbon
{
do
{
*dest = *currIt;
#ifdef NL_DEBUG
nlassert(NLMISC::isValidDouble(dest->x));
nlassert(NLMISC::isValidDouble(dest->y));
nlassert(NLMISC::isValidDouble(dest->z));
#endif
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
}
while (--leftToDo);
return;
}
float newLambdaStep = _UsedSegDuration / dt;
// readapt lambda
lambda *= newLambdaStep / lambdaStep;
lambdaStep = newLambdaStep;
float oneMinusLambda = 1.f - lambda;
for(;;)
{
if (lambda >= 1.f) break;
/// compute a location
BuildLinearVector(*currIt, *nextIt, *dest, lambda, oneMinusLambda);
#ifdef NL_DEBUG
nlassert(NLMISC::isValidDouble(dest->x));
nlassert(NLMISC::isValidDouble(dest->y));
nlassert(NLMISC::isValidDouble(dest->z));
#endif
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
-- leftToDo;
if (!leftToDo) return;
lambda += lambdaStep;
oneMinusLambda -= lambdaStep;
}
++date;
lambda -= 1.f;
currIt = nextIt;
nextIt = nextNextIt;
++nextNextIt;
if (nextNextIt == endIt) nextNextIt = startIt;
}
}
/*
void CPSRibbonBase::computeLinearRibbon(uint index, NLMISC::CVector *dest, uint stride)
{
nlassert(!_Parametric);
NLMISC::CVector *startIt = &_Ribbons[(_NbSegs + 1 + EndRibbonStorage) * index];
NLMISC::CVector *endIt = startIt + (_NbSegs + 1 + EndRibbonStorage);
NLMISC::CVector *currIt = startIt + _RibbonIndex;
NLMISC::CVector *nextIt = currIt + 1;
if (nextIt == endIt) nextIt = startIt;
NLMISC::CVector *nextNextIt = nextIt + 1;
if (nextNextIt == endIt) nextNextIt = startIt;
float *date = &_SamplingDate[0];
uint leftToDo = _UsedNbSegs + 1;
float lambda = 0.f;
float dt = date[0] - date[1];
if (dt < 10E-6f) // we reached the start of ribbon
{
do
{
*dest = *currIt;
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
}
while (--leftToDo);
return;
}
float lambdaStep = _UsedSegDuration / dt;
BuildLinearVector(*currIt, *nextIt, *dest, 0.f, 1.f);
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
-- leftToDo;
// snap lambda to nearest time step
lambda = lambdaStep * fmodf(date[0], _UsedSegDuration) / _UsedSegDuration;
for (;;)
{
float oneMinusLambda = 1.f - lambda;
for(;;)
{
if (lambda >= 1.f) break;
/// compute a location
BuildLinearVector(*currIt, *nextIt, *dest, lambda, oneMinusLambda);
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
-- leftToDo;
if (!leftToDo) return;
lambda += lambdaStep;
oneMinusLambda -= lambdaStep;
}
++date;
lambda -= 1.f;
currIt = nextIt;
nextIt = nextNextIt;
++nextNextIt;
if (nextNextIt == endIt) nextNextIt = startIt;
float dt = date[0] - date[1];
if (dt < 10E-6f) // we reached the start of ribbon
{
do
{
*dest = *currIt;
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
}
while (--leftToDo);
return;
}
float newLambdaStep = _UsedSegDuration / dt;
// readapt lambda
lambda *= newLambdaStep / lambdaStep;
lambdaStep = newLambdaStep;
}
}
*/
//=======================================================
void CPSRibbonBase::computeLinearCstSizeRibbon(uint index, NLMISC::CVector *dest, uint stride /* = sizeof(NLMISC::CVector)*/)
{
NL_PS_FUNC(CPSRibbonBase_CVector )
nlassert(!_Parametric);
CVector *startIt = &_Ribbons[(_NbSegs + 1 + EndRibbonStorage) * index];
NLMISC::CVector *endIt = startIt + (_NbSegs + 1 + EndRibbonStorage);
NLMISC::CVector *currIt = startIt + _RibbonIndex;
NLMISC::CVector *firstIt = currIt;
NLMISC::CVector *nextIt = currIt + 1;
if (nextIt == endIt) nextIt = startIt;
NLMISC::CVector *nextNextIt = nextIt + 1;
if (nextNextIt == endIt) nextNextIt = startIt;
uint leftToDo = _UsedNbSegs + 1;
float lambda = 0.f;
float lambdaStep = 1.f;
/// Our goal here is to match the length of the ribbon, But if it isn't moving fast enough, we must truncate it
for (;;)
{
/// compute length between the 2 sampling points
const float sampleLength = (*nextIt - *currIt).norm();
if (sampleLength > 10E-6f)
{
/// compute lambda so that it match the length needed for each segment
float newLambdaStep = _UsedSegLength / sampleLength;
// readapt lambda
lambda *= newLambdaStep / lambdaStep;
lambdaStep = newLambdaStep;
float oneMinusLambda = 1.f - lambda;
for(;;)
{
if (lambda >= 1.f) break;
/// compute a location
BuildLinearVector(*currIt, *nextIt, *dest, lambda, oneMinusLambda);
#ifdef NL_DEBUG
nlassert(NLMISC::isValidDouble(dest->x));
nlassert(NLMISC::isValidDouble(dest->y));
nlassert(NLMISC::isValidDouble(dest->z));
#endif
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
-- leftToDo;
if (!leftToDo) return;
lambda += lambdaStep;
oneMinusLambda -= lambdaStep;
}
lambda -= 1.f;
}
/// go to next sampling pos
currIt = nextIt;
nextIt = nextNextIt;
++nextNextIt;
if (nextNextIt == endIt) nextNextIt = startIt;
if (nextNextIt == firstIt)
{
// The length of the sampling curve is too short
// must truncate the ribbon.
NLMISC::CVector &toDup = *nextIt;
while (leftToDo --)
{
*dest = toDup;
#ifdef NL_DEBUG
nlassert(NLMISC::isValidDouble(dest->x));
nlassert(NLMISC::isValidDouble(dest->y));
nlassert(NLMISC::isValidDouble(dest->z));
#endif
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
}
return;
}
}
}
//=======================================================
void CPSRibbonBase::computeHermitteCstSizeRibbon(uint index, NLMISC::CVector *dest, uint stride /* = sizeof(NLMISC::CVector)*/)
{
NL_PS_FUNC(CPSRibbonBase_CVector )
nlassert(!_Parametric);
NLMISC::CVector *startIt = &_Ribbons[(_NbSegs + 1 + EndRibbonStorage) * index];
NLMISC::CVector *endIt = startIt + (_NbSegs + 1 + EndRibbonStorage);
NLMISC::CVector *currIt = startIt + _RibbonIndex;
NLMISC::CVector *firstIt = currIt;
NLMISC::CVector *nextIt = currIt + 1;
if (nextIt == endIt) nextIt = startIt;
NLMISC::CVector *nextNextIt = nextIt + 1;
if (nextNextIt == endIt) nextNextIt = startIt;
NLMISC::CVector t0 = (*nextIt - *currIt);
NLMISC::CVector t1 = 0.5f * (*nextNextIt - *currIt);
uint leftToDo = _UsedNbSegs + 1;
float lambda = 0.f;
float lambdaStep = 1.f;
/// Our goal here is to match the length of the ribbon, But if it isn't moving fast enough, we must truncate it
/// Having a constant speed over a hermite curve is expensive, so we make a (very) rough approximation...
for (;;)
{
/// compute length between the 2 sampling points
const float sampleLength = (*nextIt - *currIt).norm();
if (sampleLength > 10E-6f)
{
/// compute lambda so that it match the length needed for each segment
float newLambdaStep = _UsedSegLength / sampleLength;
// readapt lambda
lambda *= newLambdaStep / lambdaStep;
lambdaStep = newLambdaStep;
for(;;)
{
if (lambda >= 1.f) break;
/// compute a location
BuildHermiteVector(*currIt, *nextIt, t0, t1, *dest, lambda);
#ifdef NL_DEBUG
nlassert(NLMISC::isValidDouble(dest->x));
nlassert(NLMISC::isValidDouble(dest->y));
nlassert(NLMISC::isValidDouble(dest->z));
#endif
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
-- leftToDo;
if (!leftToDo) return;
lambda += lambdaStep;
}
lambda -= 1.f;
}
/// go to next sampling pos
currIt = nextIt;
nextIt = nextNextIt;
++nextNextIt;
if (nextNextIt == endIt) nextNextIt = startIt;
if (nextNextIt == firstIt)
{
// The length of the sampling curve is too short
// must truncate the ribbon.
NLMISC::CVector &toDup = *nextIt;
while (leftToDo --)
{
*dest = toDup;
#ifdef NL_DEBUG
nlassert(NLMISC::isValidDouble(dest->x));
nlassert(NLMISC::isValidDouble(dest->y));
nlassert(NLMISC::isValidDouble(dest->z));
#endif
dest = (NLMISC::CVector *) ((uint8 *) dest + stride);
}
return;
}
/// update tangents
t0 = t1;
t1 = 0.5f * (*nextNextIt - *currIt);
}
}
//=======================================================
void CPSRibbonBase::computeRibbon(uint index, NLMISC::CVector *dest, uint stride /* = sizeof(NLMISC::CVector)*/)
{
NL_PS_FUNC(CPSRibbonBase_CVector )
switch (_InterpolationMode)
{
case Linear:
if (_RibbonMode == VariableSize)
{
computeLinearRibbon(index, dest, stride);
}
else
{
computeLinearCstSizeRibbon(index, dest, stride);
}
break;
case Hermitte:
if (_RibbonMode == VariableSize)
{
computeHermitteRibbon(index, dest, stride);
}
else
{
computeHermitteCstSizeRibbon(index, dest, stride);
}
break;
default:
nlassert(0);
break;
}
}
//=======================================================
void CPSRibbonBase::dupRibbon(uint dest, uint src)
{
NL_PS_FUNC(CPSRibbonBase_dupRibbon)
nlassert(!_Parametric);
nlassert(_Owner);
const uint size = _Owner->getSize();
nlassert(dest < size && src < size);
::memcpy(&_Ribbons[dest * (_NbSegs + EndRibbonStorage + 1)], &_Ribbons[src * (_NbSegs + EndRibbonStorage + 1)], sizeof(NLMISC::CVector) * (_NbSegs + 1 + EndRibbonStorage));
}
//=======================================================
void CPSRibbonBase::newElement(const CPSEmitterInfo &info)
{
NL_PS_FUNC(CPSRibbonBase_newElement)
if (_Parametric) return;
/// dump the same pos for all pos of the ribbon
const uint index = _Owner->getNewElementIndex();
const NLMISC::CVector &pos = _Owner->getPos()[index]; // get the pos of the new element;
resetSingleRibbon(index, pos);
}
//=======================================================
void CPSRibbonBase::deleteElement(uint32 index)
{
NL_PS_FUNC(CPSRibbonBase_deleteElement)
if (_Parametric) return;
const uint32 size = _Owner->getSize();
if(index == (size - 1)) return; // was the last element, no permutation needed.
dupRibbon(index, size - 1);
}
//=======================================================
void CPSRibbonBase::resize(uint32 size)
{
NL_PS_FUNC(CPSRibbonBase_resize)
nlassert(size < (1 << 16));
if (_Parametric) return;
_Ribbons.resize(size * (_NbSegs + 1 + EndRibbonStorage));
resetFromOwner();
}
//=======================================================
void CPSRibbonBase::resetSingleRibbon(uint index, const NLMISC::CVector &pos)
{
NL_PS_FUNC(CPSRibbonBase_resetSingleRibbon)
nlassert(!_Parametric);
TPSMatrixMode mm = convertMatrixMode();
NLMISC::CVector *it = &_Ribbons[(index * (_NbSegs + 1 + EndRibbonStorage))];
if (mm == _Owner->getMatrixMode())
{
std::fill(it, it + (_NbSegs + 1 + EndRibbonStorage), pos);
}
else
{
nlassert(_Owner->getOwner());
const CMatrix &mat = CPSLocated::getConversionMatrix(*_Owner->getOwner(), mm, _Owner->getMatrixMode());
std::fill(it, it + (_NbSegs + 1 + EndRibbonStorage), mat * pos);
}
}
//=======================================================
void CPSRibbonBase::resetFromOwner()
{
NL_PS_FUNC(CPSRibbonBase_resetFromOwner)
nlassert(!_Parametric);
TPSAttribVector::iterator posIt = _Owner->getPos().begin();
TPSAttribVector::iterator endPosIt = _Owner->getPos().end();
for (uint k = 0; posIt != endPosIt; ++posIt, ++k)
{
resetSingleRibbon(k, *posIt);
}
}
//=======================================================
void CPSRibbonBase::motionTypeChanged(bool parametric)
{
NL_PS_FUNC(CPSRibbonBase_motionTypeChanged)
_Parametric = parametric;
if (parametric)
{
NLMISC::contReset(_Ribbons); // kill the vector
}
else
{
nlassert(_Owner);
resize(_Owner->getMaxSize());
initDateVect();
resetFromOwner();
}
}
//=======================================================
void CPSRibbonBase::initDateVect()
{
NL_PS_FUNC(CPSRibbonBase_initDateVect)
_SamplingDate.resize( _NbSegs + 1 + EndRibbonStorage);
std::fill(_SamplingDate.begin(), _SamplingDate.begin() + (_NbSegs + 1 + EndRibbonStorage), 0.f);
}
//=======================================================
void CPSRibbonBase::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
NL_PS_FUNC(CPSRibbonBase_serial)
CPSParticle::serial(f);
// version 2 : added matrix mode
sint ver = f.serialVersion(2);
f.serialEnum(_RibbonMode);
f.serialEnum(_InterpolationMode);
f.serial(_NbSegs, _SegDuration);
if (_RibbonMode == FixedSize)
{
f.serial(_RibbonLength);
if (f.isReading())
{
_SegLength = _RibbonLength / _NbSegs;
}
}
if (f.isReading())
{
if (_Owner)
{
resize(_Owner->getMaxSize());
initDateVect();
resetFromOwner();
}
}
if (ver >= 1)
{
f.serial(_LODDegradation);
}
if (ver >= 2)
{
f.serialEnum(_MatrixMode);
}
}
//=======================================================
void CPSRibbonBase::updateLOD()
{
NL_PS_FUNC(CPSRibbonBase_updateLOD)
nlassert(_Owner);
float ratio = _Owner->getOwner()->getOneMinusCurrentLODRatio();
float squaredRatio = ratio * ratio;
float lodRatio = _LODDegradation + (1.f - _LODDegradation ) * squaredRatio * squaredRatio * squaredRatio;
_UsedNbSegs = (uint) (_NbSegs * lodRatio);
NLMISC::clamp(_UsedNbSegs, 0u, _NbSegs);
const float epsilon = 10E-4f;
_UsedSegDuration = _SegDuration / std::max(epsilon, lodRatio);
_UsedSegLength = _SegLength / std::max(epsilon, lodRatio);
}
//=======================================================
void CPSRibbonBase::systemDateChanged()
{
NL_PS_FUNC(CPSRibbonBase_systemDateChanged)
nlassert(_Owner->getOwner());
_Owner->getOwner()->getSystemDate();
float date = _Owner->getOwner()->getSystemDate();
std::fill(_SamplingDate.begin(), _SamplingDate.end(), date);
_LastUpdateDate = date;
}
} // NL3D
Reference in a new issue Copy permalink