Khaganat-NeL/khanat-opennel-code
2
0
Fork 0
Code Issues 21 Pull requests Projects Releases 1 Packages Wiki Activity
khanat-opennel-code/code/nel/src/3d/seg_remanence.cpp
acemtp 1792297c93 initial version
2010-05-06 02:08:41 +02:00

581 lines
17 KiB
C++
Raw Blame History

// 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/3d/scene_group.h"
#include "nel/3d/seg_remanence.h"
#include "nel/3d/seg_remanence_shape.h"
#include "nel/3d/vertex_buffer.h"
#include "nel/3d/driver.h"
#include "nel/3d/scene.h"
#include "nel/3d/anim_detail_trav.h"
#include "nel/3d/skeleton_model.h"
#include "nel/3d/dru.h"
namespace NL3D
{
CVertexBuffer CSegRemanence::_VB;
CIndexBuffer CSegRemanence::_IB;
/// TODO : put this in a header (same code in ps_ribbon_base.cpp ..)
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
)
{
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);
}
//===============================================================
CSegRemanence::CSegRemanence() : _NumSlices(0),
_Started(false),
_Stopping(false),
_Restarted(false),
_UnrollRatio(0),
_SliceTime(0.05f),
_AniMat(NULL),
_LastSampleFrame(0)
{
IAnimatable::resize(AnimValueLast);
// RenderFilter: We are a SegRemanece
_RenderFilterType= UScene::FilterSegRemanence;
}
//===============================================================
CSegRemanence::~CSegRemanence()
{
delete _AniMat;
// Auto detach me from skeleton. Must do it here, not in ~CTransform().
if(_FatherSkeletonModel)
{
// detach me from the skeleton.
// hrc and clip hierarchy is modified.
_FatherSkeletonModel->detachSkeletonSon(this);
nlassert(_FatherSkeletonModel==NULL);
}
}
//===============================================================
CSegRemanence::CSegRemanence(CSegRemanence &other) : CTransformShape(other), _AniMat(NULL)
{
copyFromOther(other);
}
//===============================================================
CSegRemanence &CSegRemanence::operator = (CSegRemanence &other)
{
if (this != &other)
{
(CTransformShape &) *this = (CTransformShape &) other; // copy base
copyFromOther(other);
}
return *this;
}
//===============================================================
void CSegRemanence::copyFromOther(CSegRemanence &other)
{
if (this == &other) return;
CAnimatedMaterial *otherMat = other._AniMat != NULL ? new CAnimatedMaterial(*other._AniMat)
: NULL;
delete _AniMat;
_AniMat = otherMat;
std::copy(other._Samples, other._Samples + 4, _Samples);
_HeadSample = other._HeadSample;
_HeadProgress = other._HeadProgress;
//
_Pos = other._Pos; // sampled positions at each extremities of segment
_NumSlices = other._NumSlices;
_NumCorners = other._NumCorners;
_Started = other._Started;
_Stopping = other._Stopping;
_Restarted = other._Restarted;
_StartDate = other._StartDate;
_CurrDate = other._CurrDate;
_UnrollRatio = other._UnrollRatio;
_SliceTime = other._SliceTime;
_LastSampleFrame = other._LastSampleFrame;
}
//===============================================================
void CSegRemanence::registerBasic()
{
CScene::registerModel(SegRemanenceShapeId, TransformShapeId, CSegRemanence::creator);
}
// helper functions to fill vb
static inline void vbPush(uint8 *&dest, const CVector &v)
{
*(CVector *) dest = v;
dest +=sizeof(CVector);
}
static inline void vbPush(uint8 *&dest, float f)
{
*(float *) dest = f;
dest +=sizeof(float);
}
//===============================================================
void CSegRemanence::render(IDriver *drv, CMaterial &mat)
{
nlassert(_NumSlices >= 2);
nlassert(_NumCorners >= 2);
CSegRemanenceShape *srs = NLMISC::safe_cast<CSegRemanenceShape *>((IShape *) Shape);
// resize before locking because of volatile vb
_VB.setPreferredMemory(CVertexBuffer::AGPVolatile, false);
_VB.setVertexFormat(CVertexBuffer::PositionFlag|CVertexBuffer::TexCoord0Flag);
_VB.setNumVertices(_NumCorners * (_NumSlices + 1));
const uint vertexSize = _VB.getVertexSize();
// Fill Vertex Buffer part
{
CVertexBufferReadWrite vba;
_VB.lock (vba);
uint8 *datas = (uint8 *) vba.getVertexCoordPointer();
const uint8 *endDatas = datas + vertexSize *_VB.getNumVertices();
//
const CVector *src = &_Pos[0];
float deltaV = 1.f / (_NumCorners - 1);
// first slice
for(uint k = 0; k < _NumCorners; ++k)
{
vbPush(datas, *src++);
vbPush(datas, 0.f); // U
vbPush(datas, k * deltaV); // V
nlassert(datas <= endDatas);
}
float deltaU = 1.f / _NumSlices;
float baseU = _HeadProgress * deltaU;
for (uint l = 1; l < _NumSlices; ++l)
{
float currU = baseU + (l - 1) * deltaU;
for(uint k = 0; k < _NumCorners; ++k)
{
vbPush(datas, *src++);
vbPush(datas, currU); // U
vbPush(datas, k * deltaV); // V
nlassert(datas <= endDatas);
}
}
// last slice
const CVector *prevRow = src - _NumCorners;
for(uint k = 0; k < _NumCorners; ++k)
{
vbPush(datas, (1.f - _HeadProgress) * *src + _HeadProgress * *prevRow);
++ src;
++ prevRow;
vbPush(datas, 1.f); // U
vbPush(datas, k * deltaV); // V
nlassert(datas <= endDatas);
}
}
//
uint numQuads = (_NumCorners - 1) * _NumSlices;
// Fill Index Buffer part
{
_IB.setPreferredMemory(CIndexBuffer::RAMVolatile, false);
_IB.setFormat(CIndexBuffer::Indices16);
_IB.setNumIndexes(numQuads * 6);
//
CIndexBufferReadWrite iba;
_IB.lock(iba);
uint16 *indexPtr = (uint16 *) iba.getPtr();
for (uint l = 0; l < _NumSlices; ++l)
{
for(uint k = 0; k < (_NumCorners - 1); ++k)
{
*indexPtr++ = l * _NumCorners + k;
*indexPtr++ = l * _NumCorners + k + 1;
*indexPtr++ = (l + 1) * _NumCorners + k;
//
*indexPtr++ = l * _NumCorners + k + 1;
*indexPtr++ = (l + 1) * _NumCorners + k + 1;
*indexPtr++ = (l + 1) * _NumCorners + k;
}
}
nlassert(indexPtr == (uint16 *) iba.getPtr() + _IB.getNumIndexes());
}
// roll / unroll using texture matrix
CMatrix texMat;
texMat.setPos(NLMISC::CVector(1.f - _UnrollRatio, 0, 0));
if (mat.getTexture(0) != NULL)
mat.setUserTexMat(0, texMat);
drv->setupModelMatrix(CMatrix::Identity);
drv->activeVertexBuffer(_VB);
drv->activeIndexBuffer(_IB);
drv->renderTriangles(mat, 0, numQuads * 2);
// draw wire frame version if needed
#ifdef DEBUG_SEG_REMANENCE_DISPLAY
static CMaterial unlitWF;
unlitWF.initUnlit();
unlitWF.setDoubleSided(true);
IDriver::TPolygonMode oldPM = drv->getPolygonMode();
drv->setPolygonMode(IDriver::Line);
drv->renderTriangles(unlitWF, 0, numQuads * 2);
drv->setPolygonMode(oldPM);
#endif
CScene *scene = getOwnerScene();
// change unroll ratio
if (!_Stopping)
{
if (_UnrollRatio != 1.f)
_UnrollRatio = std::min(1.f, _UnrollRatio + scene->getEllapsedTime() / (srs->getNumSlices() * _SliceTime));
}
else
{
_UnrollRatio = std::max(0.f, _UnrollRatio - srs->getRollupRatio() * scene->getEllapsedTime() / (srs->getNumSlices() * _SliceTime));
if (_UnrollRatio == 0.f)
{
_Stopping = false;
_Started = false;
}
}
}
//===============================================================
void CSegRemanence::setupFromShape()
{
CSegRemanenceShape *srs = NLMISC::safe_cast<CSegRemanenceShape *>((IShape *) Shape);
if (srs->getNumCorners() != _NumCorners || srs->getNumSlices() != _NumSlices)
{
_NumCorners = srs->getNumCorners();
_NumSlices = srs->getNumSlices();
_Pos.resize(_NumCorners * (_NumSlices + 1));
for(uint k = 0; k < 4; ++k)
{
_Samples[k].Pos.resize(_NumSlices + 1);
}
}
updateOpacityFromShape();
}
//===============================================================
void CSegRemanence::samplePos(double date)
{
uint newHeadSample = (uint) floor(date / _SliceTime);
double sliceElapsedTime = date - (newHeadSample * _SliceTime);
_HeadProgress = (float) (sliceElapsedTime / _SliceTime);
NLMISC::clamp(_HeadProgress, 0.f, 1.f);
uint offset = newHeadSample - _HeadSample; // number of samples to remove
if(!_Restarted)
{
if (offset > 0)
{
offset = std::min(offset, (uint) _NumSlices);
_Samples[0].swap(_Samples[1]);
_Samples[1].swap(_Samples[2]);
_Samples[2].swap(_Samples[3]);
if (offset < _NumSlices + 1)
{
// make room for new position
memmove(&_Pos[_NumCorners * offset], &_Pos[0], sizeof(_Pos[0]) * _NumCorners * (_NumSlices + 1 - offset));
}
// else, too much time ellapsed, are sampled pos are invalidated
_HeadSample = newHeadSample;
}
}
_Samples[3].Date = date;
//
CSegRemanenceShape *srs = NLMISC::safe_cast<CSegRemanenceShape *>((IShape *) Shape);
// update positions for sample head
for(uint k = 0; k <_NumCorners;++k)
{
_Samples[3].Pos[k] = getWorldMatrix() * srs->getCorner(k);
}
if (_Restarted)
{
_HeadSample = newHeadSample;
_Samples[0] = _Samples[1] = _Samples[2] = _Samples[3];
CVector *head = &_Pos[0];
for(uint l = 0; l < _NumSlices + 1; ++l)
{
for(uint k = 0; k < _NumCorners;++k)
{
*head++ = _Samples[0].Pos[k];
}
}
_Restarted = false;
return;
}
// update head pos
CVector *head = &_Pos[0];
CVector *endPtr = head + _NumCorners * (_NumSlices + 1);
for(uint k = 0; k < _NumCorners;++k)
{
*head++ = _Samples[3].Pos[k];
}
// update current positions from sample pos
double currDate = _Samples[3].Date - sliceElapsedTime;
// interpolate linearly for 2 firstsamples
while (currDate > _Samples[2].Date && head != endPtr)
{
double dt = _Samples[3].Date - _Samples[2].Date;
float lambda = (float) (dt != 0 ? (currDate - _Samples[2].Date) / dt : 0);
for(uint k = 0; k < _NumCorners;++k)
{
*head++ = lambda * (_Samples[3].Pos[k] - _Samples[2].Pos[k]) + _Samples[2].Pos[k];
}
currDate -= _SliceTime;
}
if (head != endPtr)
{
// interpolate smoothly for remaining samples
while (currDate >= _Samples[1].Date)
{
double dt = _Samples[2].Date - _Samples[1].Date;
if (dt == 0)
{
for(uint k = 0; k < _NumCorners;++k)
{
*head++ = _Samples[2].Pos[k];
}
}
else
{
double lambda = (currDate - _Samples[1].Date) / dt;
CVector T0, T1;
for(uint k = 0; k < _NumCorners;++k)
{
if (_Samples[2].Date != _Samples[0].Date)
{
T0 = (float) dt * (_Samples[2].Pos[k] - _Samples[0].Pos[k]) / (float) (_Samples[2].Date - _Samples[0].Date);
}
else
{
T0= NLMISC::CVector::Null;
}
if (_Samples[3].Date != _Samples[1].Date)
{
T1 = (float) dt * (_Samples[3].Pos[k] - _Samples[1].Pos[k]) / (float) (_Samples[3].Date - _Samples[1].Date);
}
else
{
T1= NLMISC::CVector::Null;
}
BuildHermiteVector(_Samples[1].Pos[k], _Samples[2].Pos[k], T0, T1, *head, (float) lambda);
++ head;
}
}
if (head == endPtr) break;
currDate -= _SliceTime;
}
/*
// Version with no time correction
while (currDate >= _Samples[1].Date)
{
float lambda = (float) ((currDate - _Samples[1].Date) / (_Samples[2].Date - _Samples[1].Date));
for(uint k = 0; k < _NumCorners;++k)
{
CVector T1 = 0.5f * (_Samples[3].Pos[k] - _Samples[1].Pos[k]);
CVector T0 = 0.5f * (_Samples[2].Pos[k] - _Samples[0].Pos[k]);
BuildHermiteVector(_Samples[1].Pos[k], _Samples[2].Pos[k], T0, T1, *head, lambda);
++ head;
}
if (head == endPtr) break;
currDate -= _SliceTime;
}
*/
}
}
//===============================================================
void CSegRemanence::start()
{
if (_SliceTime == 0.f) return;
if (_Started && !_Stopping) return;
restart();
}
//===============================================================
void CSegRemanence::restart()
{
CSegRemanenceShape *srs = NLMISC::safe_cast<CSegRemanenceShape *>((IShape *) Shape);
if (!srs->getTextureShifting())
{
_UnrollRatio = 1.f;
}
else
{
if (!_Stopping)
_UnrollRatio = 0.f;
}
_Started = _Restarted = true;
_Stopping = false;
}
//===============================================================
void CSegRemanence::stop()
{
_Stopping = true;
}
//===============================================================
void CSegRemanence::stopNoUnroll()
{
_Started = _Restarted = _Stopping = false;
}
//===============================================================
void CSegRemanence::updateOpacityFromShape()
{
CSegRemanenceShape *srs = NLMISC::safe_cast<CSegRemanenceShape *>((IShape *) Shape);
bool transparent = srs->getMaterial().getBlend();
setTransparency(transparent);
setOpacity(!transparent);
}
//===============================================================
void CSegRemanence::setAnimatedMaterial(CAnimatedMaterial *mat)
{
if (mat == _AniMat) return;
delete _AniMat;
_AniMat = mat;
_AniMat->setFather(this, OwnerBit);
}
//===============================================================
void CSegRemanence::registerToChannelMixer(CChannelMixer *chanMixer, const std::string &prefix)
{
CTransformShape::registerToChannelMixer(chanMixer, prefix);
if (_AniMat)
{
_AniMat->registerToChannelMixer(chanMixer, prefix + _AniMat->getMaterialName() + ".") ;
}
}
//===============================================================
ITrack *CSegRemanence::getDefaultTrack (uint valueId)
{
CSegRemanenceShape *srs = NLMISC::safe_cast<CSegRemanenceShape *>((IShape *) Shape);
switch (valueId)
{
case PosValue: return srs->getDefaultPos();
case RotQuatValue: return srs->getDefaultRotQuat();
case ScaleValue: return srs->getDefaultScale();
}
return CTransformShape::getDefaultTrack(valueId);
return NULL;
}
//===============================================================
void CSegRemanence::traverseAnimDetail()
{
CTransformShape::traverseAnimDetail();
#ifndef DEBUG_SEG_REMANENCE_DISPLAY
if (isStarted())
#endif
{
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
CScene *scene = getOwnerScene();
if (scene->getNumRender() != (_LastSampleFrame + 1))
{
if (!isStopping())
{
// if wasn't visible at previous frame, must invalidate position
restart();
}
else
{
// ribbon started unrolling when it disapperaed from screen so simply remove it
stopNoUnroll();
}
}
_LastSampleFrame = scene->getNumRender();
setupFromShape();
samplePos(scene->getCurrentTime());
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// test if animated material must be updated.
if(IAnimatable::isTouched(CSegRemanence::OwnerBit))
{
if (getAnimatedMaterial())
getAnimatedMaterial()->update();
clearAnimatedMatFlag();
}
}
}
//===============================================================
void CSegRemanence::setSliceTime(float duration)
{
if ( duration != _SliceTime )
{
stopNoUnroll();
_SliceTime = duration;
}
}
}
Reference in a new issue View git blame Copy permalink